Style and warnings

Signed-off-by: Mattias Andrée <m@maandree.se>

10 files changed, 286 insertions, 216 deletions

diff --git a/src/config-ini.c b/src/config-ini.c
index 89d55d5..24027d4 100644
--- a/src/config-ini.c
+++ b/src/config-ini.c
@@ -107,11 +107,13 @@ open_config_file(const char *filepath)
 		if (f == NULL && (env = getenv("XDG_CONFIG_DIRS")) != NULL &&
 		    env[0] != '\0') {
 			char *begin = env;
-			while (1) {
-				char *end = strchr(begin, ':');
+			char *end;
+			int len;
+			for (;;) {
+				end = strchr(begin, ':');
 				if (end == NULL) end = strchr(begin, '\0');
 
-				int len = end - begin;
+				len = (int)(end - begin);
 				if (len > 0) {
 					snprintf(cp, sizeof(cp),
 						 "%.*s/redshift/redshift.conf", len, begin);
@@ -153,19 +155,20 @@ int
 config_ini_init(struct config_ini_state *state, const char *filepath)
 {
 	struct config_ini_section *section = NULL;
+	char line[MAX_LINE_LENGTH];
+	char *s;
+	FILE *f;
+
 	state->sections = NULL;
 
-	FILE *f = open_config_file(filepath);
+	f = open_config_file(filepath);
 	if (f == NULL) {
 		/* Only a serious error if a file was explicitly requested. */
 		if (filepath != NULL) return -1;
 		return 0;
 	}
 
-	char line[MAX_LINE_LENGTH];
-	char *s;
-
-	while (1) {
+	for (;;) {
 		/* Handle the file input linewise. */
 		char *r = fgets(line, sizeof(line), f);
 		if (r == NULL) break;
@@ -215,8 +218,12 @@ config_ini_init(struct config_ini_state *state, const char *filepath)
 
 			memcpy(section->name, name, end - name + 1);
 		} else {
+			char *value, *end;
+			size_t value_len;
+			struct config_ini_setting *setting;
+
 			/* Split assignment at equals character. */
-			char *end = strchr(s, '=');
+			end = strchr(s, '=');
 			if (end == NULL || end == s) {
 				fputs(_("Malformed assignment in config"
 					" file.\n"), stderr);
@@ -225,8 +232,8 @@ config_ini_init(struct config_ini_state *state, const char *filepath)
 				return -1;
 			}
 
-			*end = '\0';
-			char *value = end + 1;
+			*end++ = '\0';
+			value = end;
 
 			if (section == NULL) {
 				fputs(_("Assignment outside section in config"
@@ -237,8 +244,7 @@ config_ini_init(struct config_ini_state *state, const char *filepath)
 			}
 
 			/* Create section. */
-			struct config_ini_setting *setting =
-				malloc(sizeof(struct config_ini_setting));
+			setting = malloc(sizeof(struct config_ini_setting));
 			if (setting == NULL) {
 				fclose(f);
 				config_ini_free(state);
@@ -252,17 +258,17 @@ config_ini_init(struct config_ini_state *state, const char *filepath)
 			section->settings = setting;
 
 			/* Copy name of setting. */
-			setting->name = malloc(end - s + 1);
+			setting->name = malloc(end - s);
 			if (setting->name == NULL) {
 				fclose(f);
 				config_ini_free(state);
 				return -1;
 			}
 
-			memcpy(setting->name, s, end - s + 1);
+			memcpy(setting->name, s, end - s);
 
 			/* Copy setting value. */
-			size_t value_len = strlen(value) + 1;
+			value_len = strlen(value) + 1;
 			setting->value = malloc(value_len);
 			if (setting->value == NULL) {
 				fclose(f);
diff --git a/src/gamma-coopgamma.c b/src/gamma-coopgamma.c
index 387e29b..4e579c2 100644
--- a/src/gamma-coopgamma.c
+++ b/src/gamma-coopgamma.c
@@ -100,12 +100,14 @@ print_error(struct gamma_state *state)
 static int
 coopgamma_init(struct gamma_state **state)
 {
-	*state = malloc(sizeof(struct gamma_state));
+	struct gamma_state *s;
+	struct signal_blockage signal_blockage;
+
+	*state = malloc(sizeof(**state));
 	if (*state == NULL) return -1;
 
-	struct gamma_state *s = *state;
+	s = *state;
 
-	struct signal_blockage signal_blockage;
 	memset(s, 0, sizeof(*s));
 	if (libcoopgamma_context_initialise(&s->ctx)) {
 		perror("libcoopgamma_context_initialise");
diff --git a/src/gamma-drm.c b/src/gamma-drm.c
index 7ed223d..e912f85 100644
--- a/src/gamma-drm.c
+++ b/src/gamma-drm.c
@@ -48,11 +48,13 @@ struct gamma_state {
 static int
 drm_init(struct gamma_state **state)
 {
+	struct gamma_state *s;
+
 	/* Initialize state. */
-	*state = malloc(sizeof(struct gamma_state));
+	*state = malloc(sizeof(**state));
 	if (*state == NULL) return -1;
 
-	struct gamma_state *s = *state;
+	s = *state;
 	s->card_num = 0;
 	s->crtc_num = -1;
 	s->fd = -1;
@@ -68,6 +70,8 @@ drm_start(struct gamma_state *state, enum program_mode mode)
 	/* Acquire access to a graphics card. */
 	long maxlen = strlen(DRM_DIR_NAME) + strlen(DRM_DEV_NAME) + 10;
 	char pathname[maxlen];
+	int crtc_count;
+	struct drm_crtc_state *crtcs;
 
 	sprintf(pathname, DRM_DEV_NAME, DRM_DIR_NAME, state->card_num);
 
@@ -91,7 +95,7 @@ drm_start(struct gamma_state *state, enum program_mode mode)
 	}
 
 	/* Create entries for selected CRTCs. */
-	int crtc_count = state->res->count_crtcs;
+	crtc_count = state->res->count_crtcs;
 	if (state->crtc_num >= 0) {
 		if (state->crtc_num >= crtc_count) {
 			fprintf(stderr, _("CRTC %d does not exist. "),
@@ -133,10 +137,11 @@ drm_start(struct gamma_state *state, enum program_mode mode)
 	}
 
 	/* Load CRTC information and gamma ramps. */
-	struct drm_crtc_state *crtcs = state->crtcs;
+	crtcs = state->crtcs;
 	for (; crtcs->crtc_num >= 0; crtcs++) {
+		drmModeCrtc *crtc_info;
 		crtcs->crtc_id = state->res->crtcs[crtcs->crtc_num];
-		drmModeCrtc* crtc_info = drmModeGetCrtc(state->fd, crtcs->crtc_id);
+		crtc_info = drmModeGetCrtc(state->fd, crtcs->crtc_id);
 		if (crtc_info == NULL) {
 			fprintf(stderr, _("CRTC %i lost, skipping\n"), crtcs->crtc_num);
 			continue;
@@ -259,6 +264,8 @@ drm_set_temperature(
 	uint16_t *r_gamma = NULL;
 	uint16_t *g_gamma = NULL;
 	uint16_t *b_gamma = NULL;
+	uint16_t value;
+	uint32_t i, ramp_size;
 
 	for (; crtcs->crtc_num >= 0; crtcs++) {
 		if (crtcs->gamma_size <= 1)
@@ -281,9 +288,9 @@ drm_set_temperature(
 		}
 
 		/* Initialize gamma ramps to pure state */
-		uint32_t ramp_size = crtcs->gamma_size;
-		for (uint32_t i = 0; i < ramp_size; i++) {
-			uint16_t value = (double)i/ramp_size * (UINT16_MAX+1);
+		ramp_size = crtcs->gamma_size;
+		for (i = 0; i < ramp_size; i++) {
+			value = (uint16_t)((double)i/ramp_size * (UINT16_MAX+1));
 			r_gamma[i] = value;
 			g_gamma[i] = value;
 			b_gamma[i] = value;
diff --git a/src/gamma-randr.c b/src/gamma-randr.c
index 713139a..9bbb807 100644
--- a/src/gamma-randr.c
+++ b/src/gamma-randr.c
@@ -48,11 +48,16 @@ struct gamma_state {
 static int
 randr_init(struct gamma_state **state)
 {
+	xcb_randr_query_version_cookie_t ver_cookie;
+	xcb_randr_query_version_reply_t *ver_reply;
+	xcb_generic_error_t *error;
+	struct gamma_state *s;
+
 	/* Initialize state. */
-	*state = malloc(sizeof(struct gamma_state));
+	*state = malloc(sizeof(**state));
 	if (*state == NULL) return -1;
 
-	struct gamma_state *s = *state;
+	s = *state;
 	s->screen_num = -1;
 	s->crtc_num = NULL;
 
@@ -60,17 +65,12 @@ randr_init(struct gamma_state **state)
 	s->crtc_count = 0;
 	s->crtcs = NULL;
 
-	xcb_generic_error_t *error;
-
 	/* Open X server connection */
 	s->conn = xcb_connect(NULL, &s->preferred_screen);
 
 	/* Query RandR version */
-	xcb_randr_query_version_cookie_t ver_cookie =
-		xcb_randr_query_version(s->conn, RANDR_VERSION_MAJOR,
-					RANDR_VERSION_MINOR);
-	xcb_randr_query_version_reply_t *ver_reply =
-		xcb_randr_query_version_reply(s->conn, ver_cookie, &error);
+	ver_cookie = xcb_randr_query_version(s->conn, RANDR_VERSION_MAJOR, RANDR_VERSION_MINOR);
+	ver_reply = xcb_randr_query_version_reply(s->conn, ver_cookie, &error);
 
 	/* TODO What does it mean when both error and ver_reply is NULL?
 	   Apparently, we have to check both to avoid seg faults. */
@@ -102,16 +102,22 @@ static int
 randr_start(struct gamma_state *state, enum program_mode mode)
 {
 	xcb_generic_error_t *error;
-
-	int screen_num = state->screen_num;
+	const xcb_setup_t *setup;
+	xcb_screen_iterator_t iter;
+	int i, screen_num;
+	xcb_randr_get_screen_resources_current_cookie_t res_cookie;
+	xcb_randr_get_screen_resources_current_reply_t *res_reply;
+	xcb_randr_crtc_t *crtcs;
+
+	screen_num = state->screen_num;
 	if (screen_num < 0) screen_num = state->preferred_screen;
 
 	/* Get screen */
-	const xcb_setup_t *setup = xcb_get_setup(state->conn);
-	xcb_screen_iterator_t iter = xcb_setup_roots_iterator(setup);
+	setup = xcb_get_setup(state->conn);
+	iter = xcb_setup_roots_iterator(setup);
 	state->screen = NULL;
 
-	for (int i = 0; iter.rem > 0; i++) {
+	for (i = 0; iter.rem > 0; i++) {
 		if (i == screen_num) {
 			state->screen = iter.data;
 			break;
@@ -126,10 +132,10 @@ randr_start(struct gamma_state *state, enum program_mode mode)
 	}
 
 	/* Get list of CRTCs for the screen */
-	xcb_randr_get_screen_resources_current_cookie_t res_cookie =
+	res_cookie =
 		xcb_randr_get_screen_resources_current(state->conn,
 						       state->screen->root);
-	xcb_randr_get_screen_resources_current_reply_t *res_reply =
+	res_reply =
 		xcb_randr_get_screen_resources_current_reply(state->conn,
 							     res_cookie,
 							     &error);
@@ -149,11 +155,10 @@ randr_start(struct gamma_state *state, enum program_mode mode)
 		return -1;
 	}
 
-	xcb_randr_crtc_t *crtcs =
-		xcb_randr_get_screen_resources_current_crtcs(res_reply);
+	crtcs = xcb_randr_get_screen_resources_current_crtcs(res_reply);
 
 	/* Save CRTC identifier in state */
-	for (int i = 0; i < state->crtc_count; i++) {
+	for (i = 0; i < state->crtc_count; i++) {
 		state->crtcs[i].crtc = crtcs[i];
 	}
 
@@ -162,16 +167,18 @@ randr_start(struct gamma_state *state, enum program_mode mode)
 	/* Save size and gamma ramps of all CRTCs.
 	   Current gamma ramps are saved so we can restore them
 	   at program exit. */
-	for (int i = 0; i < state->crtc_count; i++) {
+	for (i = 0; i < state->crtc_count; i++) {
 		xcb_randr_crtc_t crtc = state->crtcs[i].crtc;
+		xcb_randr_get_crtc_gamma_size_cookie_t gamma_size_cookie;
+		xcb_randr_get_crtc_gamma_size_reply_t *gamma_size_reply;
+		xcb_randr_get_crtc_gamma_cookie_t gamma_get_cookie;
+		xcb_randr_get_crtc_gamma_reply_t *gamma_get_reply;
+		uint16_t *gamma_r, *gamma_g, *gamma_b;
+		unsigned int ramp_size;
 
 		/* Request size of gamma ramps */
-		xcb_randr_get_crtc_gamma_size_cookie_t gamma_size_cookie =
-			xcb_randr_get_crtc_gamma_size(state->conn, crtc);
-		xcb_randr_get_crtc_gamma_size_reply_t *gamma_size_reply =
-			xcb_randr_get_crtc_gamma_size_reply(state->conn,
-							    gamma_size_cookie,
-							    &error);
+		gamma_size_cookie = xcb_randr_get_crtc_gamma_size(state->conn, crtc);
+		gamma_size_reply = xcb_randr_get_crtc_gamma_size_reply(state->conn, gamma_size_cookie, &error);
 
 		if (error) {
 			fprintf(stderr, _("`%s' returned error %d\n"),
@@ -180,7 +187,7 @@ randr_start(struct gamma_state *state, enum program_mode mode)
 			return -1;
 		}
 
-		unsigned int ramp_size = gamma_size_reply->size;
+		ramp_size = gamma_size_reply->size;
 		state->crtcs[i].ramp_size = ramp_size;
 
 		free(gamma_size_reply);
@@ -192,12 +199,8 @@ randr_start(struct gamma_state *state, enum program_mode mode)
 		}
 
 		/* Request current gamma ramps */
-		xcb_randr_get_crtc_gamma_cookie_t gamma_get_cookie =
-			xcb_randr_get_crtc_gamma(state->conn, crtc);
-		xcb_randr_get_crtc_gamma_reply_t *gamma_get_reply =
-			xcb_randr_get_crtc_gamma_reply(state->conn,
-						       gamma_get_cookie,
-						       &error);
+		gamma_get_cookie = xcb_randr_get_crtc_gamma(state->conn, crtc);
+		gamma_get_reply = xcb_randr_get_crtc_gamma_reply(state->conn, gamma_get_cookie, &error);
 
 		if (error) {
 			fprintf(stderr, _("`%s' returned error %d\n"),
@@ -205,12 +208,9 @@ randr_start(struct gamma_state *state, enum program_mode mode)
 			return -1;
 		}
 
-		uint16_t *gamma_r =
-			xcb_randr_get_crtc_gamma_red(gamma_get_reply);
-		uint16_t *gamma_g =
-			xcb_randr_get_crtc_gamma_green(gamma_get_reply);
-		uint16_t *gamma_b =
-			xcb_randr_get_crtc_gamma_blue(gamma_get_reply);
+		gamma_r = xcb_randr_get_crtc_gamma_red(gamma_get_reply);
+		gamma_g = xcb_randr_get_crtc_gamma_green(gamma_get_reply);
+		gamma_b = xcb_randr_get_crtc_gamma_blue(gamma_get_reply);
 
 		/* Allocate space for saved gamma ramps */
 		state->crtcs[i].saved_ramps =
@@ -302,12 +302,13 @@ randr_set_option(struct gamma_state *state, const char *key, const char *value)
 		state->screen_num = atoi(value);
 	} else if (strcasecmp(key, "crtc") == 0) {
 		char *tail;
+		int i, parsed;
 
 		/* Check how many crtcs are configured */
 		const char *local_value = value;
-		while (1) {
+		for (;;) {
 			errno = 0;
-			int parsed = strtol(local_value, &tail, 0);
+			parsed = strtol(local_value, &tail, 0);
 			if (parsed == 0 && (errno != 0 ||
 					    tail == local_value)) {
 				fprintf(stderr, _("Unable to read screen"
@@ -328,9 +329,9 @@ randr_set_option(struct gamma_state *state, const char *key, const char *value)
 		/* Configure all given crtcs */
 		state->crtc_num = calloc(state->crtc_num_count, sizeof(int));
 		local_value = value;
-		for (int i = 0; i < state->crtc_num_count; i++) {
+		for (i = 0; i < state->crtc_num_count; i++) {
 			errno = 0;
-			int parsed = strtol(local_value, &tail, 0);
+			parsed = strtol(local_value, &tail, 0);
 			if (parsed == 0 && (errno != 0 ||
 					    tail == local_value)) {
 				return -1;
@@ -363,7 +364,11 @@ randr_set_temperature_for_crtc(
 	struct gamma_state *state, int crtc_num, const struct color_setting *setting,
 	int preserve)
 {
+	xcb_randr_crtc_t crtc;
+	xcb_void_cookie_t gamma_set_cookie;
 	xcb_generic_error_t *error;
+	unsigned int i, ramp_size;
+	uint16_t *gamma_ramps, *gamma_r, *gamma_g, *gamma_b, value;
 
 	if (crtc_num >= state->crtc_count || crtc_num < 0) {
 		fprintf(stderr, _("CRTC %d does not exist. "),
@@ -378,19 +383,19 @@ randr_set_temperature_for_crtc(
 		return -1;
 	}
 
-	xcb_randr_crtc_t crtc = state->crtcs[crtc_num].crtc;
-	unsigned int ramp_size = state->crtcs[crtc_num].ramp_size;
+	crtc = state->crtcs[crtc_num].crtc;
+	ramp_size = state->crtcs[crtc_num].ramp_size;
 
 	/* Create new gamma ramps */
-	uint16_t *gamma_ramps = malloc(3*ramp_size*sizeof(uint16_t));
+	gamma_ramps = malloc(3*ramp_size*sizeof(uint16_t));
 	if (gamma_ramps == NULL) {
 		perror("malloc");
 		return -1;
 	}
 
-	uint16_t *gamma_r = &gamma_ramps[0*ramp_size];
-	uint16_t *gamma_g = &gamma_ramps[1*ramp_size];
-	uint16_t *gamma_b = &gamma_ramps[2*ramp_size];
+	gamma_r = &gamma_ramps[0*ramp_size];
+	gamma_g = &gamma_ramps[1*ramp_size];
+	gamma_b = &gamma_ramps[2*ramp_size];
 
 	if (preserve) {
 		/* Initialize gamma ramps from saved state */
@@ -398,8 +403,8 @@ randr_set_temperature_for_crtc(
 		       3*ramp_size*sizeof(uint16_t));
 	} else {
 		/* Initialize gamma ramps to pure state */
-		for (int i = 0; i < ramp_size; i++) {
-			uint16_t value = (double)i/ramp_size * (UINT16_MAX+1);
+		for (i = 0; i < ramp_size; i++) {
+			value = (double)i/ramp_size * (UINT16_MAX+1);
 			gamma_r[i] = value;
 			gamma_g[i] = value;
 			gamma_b[i] = value;
@@ -410,7 +415,7 @@ randr_set_temperature_for_crtc(
 			   ramp_size, ramp_size, setting);
 
 	/* Set new gamma ramps */
-	xcb_void_cookie_t gamma_set_cookie =
+	gamma_set_cookie =
 		xcb_randr_set_crtc_gamma_checked(state->conn, crtc,
 						 ramp_size, gamma_r,
 						 gamma_g, gamma_b);
diff --git a/src/gamma-vidmode.c b/src/gamma-vidmode.c
index 164437f..f88925a 100644
--- a/src/gamma-vidmode.c
+++ b/src/gamma-vidmode.c
@@ -34,10 +34,12 @@ struct gamma_state {
 static int
 vidmode_init(struct gamma_state **state)
 {
+	struct gamma_state *s;
+
 	*state = malloc(sizeof(struct gamma_state));
 	if (*state == NULL) return -1;
 
-	struct gamma_state *s = *state;
+	s = *state;
 	s->screen_num = -1;
 	s->saved_ramps = NULL;
 
@@ -56,12 +58,13 @@ vidmode_start(struct gamma_state *state, enum program_mode mode)
 {
 	int r;
 	int screen_num = state->screen_num;
+	int major, minor;
+	uint16_t *gamma_r, *gamma_g, *gamma_b;
 
 	if (screen_num < 0) screen_num = DefaultScreen(state->display);
 	state->screen_num = screen_num;
 
 	/* Query extension version */
-	int major, minor;
 	r = XF86VidModeQueryVersion(state->display, &major, &minor);
 	if (!r) {
 		fprintf(stderr, _("X request failed: %s\n"),
@@ -91,9 +94,9 @@ vidmode_start(struct gamma_state *state, enum program_mode mode)
 		return -1;
 	}
 
-	uint16_t *gamma_r = &state->saved_ramps[0*state->ramp_size];
-	uint16_t *gamma_g = &state->saved_ramps[1*state->ramp_size];
-	uint16_t *gamma_b = &state->saved_ramps[2*state->ramp_size];
+	gamma_r = &state->saved_ramps[0 * state->ramp_size];
+	gamma_g = &state->saved_ramps[1 * state->ramp_size];
+	gamma_b = &state->saved_ramps[2 * state->ramp_size];
 
 	/* Save current gamma ramps so we can restore them at program exit. */
 	r = XF86VidModeGetGammaRamp(state->display, state->screen_num,
@@ -172,18 +175,19 @@ static int
 vidmode_set_temperature(
 	struct gamma_state *state, const struct color_setting *setting, int preserve)
 {
-	int r;
+	int r, i;
+	uint16_t value, *gamma_ramps, *gamma_r, *gamma_g, *gamma_b;
 
 	/* Create new gamma ramps */
-	uint16_t *gamma_ramps = malloc(3*state->ramp_size*sizeof(uint16_t));
+	gamma_ramps = malloc(3*state->ramp_size*sizeof(uint16_t));
 	if (gamma_ramps == NULL) {
 		perror("malloc");
 		return -1;
 	}
 
-	uint16_t *gamma_r = &gamma_ramps[0*state->ramp_size];
-	uint16_t *gamma_g = &gamma_ramps[1*state->ramp_size];
-	uint16_t *gamma_b = &gamma_ramps[2*state->ramp_size];
+	gamma_r = &gamma_ramps[0 * state->ramp_size];
+	gamma_g = &gamma_ramps[1 * state->ramp_size];
+	gamma_b = &gamma_ramps[2 * state->ramp_size];
 
 	if (preserve) {
 		/* Initialize gamma ramps from saved state */
@@ -191,8 +195,8 @@ vidmode_set_temperature(
 		       3*state->ramp_size*sizeof(uint16_t));
 	} else {
 		/* Initialize gamma ramps to pure state */
-		for (int i = 0; i < state->ramp_size; i++) {
-			uint16_t value = (double)i/state->ramp_size *
+		for (i = 0; i < state->ramp_size; i++) {
+			value = (double)i/state->ramp_size *
 				(UINT16_MAX+1);
 			gamma_r[i] = value;
 			gamma_g[i] = value;
diff --git a/src/hooks.c b/src/hooks.c
index 485f5f0..8440874 100644
--- a/src/hooks.c
+++ b/src/hooks.c
@@ -38,6 +38,10 @@ open_hooks_dir(char *hp)
 {
 	char *env;
 
+#ifndef WINDOWS
+	struct passwd *pwd;
+#endif
+
 	if ((env = getenv("XDG_CONFIG_HOME")) != NULL &&
 	    env[0] != '\0') {
 		snprintf(hp, MAX_HOOK_PATH, "%s/redshift/hooks", env);
@@ -51,7 +55,7 @@ open_hooks_dir(char *hp)
 	}
 
 #ifndef WINDOWS
-	struct passwd *pwd = getpwuid(getuid());
+	pwd = getpwuid(getuid()); /* TODO check failure */
 	snprintf(hp, MAX_HOOK_PATH, "%s/.config/redshift/hooks", pwd->pw_dir);
 	return opendir(hp);
 #else
@@ -64,16 +68,20 @@ void
 hooks_signal_period_change(enum period prev_period, enum period period)
 {
 	char hooksdir_path[MAX_HOOK_PATH];
-	DIR *hooks_dir = open_hooks_dir(hooksdir_path);
+	DIR *hooks_dir;
+	struct dirent *ent;
+	char *hook_name;
+	char hook_path[MAX_HOOK_PATH];
+	int r;
+
+	hooks_dir = open_hooks_dir(hooksdir_path);
 	if (hooks_dir == NULL) return;
 
-	struct dirent* ent;
 	while ((ent = readdir(hooks_dir)) != NULL) {
 		/* Skip hidden and special files (., ..) */
 		if (ent->d_name[0] == '\0' || ent->d_name[0] == '.') continue;
 
-		char *hook_name = ent->d_name;
-		char hook_path[MAX_HOOK_PATH];
+		hook_name = ent->d_name;
 		snprintf(hook_path, sizeof(hook_path), "%s/%s",
 			 hooksdir_path, hook_name);
 
@@ -81,21 +89,23 @@ hooks_signal_period_change(enum period prev_period, enum period period)
 		/* Fork and exec the hook. We close stdout
 		   so the hook cannot interfere with the normal
 		   output. */
-		pid_t pid = fork();
-		if (pid == (pid_t)-1) {
+		switch (fork()) {
+		case -1:
 			perror("fork");
-			continue;
-		} else if (pid == 0) { /* Child */
+			break;
+		case 0:
 			close(STDOUT_FILENO);
 
-			int r = execl(hook_path, hook_name,
-				      "period-changed",
-				      period_names[prev_period],
-				      period_names[period], NULL);
+			r = execl(hook_path, hook_name,
+				  "period-changed",
+				  period_names[prev_period],
+				  period_names[period], NULL);
 			if (r < 0 && errno != EACCES) perror("execl");
 
 			/* Only reached on error */
 			_exit(EXIT_FAILURE);
+		default:
+			break;
 		}
 #endif
 	}
diff --git a/src/location-geoclue2.c b/src/location-geoclue2.c
index 329348e..773e99d 100644
--- a/src/location-geoclue2.c
+++ b/src/location-geoclue2.c
@@ -70,6 +70,10 @@ geoclue_client_signal_cb(GDBusProxy *client, gchar *sender_name,
 			 gpointer user_data)
 {
 	struct location_state *state = user_data;
+	const gchar *location_path;
+	GDBusProxy *location;
+	GError *error;
+	GVariant *lat_v, *lon_v;
 
 	/* Only handle LocationUpdated signals */
 	if (g_strcmp0(signal_name, "LocationUpdated") != 0) {
@@ -77,12 +81,11 @@ geoclue_client_signal_cb(GDBusProxy *client, gchar *sender_name,
 	}
 
 	/* Obtain location path */
-	const gchar *location_path;
 	g_variant_get_child(parameters, 1, "&o", &location_path);
 
 	/* Obtain location */
-	GError *error = NULL;
-	GDBusProxy *location = g_dbus_proxy_new_sync(
+	error = NULL;
+	location = g_dbus_proxy_new_sync(
 		g_dbus_proxy_get_connection(client),
 		G_DBUS_PROXY_FLAGS_NONE,
 		NULL,
@@ -101,12 +104,10 @@ geoclue_client_signal_cb(GDBusProxy *client, gchar *sender_name,
 	g_mutex_lock(&state->lock);
 
 	/* Read location properties */
-	GVariant *lat_v = g_dbus_proxy_get_cached_property(
-		location, "Latitude");
+	lat_v = g_dbus_proxy_get_cached_property(location, "Latitude");
 	state->location.lat = g_variant_get_double(lat_v);
 
-	GVariant *lon_v = g_dbus_proxy_get_cached_property(
-		location, "Longitude");
+	lon_v = g_dbus_proxy_get_cached_property(location, "Longitude");
 	state->location.lon = g_variant_get_double(lon_v);
 
 	state->available = 1;
@@ -122,10 +123,16 @@ on_name_appeared(GDBusConnection *conn, const gchar *name,
 		 const gchar *name_owner, gpointer user_data)
 {
 	struct location_state *state = user_data;
+	const gchar *client_path;
+	GDBusProxy *geoclue_client;
+	GVariant *client_path_v;
+	GDBusProxy *geoclue_manager;
+	GError *error;
+	GVariant *ret_v;
 
 	/* Obtain GeoClue Manager */
-	GError *error = NULL;
-	GDBusProxy *geoclue_manager = g_dbus_proxy_new_sync(
+	error = NULL;
+	geoclue_manager = g_dbus_proxy_new_sync(
 		conn,
 		G_DBUS_PROXY_FLAGS_NONE,
 		NULL,
@@ -143,7 +150,7 @@ on_name_appeared(GDBusConnection *conn, const gchar *name,
 
 	/* Obtain GeoClue Client path */
 	error = NULL;
-	GVariant *client_path_v =
+	client_path_v =
 		g_dbus_proxy_call_sync(geoclue_manager,
 				       "GetClient",
 				       NULL,
@@ -158,12 +165,11 @@ on_name_appeared(GDBusConnection *conn, const gchar *name,
 		return;
 	}
 
-	const gchar *client_path;
 	g_variant_get(client_path_v, "(&o)", &client_path);
 
 	/* Obtain GeoClue client */
 	error = NULL;
-	GDBusProxy *geoclue_client = g_dbus_proxy_new_sync(
+	geoclue_client = g_dbus_proxy_new_sync(
 		conn,
 		G_DBUS_PROXY_FLAGS_NONE,
 		NULL,
@@ -185,7 +191,7 @@ on_name_appeared(GDBusConnection *conn, const gchar *name,
 
 	/* Set desktop id (basename of the .desktop file) */
 	error = NULL;
-	GVariant *ret_v = g_dbus_proxy_call_sync(
+	ret_v = g_dbus_proxy_call_sync(
 		geoclue_client,
 		"org.freedesktop.DBus.Properties.Set",
 		g_variant_new("(ssv)",
@@ -289,12 +295,16 @@ static void *
 run_geoclue2_loop(void *state_)
 {
 	struct location_state *state = state_;
+	GMainContext *context;
+	guint watcher_id;
+	GIOChannel *pipe_channel;
+	GSource *pipe_source;
 
-	GMainContext *context = g_main_context_new();
+	context = g_main_context_new();
 	g_main_context_push_thread_default(context);
 	state->loop = g_main_loop_new(context, FALSE);
 
-	guint watcher_id = g_bus_watch_name(
+	watcher_id = g_bus_watch_name(
 		G_BUS_TYPE_SYSTEM,
 		"org.freedesktop.GeoClue2",
 		G_BUS_NAME_WATCHER_FLAGS_AUTO_START,
@@ -303,11 +313,9 @@ run_geoclue2_loop(void *state_)
 		state, NULL);
 
 	/* Listen for closure of pipe */
-	GIOChannel *pipe_channel = g_io_channel_unix_new(state->pipe_fd_write);
-	GSource *pipe_source = g_io_create_watch(
-		pipe_channel, G_IO_IN | G_IO_HUP | G_IO_ERR);
-        g_source_set_callback(
-		pipe_source, (GSourceFunc)on_pipe_closed, state, NULL);
+	pipe_channel = g_io_channel_unix_new(state->pipe_fd_write);
+	pipe_source = g_io_create_watch(pipe_channel, G_IO_IN | G_IO_HUP | G_IO_ERR);
+        g_source_set_callback(pipe_source, (GSourceFunc)on_pipe_closed, state, NULL);
         g_source_attach(pipe_source, context);
 
 	g_main_loop_run(state->loop);
@@ -330,7 +338,7 @@ location_geoclue2_init(struct location_state **state)
 #if !GLIB_CHECK_VERSION(2, 35, 0)
 	g_type_init();
 #endif
-	*state = malloc(sizeof(struct location_state));
+	*state = malloc(sizeof(**state));
 	if (*state == NULL) return -1;
 	return 0;
 }
@@ -338,6 +346,8 @@ location_geoclue2_init(struct location_state **state)
 static int
 location_geoclue2_start(struct location_state *state)
 {
+	int pipefds[2];
+
 	state->pipe_fd_read = -1;
 	state->pipe_fd_write = -1;
 
@@ -346,9 +356,7 @@ location_geoclue2_start(struct location_state *state)
 	state->location.lat = 0;
 	state->location.lon = 0;
 
-	int pipefds[2];
-	int r = pipeutils_create_nonblocking(pipefds);
-	if (r < 0) {
+	if (pipeutils_create_nonblocking(pipefds)) {
 		fputs(_("Failed to start GeoClue2 provider!\n"), stderr);
 		return -1;
 	}
diff --git a/src/location-manual.c b/src/location-manual.c
index b07ca4f..1a9b044 100644
--- a/src/location-manual.c
+++ b/src/location-manual.c
@@ -28,12 +28,11 @@ struct location_state {
 static int
 location_manual_init(struct location_state **state)
 {
-	*state = malloc(sizeof(struct location_state));
+	*state = malloc(sizeof(**state));
 	if (*state == NULL) return -1;
 
-	struct location_state *s = *state;
-	s->loc.lat = NAN;
-	s->loc.lon = NAN;
+	(*state)->loc.lat = NAN;
+	(*state)->loc.lon = NAN;
 
 	return 0;
 }
@@ -78,8 +77,10 @@ location_manual_set_option(struct location_state *state, const char *key,
 {
 	/* Parse float value */
 	char *end;
+	double v;
+
 	errno = 0;
-	double v = strtod(value, &end);
+	v = strtod(value, &end);
 	if (errno != 0 || *end != '\0') {
 		fputs(_("Malformed argument.\n"), stderr);
 		return -1;
diff --git a/src/options.c b/src/options.c
index 0f94c3c..95cb636 100644
--- a/src/options.c
+++ b/src/options.c
@@ -62,8 +62,9 @@ parse_gamma_string(const char *str, double gamma[3])
 		gamma[0] = gamma[1] = gamma[2] = g;
 	} else {
 		/* Parse separate value for each channel */
-		*(s++) = '\0';
-		char *g_s = s;
+		char *g_s;
+		*s++ = '\0';
+		g_s = s;
 		s = strchr(s, ':');
 		if (s == NULL) return -1;
 
@@ -82,8 +83,10 @@ static int
 parse_transition_time(const char *str, const char **end)
 {
 	const char *min = NULL;
+	long hours, minutes;
+
 	errno = 0;
-	long hours = strtol(str, (char **)&min, 10);
+	hours = strtol(str, (char **)&min, 10);
 	if (errno != 0 || min == str || min[0] != ':' ||
 	    hours < 0 || hours >= 24) {
 		return -1;
@@ -91,7 +94,7 @@ parse_transition_time(const char *str, const char **end)
 
 	min += 1;
 	errno = 0;
-	long minutes = strtol(min, (char **)end, 10);
+	minutes = strtol(min, (char **)end, 10);
 	if (errno != 0 || *end == min || minutes < 0 || minutes >= 60) {
 		return -1;
 	}
@@ -106,15 +109,17 @@ static int
 parse_transition_range(const char *str, struct time_range *range)
 {
 	const char *next = NULL;
-	int start_time = parse_transition_time(str, &next);
+	int start_time;
+	int end_time;
+
+	start_time = parse_transition_time(str, &next);
 	if (start_time < 0) return -1;
 
-	int end_time;
 	if (next[0] == '\0') {
 		end_time = start_time;
 	} else if (next[0] == '-') {
-		next += 1;
 		const char *end = NULL;
+		next += 1;
 		end_time = parse_transition_time(next, &end);
 		if (end_time < 0 || end[0] != '\0') return -1;
 	} else {
@@ -311,6 +316,8 @@ parse_command_line_option(
 {
 	int r;
 	char *s;
+	char *end;
+	char *provider_name;
 
 	switch (option) {
 	case 'b':
@@ -348,12 +355,11 @@ parse_command_line_option(
 			exit(EXIT_SUCCESS);
 		}
 
-		char *provider_name = NULL;
+		provider_name = NULL;
 
 		/* Don't save the result of strtof(); we simply want
 		   to know if value can be parsed as a float. */
 		errno = 0;
-		char *end;
 		strtof(value, &end);
 		if (errno == 0 && *end == ':') {
 			/* Use instead as arguments to `manual'. */
@@ -611,12 +617,14 @@ options_parse_config_file(
 	const struct gamma_method *gamma_methods,
 	const struct location_provider *location_providers)
 {
+	struct config_ini_section *section;
+	struct config_ini_setting *setting;
+
 	/* Read global config settings. */
-	struct config_ini_section *section = config_ini_get_section(
-		config_state, "redshift");
+	section = config_ini_get_section(config_state, "redshift");
 	if (section == NULL) return;
 
-	struct config_ini_setting *setting = section->settings;
+	setting = section->settings;
 	while (setting != NULL) {
 		int r = parse_config_file_option(
 			setting->name, setting->value, options,
diff --git a/src/redshift.c b/src/redshift.c
index be97912..bbbb30b 100644
--- a/src/redshift.c
+++ b/src/redshift.c
@@ -256,7 +256,9 @@ provider_try_start(const struct location_provider *provider,
 		   LOCATION_STATE **state, struct config_ini_state *config,
 		   char *args)
 {
-	int r;
+	const char *manual_keys[] = { "lat", "lon" };
+	struct config_ini_section *section;
+	int r, i;
 
 	r = provider->init(state);
 	if (r < 0) {
@@ -266,8 +268,7 @@ provider_try_start(const struct location_provider *provider,
 	}
 
 	/* Set provider options from config file. */
-	struct config_ini_section *section =
-		config_ini_get_section(config, provider->name);
+	section = config_ini_get_section(config, provider->name);
 	if (section != NULL) {
 		struct config_ini_setting *setting = section->settings;
 		while (setting != NULL) {
@@ -290,14 +291,17 @@ provider_try_start(const struct location_provider *provider,
 	}
 
 	/* Set provider options from command line. */
-	const char *manual_keys[] = { "lat", "lon" };
-	int i = 0;
+	i = 0;
 	while (args != NULL) {
-		char *next_arg = strchr(args, ':');
+		char *next_arg;
+		const char *key;
+		char *value;
+
+		next_arg = strchr(args, ':');
 		if (next_arg != NULL) *(next_arg++) = '\0';
 
-		const char *key = args;
-		char *value = strchr(args, '=');
+		key = args;
+		value = strchr(args, '=');
 		if (value == NULL) {
 			/* The options for the "manual" method can be set
 			   without keys on the command line for convencience
@@ -347,6 +351,7 @@ static int
 method_try_start(const struct gamma_method *method, GAMMA_STATE **state,
 		 enum program_mode mode, struct config_ini_state *config, char *args)
 {
+	struct config_ini_section *section;
 	int r;
 
 	r = method->init(state);
@@ -357,8 +362,7 @@ method_try_start(const struct gamma_method *method, GAMMA_STATE **state,
 	}
 
 	/* Set method options from config file. */
-	struct config_ini_section *section =
-		config_ini_get_section(config, method->name);
+	section = config_ini_get_section(config, method->name);
 	if (section != NULL) {
 		struct config_ini_setting *setting = section->settings;
 		while (setting != NULL) {
@@ -382,11 +386,15 @@ method_try_start(const struct gamma_method *method, GAMMA_STATE **state,
 
 	/* Set method options from command line. */
 	while (args != NULL) {
-		char *next_arg = strchr(args, ':');
+		char *next_arg;
+		const char *key;
+		char *value;
+
+		next_arg = strchr(args, ':');
 		if (next_arg != NULL) *(next_arg++) = '\0';
 
-		const char *key = args;
-		char *value = strchr(args, '=');
+		key = args;
+		value = strchr(args, '=');
 		if (value == NULL) {
 			fprintf(stderr, _("Failed to parse option `%s'.\n"),
 				args);
@@ -472,10 +480,13 @@ provider_get_location(
 	while (!available) {
 		int loc_fd = provider->get_fd(state);
 		if (loc_fd >= 0) {
+			double now;
+			double later;
+			int r;
+
 			/* Provider is dynamic. */
 			/* TODO: This should use a monotonic time source. */
-			double now;
-			int r = systemtime_get_time(&now);
+			r = systemtime_get_time(&now);
 			if (r < 0) {
 				fputs(_("Unable to read system time.\n"),
 				      stderr);
@@ -493,7 +504,6 @@ provider_get_location(
 				return 0;
 			}
 
-			double later;
 			r = systemtime_get_time(&later);
 			if (r < 0) {
 				fputs(_("Unable to read system time.\n"),
@@ -509,8 +519,8 @@ provider_get_location(
 		}
 
 
-		int r = provider->handle(state, loc, &available);
-		if (r < 0) return -1;
+		if (provider->handle(state, loc, &available) < 0)
+			return -1;
 	}
 
 	return 1;
@@ -542,30 +552,37 @@ run_continual_mode(const struct location_provider *provider,
 {
 	int r;
 
+	int done = 0;
+	int prev_disabled = 1;
+	int disabled = 0;
+	int location_available = 1;
+	struct color_setting fade_start_interp;
+	struct color_setting prev_target_interp;
+	struct color_setting interp;
+	struct location loc;
+	int need_location;
+
 	/* Short fade parameters */
 	int fade_length = 0;
 	int fade_time = 0;
-	struct color_setting fade_start_interp;
+
+	/* Save previous parameters so we can avoid printing status updates if
+	   the values did not change. */
+	enum period prev_period = PERIOD_NONE;
 
 	r = signals_install_handlers();
 	if (r < 0) {
 		return r;
 	}
 
-	/* Save previous parameters so we can avoid printing status updates if
-	   the values did not change. */
-	enum period prev_period = PERIOD_NONE;
-
 	/* Previous target color setting and current actual color setting.
 	   Actual color setting takes into account the current color fade. */
-	struct color_setting prev_target_interp;
 	color_setting_reset(&prev_target_interp);
 
-	struct color_setting interp;
 	color_setting_reset(&interp);
 
-	struct location loc = { NAN, NAN };
-	int need_location = !scheme->use_time;
+	loc = (struct location){ NAN, NAN };
+	need_location = !scheme->use_time;
 	if (need_location) {
 		fputs(_("Waiting for initial location"
 			" to become available...\n"), stderr);
@@ -593,11 +610,13 @@ run_continual_mode(const struct location_provider *provider,
 	}
 
 	/* Continuously adjust color temperature */
-	int done = 0;
-	int prev_disabled = 1;
-	int disabled = 0;
-	int location_available = 1;
-	while (1) {
+	for (;;) {
+		double now;
+		enum period period;
+		double transition_prog;
+		struct color_setting target_interp;
+		int delay, loc_fd;
+
 		/* Check to see if disable signal was caught */
 		if (disable && !done) {
 			disabled = !disabled;
@@ -625,15 +644,12 @@ run_continual_mode(const struct location_provider *provider,
 		prev_disabled = disabled;
 
 		/* Read timestamp */
-		double now;
 		r = systemtime_get_time(&now);
 		if (r < 0) {
 			fputs(_("Unable to read system time.\n"), stderr);
 			return -1;
 		}
 
-		enum period period;
-		double transition_prog;
 		if (scheme->use_time) {
 			int time_offset = get_seconds_since_midnight(now);
 
@@ -653,7 +669,6 @@ run_continual_mode(const struct location_provider *provider,
 
 		/* Use transition progress to get target color
 		   temperature. */
-		struct color_setting target_interp;
 		interpolate_transition_scheme(
 			scheme, transition_prog, &target_interp);
 
@@ -699,8 +714,7 @@ run_continual_mode(const struct location_provider *provider,
 
 		/* Handle ongoing fade */
 		if (fade_length != 0) {
-			fade_time += 1;
-			double frac = fade_time / (double)fade_length;
+			double frac = ++fade_time / (double)fade_length;
 			double alpha = CLAMP(0.0, ease_fade(frac), 1.0);
 
 			interpolate_color_settings(
@@ -745,23 +759,26 @@ run_continual_mode(const struct location_provider *provider,
 		prev_target_interp = target_interp;
 
 		/* Sleep length depends on whether a fade is ongoing. */
-		int delay = SLEEP_DURATION;
+		delay = SLEEP_DURATION;
 		if (fade_length != 0) {
 			delay = SLEEP_DURATION_SHORT;
 		}
 
 		/* Update location. */
-		int loc_fd = -1;
+		loc_fd = -1;
 		if (need_location) {
 			loc_fd = provider->get_fd(location_state);
 		}
 
 		if (loc_fd >= 0) {
-			/* Provider is dynamic. */
 			struct pollfd pollfds[1];
+			struct location new_loc;
+			int r, new_available;
+
+			/* Provider is dynamic. */
 			pollfds[0].fd = loc_fd;
 			pollfds[0].events = POLLIN;
-			int r = poll(pollfds, 1, delay);
+			r = poll(pollfds, 1, delay);
 			if (r < 0) {
 				if (errno == EINTR) continue;
 				perror("poll");
@@ -774,8 +791,6 @@ run_continual_mode(const struct location_provider *provider,
 
 			/* Get new location and availability
 			   information. */
-			struct location new_loc;
-			int new_available;
 			r = provider->handle(
 				location_state, &new_loc,
 				&new_available);
@@ -823,18 +838,6 @@ run_continual_mode(const struct location_provider *provider,
 int
 main(int argc, char *argv[])
 {
-	int r;
-
-#ifdef ENABLE_NLS
-	/* Init locale */
-	setlocale(LC_CTYPE, "");
-	setlocale(LC_MESSAGES, "");
-
-	/* Internationalisation */
-	bindtextdomain(PACKAGE, LOCALEDIR);
-	textdomain(PACKAGE);
-#endif
-
 	/* List of gamma methods. */
 	const struct gamma_method gamma_methods[] = {
 #ifdef ENABLE_COOPGAMMA
@@ -871,19 +874,35 @@ main(int argc, char *argv[])
 		{ NULL }
 	};
 
+	struct options options;
+	struct config_ini_state config_state;
+	struct transition_scheme *scheme;
+	GAMMA_STATE *method_state;
+	LOCATION_STATE *location_state;
+	int need_location;
+	int r;
+
+#ifdef ENABLE_NLS
+	/* Init locale */
+	setlocale(LC_CTYPE, "");
+	setlocale(LC_MESSAGES, "");
+
+	/* Internationalisation */
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+#endif
+
 	/* Flush messages consistently even if redirected to a pipe or
 	   file.  Change the flush behaviour to line-buffered, without
 	   changing the actual buffers being used. */
 	setvbuf(stdout, NULL, _IOLBF, 0);
 	setvbuf(stderr, NULL, _IOLBF, 0);
 
-	struct options options;
 	options_init(&options);
 	options_parse_args(
 		&options, argc, argv, gamma_methods, location_providers);
 
 	/* Load settings from config file. */
-	struct config_ini_state config_state;
 	r = config_ini_init(&config_state, options.config_filepath);
 	if (r < 0) {
 		fputs("Unable to load config file.\n", stderr);
@@ -921,10 +940,9 @@ main(int argc, char *argv[])
 
 	/* Initialize location provider if needed. If provider is NULL
 	   try all providers until one that works is found. */
-	LOCATION_STATE *location_state;
 
 	/* Location is not needed for reset mode and manual mode. */
-	int need_location =
+	need_location =
 		options.mode != PROGRAM_MODE_RESET &&
 		options.mode != PROGRAM_MODE_MANUAL &&
 		!options.scheme.use_time;
@@ -1052,11 +1070,10 @@ main(int argc, char *argv[])
 		       options.scheme.night.gamma[2]);
 	}
 
-	struct transition_scheme *scheme = &options.scheme;
+	scheme = &options.scheme;
 
 	/* Initialize gamma adjustment method. If method is NULL
 	   try all methods until one that works is found. */
-	GAMMA_STATE *method_state;
 
 	/* Gamma adjustment not needed for print mode */
 	if (options.mode != PROGRAM_MODE_PRINT) {
@@ -1068,7 +1085,8 @@ main(int argc, char *argv[])
 			if (r < 0) exit(EXIT_FAILURE);
 		} else {
 			/* Try all methods, use the first that works. */
-			for (int i = 0; gamma_methods[i].name != NULL; i++) {
+			int i;
+			for (i = 0; gamma_methods[i].name != NULL; i++) {
 				const struct gamma_method *m = &gamma_methods[i];
 				if (!m->autostart) continue;
 
@@ -1100,14 +1118,17 @@ main(int argc, char *argv[])
 	case PROGRAM_MODE_PRINT:
 	{
 		struct location loc = { NAN, NAN };
+		double now;
+		enum period period;
+		double transition_prog;
+		struct color_setting interp;
+
 		if (need_location) {
 			fputs(_("Waiting for current location"
 				" to become available...\n"), stderr);
 
 			/* Wait for location provider. */
-			int r = provider_get_location(
-				options.provider, location_state, -1, &loc);
-			if (r < 0) {
+			if (provider_get_location(options.provider, location_state, -1, &loc) < 0) {
 				fputs(_("Unable to get location"
 					" from provider.\n"), stderr);
 				exit(EXIT_FAILURE);
@@ -1120,7 +1141,6 @@ main(int argc, char *argv[])
 			print_location(&loc);
 		}
 
-		double now;
 		r = systemtime_get_time(&now);
 		if (r < 0) {
 			fputs(_("Unable to read system time.\n"), stderr);
@@ -1128,8 +1148,6 @@ main(int argc, char *argv[])
 			exit(EXIT_FAILURE);
 		}
 
-		enum period period;
-		double transition_prog;
 		if (options.scheme.use_time) {
 			int time_offset = get_seconds_since_midnight(now);
 			period = get_period_from_time(scheme, time_offset);
@@ -1152,7 +1170,6 @@ main(int argc, char *argv[])
 		}
 
 		/* Use transition progress to set color temperature */
-		struct color_setting interp;
 		interpolate_transition_scheme(
 			scheme, transition_prog, &interp);
 
@@ -1188,13 +1205,15 @@ main(int argc, char *argv[])
 	break;
 	case PROGRAM_MODE_MANUAL:
 	{
+		struct color_setting manual;
+
 		if (options.verbose) {
 			printf(_("Color temperature: %uK\n"),
 			       options.temp_set);
 		}
 
 		/* Adjust temperature */
-		struct color_setting manual = scheme->day;
+		manual = scheme->day;
 		manual.temperature = options.temp_set;
 		r = options.method->set_temperature(
 			method_state, &manual, options.preserve_gamma);