style

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

1 files changed, 84 insertions, 160 deletions

diff --git a/src/redshift.c b/src/redshift.c
index 53042db..70cdf38 100644
--- a/src/redshift.c
+++ b/src/redshift.c
@@ -758,8 +758,12 @@ main(int argc, char *argv[])
 	struct transition_scheme *scheme;
 	GAMMA_STATE *method_state;
 	LOCATION_STATE *location_state;
-	int need_location;
-	int r;
+	int r, need_location;
+	size_t i;
+	struct location loc = { NAN, NAN };
+	double now, transition_prog;
+	enum period period;
+	struct color_setting color;
 
 	argv0 = argv[0];
 
@@ -780,20 +784,15 @@ main(int argc, char *argv[])
 	setvbuf(stderr, NULL, _IOLBF, 0);
 
 	options_init(&options);
-	options_parse_args(
-		&options, argc, argv, gamma_methods, location_providers);
+	options_parse_args(&options, argc, argv, gamma_methods, location_providers);
 
 	/* Load settings from config file. */
-	r = config_ini_init(&config_state, options.config_filepath);
-	if (r < 0) {
-		fputs("Unable to load config file.\n", stderr);
-		exit(EXIT_FAILURE);
-	}
+	if (config_ini_init(&config_state, options.config_filepath) < 0)
+		eprintf(_("Unable to load config file."));
 
 	free(options.config_filepath);
 
-	options_parse_config_file(
-		&options, &config_state, gamma_methods, location_providers);
+	options_parse_config_file(&options, &config_state, gamma_methods, location_providers);
 
 	options_set_defaults(&options);
 
@@ -801,12 +800,12 @@ main(int argc, char *argv[])
 	    options.scheme.dusk.start >= 0 || options.scheme.dusk.end >= 0) {
 		if (options.scheme.dawn.start < 0 || options.scheme.dawn.end < 0 ||
 		    options.scheme.dusk.start < 0 || options.scheme.dusk.end < 0)
-			eprintf(_("Partial time-configuration not supported!\n"));
+			eprintf(_("Partial time-configuration not supported!"));
 
 		if (options.scheme.dawn.start > options.scheme.dawn.end ||
 		    options.scheme.dawn.end > options.scheme.dusk.start ||
 		    options.scheme.dusk.start > options.scheme.dusk.end)
-			eprintf(_("Invalid dawn/dusk time configuration!\n"));
+			eprintf(_("Invalid dawn/dusk time configuration!"));
 
 		options.scheme.use_time = 1;
 	}
@@ -821,24 +820,15 @@ main(int argc, char *argv[])
 	if (need_location) {
 		if (options.provider) {
 			/* Use provider specified on command line. */
-			r = provider_try_start(options.provider, &location_state,
-			                       &config_state, options.provider_args);
-			if (r < 0)
+			if (provider_try_start(options.provider, &location_state, &config_state, options.provider_args) < 0)
 				exit(EXIT_FAILURE);
 		} else {
 			/* Try all providers, use the first that works. */
-			for (int i = 0;
-			     location_providers[i].name != NULL; i++) {
-				const struct location_provider *p =
-					&location_providers[i];
-				fprintf(stderr,
-					_("Trying location provider `%s'...\n"),
-					p->name);
-				r = provider_try_start(p, &location_state,
-						       &config_state, NULL);
-				if (r < 0) {
-					fputs(_("Trying next provider...\n"),
-					      stderr);
+			for (i = 0; location_providers[i].name != NULL; i++) {
+				const struct location_provider *p = &location_providers[i];
+				weprintf(_("Trying location provider `%s'..."), p->name);
+				if (provider_try_start(p, &location_state, &config_state, NULL) < 0) {
+					weprintf(_("Trying next provider..."));
 					continue;
 				}
 
@@ -848,20 +838,14 @@ main(int argc, char *argv[])
 				break;
 			}
 
-			/* Failure if no providers were successful at this
-			   point. */
-			if (options.provider == NULL) {
-				fputs(_("No more location providers"
-					" to try.\n"), stderr);
-				exit(EXIT_FAILURE);
-			}
+			/* Failure if no providers were successful at this point. */
+			if (!options.provider)
+				eprintf(_("No more location providers to try."));
 		}
 
 		/* Solar elevations */
 		if (options.scheme.high < options.scheme.low) {
-			fprintf(stderr,
-				_("High transition elevation cannot be lower than"
-				  " the low transition elevation.\n"));
+			weprintf(_("High transition elevation cannot be lower than the low transition elevation."));
 			exit(EXIT_FAILURE);
 		}
 
@@ -876,56 +860,37 @@ main(int argc, char *argv[])
 	    options.mode != PROGRAM_MODE_MANUAL) {
 		if (options.verbose) {
 			printf(_("Temperatures: %iK at day, %iK at night\n"),
-			       options.scheme.day.temperature,
-			       options.scheme.night.temperature);
+			       options.scheme.day.temperature, options.scheme.night.temperature);
 		}
 
 		/* Color temperature */
 		if (options.scheme.day.temperature < MIN_TEMP ||
 		    options.scheme.day.temperature > MAX_TEMP ||
 		    options.scheme.night.temperature < MIN_TEMP ||
-		    options.scheme.night.temperature > MAX_TEMP) {
-			fprintf(stderr,
-				_("Temperature must be between %uK and %uK.\n"),
-				MIN_TEMP, MAX_TEMP);
-			exit(EXIT_FAILURE);
-		}
+		    options.scheme.night.temperature > MAX_TEMP)
+			eprintf(_("Temperature must be between %uK and %uK."), MIN_TEMP, MAX_TEMP);
 	}
 
 	if (options.mode == PROGRAM_MODE_MANUAL) {
 		/* Check color temperature to be set */
-		if (options.temp_set < MIN_TEMP ||
-		    options.temp_set > MAX_TEMP) {
-			fprintf(stderr,
-				_("Temperature must be between %uK and %uK.\n"),
-				MIN_TEMP, MAX_TEMP);
-			exit(EXIT_FAILURE);
-		}
+		if (options.temp_set < MIN_TEMP || options.temp_set > MAX_TEMP)
+			eprintf(_("Temperature must be between %uK and %uK."), MIN_TEMP, MAX_TEMP);
 	}
 
 	/* Brightness */
 	if (options.scheme.day.brightness < MIN_BRIGHTNESS ||
 	    options.scheme.day.brightness > MAX_BRIGHTNESS ||
 	    options.scheme.night.brightness < MIN_BRIGHTNESS ||
-	    options.scheme.night.brightness > MAX_BRIGHTNESS) {
-		fprintf(stderr,
-			_("Brightness values must be between %.1f and %.1f.\n"),
-			MIN_BRIGHTNESS, MAX_BRIGHTNESS);
-		exit(EXIT_FAILURE);
-	}
+	    options.scheme.night.brightness > MAX_BRIGHTNESS)
+		eprintf(_("Brightness values must be between %.1f and %.1f."), MIN_BRIGHTNESS, MAX_BRIGHTNESS);
 
-	if (options.verbose) {
-		printf(_("Brightness: %.2f:%.2f\n"),
-		       options.scheme.day.brightness,
-		       options.scheme.night.brightness);
-	}
+	if (options.verbose)
+		printf(_("Brightness: %.2f:%.2f\n"), options.scheme.day.brightness, options.scheme.night.brightness);
 
 	/* Gamma */
 	if (!gamma_is_valid(options.scheme.day.gamma) ||
 	    !gamma_is_valid(options.scheme.night.gamma)) {
-		fprintf(stderr,
-			_("Gamma value must be between %.1f and %.1f.\n"),
-			MIN_GAMMA, MAX_GAMMA);
+		weprintf(_("Gamma value must be between %.1f and %.1f."), MIN_GAMMA, MAX_GAMMA);
 		exit(EXIT_FAILURE);
 	}
 
@@ -949,23 +914,21 @@ main(int argc, char *argv[])
 
 	/* Gamma adjustment not needed for print mode */
 	if (options.mode != PROGRAM_MODE_PRINT) {
-		if (options.method != NULL) {
+		if (options.method) {
 			/* Use method specified on command line. */
-			r = method_try_start(
-				options.method, &method_state, options.mode, &config_state,
-				options.method_args);
-			if (r < 0) exit(EXIT_FAILURE);
+			r = method_try_start(options.method, &method_state, options.mode,
+			                     &config_state, options.method_args);
+			if (r < 0)
+				exit(EXIT_FAILURE);
 		} else {
 			/* Try all methods, use the first that works. */
-			int i;
-			for (i = 0; gamma_methods[i].name != NULL; i++) {
+			for (i = 0; gamma_methods[i].name; i++) {
 				const struct gamma_method *m = &gamma_methods[i];
-				if (!m->autostart) continue;
+				if (!m->autostart)
+					continue;
 
-				r = method_try_start(
-					m, &method_state, options.mode, &config_state, NULL);
-				if (r < 0) {
-					fputs(_("Trying next method...\n"), stderr);
+				if (method_try_start(m, &method_state, options.mode, &config_state, NULL) < 0) {
+					weprintf(_("Trying next method..."));
 					continue;
 				}
 
@@ -976,10 +939,8 @@ main(int argc, char *argv[])
 			}
 
 			/* Failure if no methods were successful at this point. */
-			if (options.method == NULL) {
-				fputs(_("No more methods to try.\n"), stderr);
-				exit(EXIT_FAILURE);
-			}
+			if (!options.method)
+				eprintf(_("No more methods to try."));
 		}
 	}
 
@@ -988,78 +949,55 @@ main(int argc, char *argv[])
 	switch (options.mode) {
 	case PROGRAM_MODE_ONE_SHOT:
 	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);
+			weprintf(_("Waiting for current location to become available..."));
 
 			/* Wait for location provider. */
-			if (provider_get_location(options.provider, location_state, -1, &loc) < 0) {
-				fputs(_("Unable to get location"
-					" from provider.\n"), stderr);
-				exit(EXIT_FAILURE);
-			}
+			if (provider_get_location(options.provider, location_state, -1, &loc) < 0)
+				eprintf(_("Unable to get location from provider."));
 
-			if (!location_is_valid(&loc)) {
-				exit(EXIT_FAILURE);
-			}
+			if (!location_is_valid(&loc))
+				exit(1);
 
 			print_location(&loc);
 		}
 
 		r = systemtime_get_time(&now);
 		if (r < 0) {
-			fputs(_("Unable to read system time.\n"), stderr);
+			weprintf(_("Unable to read system time."));
 			options.method->free(method_state);
-			exit(EXIT_FAILURE);
+			exit(1);
 		}
 
 		if (options.scheme.use_time) {
 			int time_offset = get_seconds_since_midnight(now);
 			period = get_period_from_time(scheme, time_offset);
-			transition_prog = get_transition_progress_from_time(
-				scheme, time_offset);
+			transition_prog = get_transition_progress_from_time(scheme, time_offset);
 		} else {
 			/* Current angular elevation of the sun */
-			double elevation = solar_elevation(
-				now, loc.lat, loc.lon);
+			double elevation = solar_elevation(now, loc.lat, loc.lon);
 			if (options.verbose) {
-				/* TRANSLATORS: Append degree symbol if
-				   possible. */
+				/* TRANSLATORS: Append degree symbol if possible. */
 				printf(_("Solar elevation: %f\n"), elevation);
 			}
 
 			period = get_period_from_elevation(scheme, elevation);
-			transition_prog =
-				get_transition_progress_from_elevation(
-					scheme, elevation);
+			transition_prog = get_transition_progress_from_elevation(scheme, elevation);
 		}
 
 		/* Use transition progress to set color temperature */
-		interpolate_transition_scheme(
-			scheme, transition_prog, &interp);
+		interpolate_transition_scheme(scheme, transition_prog, &color);
 
 		if (options.verbose || options.mode == PROGRAM_MODE_PRINT) {
 			print_period(period, transition_prog);
-			printf(_("Color temperature: %uK\n"),
-			       interp.temperature);
-			printf(_("Brightness: %.2f\n"),
-			       interp.brightness);
+			printf(_("Color temperature: %uK\n"), color.temperature);
+			printf(_("Brightness: %.2f\n"), color.brightness);
 		}
 
 		if (options.mode != PROGRAM_MODE_PRINT) {
 			/* Adjust temperature */
-			r = options.method->set_temperature(
-				method_state, &interp, options.preserve_gamma);
-			if (r < 0) {
-				fputs(_("Temperature adjustment failed.\n"),
-				      stderr);
+			if (options.method->set_temperature(method_state, &color, options.preserve_gamma) < 0) {
+				weprintf(_("Temperature adjustment failed."));
 				options.method->free(method_state);
 				exit(EXIT_FAILURE);
 			}
@@ -1068,29 +1006,23 @@ main(int argc, char *argv[])
 			   automatically revert when the process exits.
 			   Therefore, we have to loop until CTRL-C is received.
 			   */
-			if (strcmp(options.method->name, "quartz") == 0) {
-				fputs(_("Press ctrl-c to stop...\n"), stderr);
+			if (!strcmp(options.method->name, "quartz")) {
+				weprintf(_("Press ctrl-c to stop..."));
 				pause();
 			}
 		}
-	}
-	break;
-	case PROGRAM_MODE_MANUAL:
-	{
-		struct color_setting manual;
+		break;
 
-		if (options.verbose) {
-			printf(_("Color temperature: %uK\n"),
-			       options.temp_set);
-		}
+	case PROGRAM_MODE_MANUAL:
+		if (options.verbose)
+			printf(_("Color temperature: %uK\n"), options.temp_set);
 
 		/* Adjust temperature */
-		manual = scheme->day;
-		manual.temperature = options.temp_set;
-		r = options.method->set_temperature(
-			method_state, &manual, options.preserve_gamma);
+		color = scheme->day;
+		color.temperature = options.temp_set;
+		r = options.method->set_temperature(method_state, &color, options.preserve_gamma);
 		if (r < 0) {
-			fputs(_("Temperature adjustment failed.\n"), stderr);
+			weprintf(_("Temperature adjustment failed."));
 			options.method->free(method_state);
 			exit(EXIT_FAILURE);
 		}
@@ -1098,21 +1030,18 @@ main(int argc, char *argv[])
 		/* In Quartz (OSX) the gamma adjustments will automatically
 		   revert when the process exits. Therefore, we have to loop
 		   until CTRL-C is received. */
-		if (strcmp(options.method->name, "quartz") == 0) {
-			fputs(_("Press ctrl-c to stop...\n"), stderr);
+		if (!strcmp(options.method->name, "quartz")) {
+			weprintf(_("Press ctrl-c to stop..."));
 			pause();
 		}
-	}
-	break;
+		break;
+
 	case PROGRAM_MODE_RESET:
-	{
 		/* Reset screen */
-		struct color_setting reset;
-		color_setting_reset(&reset);
+		color_setting_reset(&color);
 
-		r = options.method->set_temperature(method_state, &reset, 0);
-		if (r < 0) {
-			fputs(_("Temperature adjustment failed.\n"), stderr);
+		if (options.method->set_temperature(method_state, &color, 0) < 0) {
+			weprintf(_("Temperature adjustment failed."));
 			options.method->free(method_state);
 			exit(EXIT_FAILURE);
 		}
@@ -1120,23 +1049,18 @@ main(int argc, char *argv[])
 		/* In Quartz (OSX) the gamma adjustments will automatically
 		   revert when the process exits. Therefore, we have to loop
 		   until CTRL-C is received. */
-		if (strcmp(options.method->name, "quartz") == 0) {
-			fputs(_("Press ctrl-c to stop...\n"), stderr);
+		if (!strcmp(options.method->name, "quartz")) {
+			weprintf(_("Press ctrl-c to stop..."));
 			pause();
 		}
-	}
-	break;
+		break;
+
 	case PROGRAM_MODE_CONTINUAL:
-	{
-		r = run_continual_mode(
-			options.provider, location_state, scheme,
-			options.method, method_state,
-			options.use_fade, options.preserve_gamma,
-			options.verbose);
+		r = run_continual_mode(options.provider, location_state, scheme, options.method, method_state,
+		                       options.use_fade, options.preserve_gamma, options.verbose);
 		if (r < 0)
 			exit(EXIT_FAILURE);
-	}
-	break;
+		break;
 	}
 
 	/* Clean up gamma adjustment state */