style and some minor fixes

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

1 files changed, 66 insertions, 105 deletions

diff --git a/src/gamma-coopgamma.c b/src/gamma-coopgamma.c
index fe01cb5..6c3da38 100644
--- a/src/gamma-coopgamma.c
+++ b/src/gamma-coopgamma.c
@@ -72,7 +72,8 @@ restore_signal_blockage(int signo, const struct signal_blockage *blockage)
 static int
 update(struct gamma_state *state)
 {
-	for (size_t i = 0; i < state->n_crtcs; i++)
+	size_t i;
+	for (i = 0; i < state->n_crtcs; i++)
 		libcoopgamma_set_gamma_sync(&state->crtcs[i].filter, &state->ctx);
 	return 0;
 }
@@ -81,21 +82,34 @@ update(struct gamma_state *state)
 static void
 print_error(struct gamma_state *state)
 {
-	const char* side = state->ctx.error.server_side ? _("server-side") : _("client-side");
+	unsigned long long int ec = (unsigned long long int)state->ctx.error.number;
 	if (state->ctx.error.custom) {
-		if (state->ctx.error.number != 0 && state->ctx.error.description != NULL)
-			fprintf(stderr, "%s error number %llu: %s\n",
-				side, (unsigned long long int)state->ctx.error.number,
-				state->ctx.error.description);
-		else if (state->ctx.error.number != 0)
-			fprintf(stderr, _("%s error number %llu\n"),
-				side, (unsigned long long int)state->ctx.error.number);
-		else if (state->ctx.error.description != NULL)
-			fprintf(stderr, _("%s error: %s\n"), side, state->ctx.error.description);
-	} else if (state->ctx.error.description != NULL) {
-		fprintf(stderr, _("%s error: %s\n"), side, state->ctx.error.description);
+		if (ec && state->ctx.error.description) {
+			if (state->ctx.error.server_side)
+				weprintf(_("Server-side error number %llu: %s."), ec, state->ctx.error.description);
+			else
+				weprintf(_("Client-side error number %llu: %s."), ec, state->ctx.error.description);
+		} else if (ec) {
+			if (state->ctx.error.server_side)
+				weprintf(_("Server-side error number %llu."), ec);
+			else
+				weprintf(_("Client-side error number %llu."), ec);
+		} else if (state->ctx.error.description) {
+			if (state->ctx.error.server_side)
+				weprintf(_("Server-side error: %s."), state->ctx.error.description);
+			else
+				weprintf(_("Client-side error: %s."), state->ctx.error.description);
+		}
+	} else if (state->ctx.error.description) {
+		if (state->ctx.error.server_side)
+			weprintf(_("Server-side error: %s."), state->ctx.error.description);
+		else
+			weprintf(_("Client-side error: %s."), state->ctx.error.description);
 	} else {
-		fprintf(stderr, _("%s error: %s\n"), side, strerror(state->ctx.error.number));
+		if (state->ctx.error.server_side)
+			weprintf(_("Server-side error: %s."), strerror(state->ctx.error.number));
+		else
+			weprintf(_("Client-side error: %s."), strerror(state->ctx.error.number));
 	}
 }
 
@@ -106,14 +120,10 @@ coopgamma_init(struct gamma_state **state)
 	struct gamma_state *s;
 	struct signal_blockage signal_blockage;
 
-	*state = malloc(sizeof(**state));
-	if (*state == NULL) return -1;
-
-	s = *state;
+	s = *state = ecalloc(1, sizeof(**state));
 
-	memset(s, 0, sizeof(*s));
 	if (libcoopgamma_context_initialise(&s->ctx)) {
-		perror("libcoopgamma_context_initialise");
+		weprintf("libcoopgamma_context_initialise:");
 		return -1;
 	}
 
@@ -122,9 +132,9 @@ coopgamma_init(struct gamma_state **state)
 		return -1;
 	s->methods = libcoopgamma_get_methods();
 	if (s->methods == NULL) {
-		perror("libcoopgamma_get_methods");
+		weprintf("libcoopgamma_get_methods:");
 		if (restore_signal_blockage(SIGCHLD, &signal_blockage) < 0)
-			exit(EXIT_FAILURE);
+			exit(1);
 		return -1;
 	}
 	if (restore_signal_blockage(SIGCHLD, &signal_blockage) < 0)
@@ -168,12 +178,11 @@ coopgamma_start(struct gamma_state *state, enum program_mode mode)
 		return -1;
 	if (libcoopgamma_connect(state->method, state->site, &state->ctx) < 0) {
 		if (errno)
-			perror("libcoopgamma_connect");
+			weprintf("libcoopgamma_connect:");
 		else
-			fprintf(stderr, _("libcoopgamma_connect: could not "
-					  "start coopgamma server\n"));
+			weprintf(_("libcoopgamma_connect: could not start coopgamma server."));
 		if (restore_signal_blockage(SIGCHLD, &signal_blockage) < 0)
-			exit(EXIT_FAILURE);
+			exit(1);
 		return -1;
 	}
 	if (restore_signal_blockage(SIGCHLD, &signal_blockage) < 0)
@@ -189,62 +198,42 @@ coopgamma_start(struct gamma_state *state, enum program_mode mode)
 
 	/* List available output if edid=list was used */
 	if (state->list_outputs) {
-		if (outputs == NULL) {
+		if (!outputs) {
 			print_error(state);
 			return -1;
 		}
 		printf(_("Available outputs:\n"));
 		for (i = 0; outputs[i]; i++)
 			printf("  %s\n", outputs[i]);
-		if (ferror(stdout)) {
-			perror("printf");
-			exit(EXIT_FAILURE);
-		}
-		exit(EXIT_SUCCESS);
+		if (ferror(stdout))
+			eprintf("printf:");
+		exit(0);
 	}
 
 	/* Translate crtc=N to edid=EDID */
 	for (i = 0; i < state->n_outputs; i++) {
-		if (state->outputs[i].edid != NULL)
+		if (state->outputs[i].edid)
 			continue;
 		if (state->outputs[i].index >= n_outputs) {
-			fprintf(stderr, _("monitor number %zu does not exist,"
-					  "available monitors are [0, %zu]\n"),
-				state->outputs[i].index, n_outputs - 1);
-			return -1;
-		}
-		state->outputs[i].edid = strdup(outputs[state->outputs[i].index]);
-		if (state->outputs[i].edid == NULL) {
-			perror("strdup");
+			weprintf(_("Monitor number %zu does not exist, available monitors are [0, %zu]"),
+			         state->outputs[i].index, n_outputs - 1);
 			return -1;
 		}
+		state->outputs[i].edid = estrdup(outputs[state->outputs[i].index]);
 	}
 
 	/* Use all outputs if none were specified */
 	if (state->n_outputs == 0) {
 		state->n_outputs = state->a_outputs = n_outputs;
-		state->outputs = malloc(n_outputs * sizeof(*state->outputs));
-		if (state->outputs == NULL) {
-			perror("malloc");
-			return -1;
-		}
-		for (i = 0; i < n_outputs; i++) {
-			state->outputs[i].edid = strdup(outputs[i]);
-			if (state->outputs[i].edid == NULL) {
-				perror("strdup");
-				return -1;
-			}
-		}
+		state->outputs = emalloc(n_outputs * sizeof(*state->outputs));
+		for (i = 0; i < n_outputs; i++)
+			state->outputs[i].edid = estrdup(outputs[i]);
 	}
 
 	free(outputs);
 
 	/* Initialise information for each output */
-	state->crtcs = calloc(state->n_outputs, sizeof(*state->crtcs));
-	if (state->crtcs == NULL) {
-		perror("calloc");
-		return -1;
-	}
+	state->crtcs = ecalloc(state->n_outputs, sizeof(*state->crtcs));
 	for (i = 0; i < state->n_outputs; i++) {
 		libcoopgamma_crtc_info_t info;
 		struct coopgamma_crtc_state *crtc = state->crtcs + state->n_crtcs;
@@ -263,19 +252,17 @@ coopgamma_start(struct gamma_state *state, enum program_mode mode)
 
 		if (libcoopgamma_get_gamma_info_sync(crtc->filter.crtc, &info, &state->ctx) < 0) {
 			int saved_errno = errno;
-			fprintf(stderr, _("failed to retrieve information for output `%s':\n"),
-				outputs[i]);
+			weprintf(_("Failed to retrieve information for output `%s':\n"), outputs[i]);
 			errno = saved_errno;
 			print_error(state);
 			return -1;
 		}
 		if (!info.cooperative) {
-			fprintf(stderr, _("coopgamma is not available\n"));
+			weprintf(_("coopgamma is not available.\n"));
 			return -1;
 		}
 		if (info.supported == LIBCOOPGAMMA_NO) {
-			fprintf(stderr, _("output `%s' does not support gamma "
-					  "adjustments, skipping\n"), outputs[i]);
+			weprintf(_("Output `%s' does not support gamma adjustments, skipping."), outputs[i]);
 			continue;
 		}
 
@@ -417,16 +404,14 @@ coopgamma_set_option(struct gamma_state *state, const char *key, const char *val
 		errno = 0;
 		priority = strtoll(value, &end, 10);
 		if (errno || *end || priority < INT64_MIN || priority > INT64_MAX) {
-			fprintf(stderr, _("value of method parameter `crtc' "
-					  "must be a integer in [%lli, %lli]\n"),
-				(long long int)INT64_MIN, (long long int)INT64_MAX);
+			weprintf(_("Value of method parameter `crtc' must be a integer in [%lli, %lli]."),
+			         (long long int)INT64_MIN, (long long int)INT64_MAX);
 			return -1;
 		}
 		state->priority = priority;
 	} else if (!strcasecmp(key, "method")) {
 		if (state->method != NULL) {
-			fprintf(stderr, _("method parameter `method' "
-					  "can only be used once\n"));
+			weprintf(_("Method parameter `method' can only be used once."));
 			return -1;
 		}
 		if (!strcasecmp(value, "list")) {
@@ -435,62 +420,40 @@ coopgamma_set_option(struct gamma_state *state, const char *key, const char *val
 			printf(_("Available adjustment methods for coopgamma:\n"));
 			for (i = 0; state->methods[i]; i++)
 				printf("  %s\n", state->methods[i]);
-			if (ferror(stdout)) {
-				perror("printf");
-				exit(EXIT_FAILURE);
-			}
+			if (ferror(stdout))
+				eprintf("printf:");
 			exit(EXIT_SUCCESS);
 		}
-		state->method = strdup(value);
-		if (state->method == NULL) {
-			perror("strdup");
-			return -1;
-		}
+		state->method = estrdup(value);
 	} else if (!strcasecmp(key, "display")) {
 		if (state->site != NULL) {
-			fprintf(stderr, _("method parameter `display' "
-					  "can only be used once\n"));
-			return -1;
-		}
-		state->site = strdup(value);
-		if (state->site == NULL) {
-			perror("strdup");
+			weprintf(_("Method parameter `display' can only be used once."));
 			return -1;
 		}
+		state->site = estrdup(value);
 	} else if (!strcasecmp(key, "edid") || !strcasecmp(key, "crtc")) {
 		if (state->n_outputs == state->a_outputs) {
 			state->a_outputs += 8;
-			state->outputs = realloc(state->outputs,
-						 state->a_outputs * sizeof(*state->outputs));
-			if (state->outputs == NULL) {
-				perror("realloc");
-				return -1;
-			}
+			state->outputs = erealloc(state->outputs, state->a_outputs * sizeof(*state->outputs));
 		}
 		if (!strcasecmp(key, "edid")) {
-			state->outputs[state->n_outputs].edid = strdup(value);
-			if (state->outputs[state->n_outputs].edid == NULL) {
-				perror("strdup");
-				return -1;
-			}
+			state->outputs[state->n_outputs].edid = estrdup(value);
 			if (!strcasecmp(state->outputs[state->n_outputs].edid, "list"))
 				state->list_outputs = 1;
 		} else {
 			state->outputs[state->n_outputs].edid = NULL;
 			errno = 0;
 			state->outputs[state->n_outputs].index = (size_t)strtoul(value, &end, 10);
-			if (!*end && errno == ERANGE &&
-			    state->outputs[state->n_outputs].index == SIZE_MAX) {
+			if (!*end && errno == ERANGE && state->outputs[state->n_outputs].index == SIZE_MAX) {
 				state->outputs[state->n_outputs].index = SIZE_MAX;
 			} else if (errno || *end) {
-				fprintf(stderr, _("value of method parameter `crtc' "
-						  "must be a non-negative integer\n"));
+				weprintf(_("Value of method parameter `crtc' must be a non-negative integer."));
 				return -1;
 			}
 		}
 		state->n_outputs++;
 	} else {
-		fprintf(stderr, _("Unknown method parameter: `%s'.\n"), key);
+		fprintf(stderr, _("Unknown method parameter: `%s'."), key);
 		return -1;
 	}
 
@@ -521,18 +484,16 @@ coopgamma_set_temperature(struct gamma_state *state, const struct color_setting
 		filter = &state->crtcs[i].filter;
 
 		/* Copy ramps for previous CRTC if its ramps is of same size and depth */
-		if (last_filter != NULL &&
+		if (last_filter &&
 		    last_filter->ramps.u8.red_size   == filter->ramps.u8.red_size &&
 		    last_filter->ramps.u8.green_size == filter->ramps.u8.green_size &&
 		    last_filter->ramps.u8.blue_size  == filter->ramps.u8.blue_size) {
-			memcpy(filter->ramps.u8.red, last_filter->ramps.u8.red,
-			       state->crtcs[i].rampsize);
+			memcpy(filter->ramps.u8.red, last_filter->ramps.u8.red, state->crtcs[i].rampsize);
 			continue;
 		}
 
 		/* Otherwise, create calculate the ramps */
-		memcpy(filter->ramps.u8.red, state->crtcs[i].plain_ramps.u8.red,
-		       state->crtcs[i].rampsize);
+		memcpy(filter->ramps.u8.red, state->crtcs[i].plain_ramps.u8.red, state->crtcs[i].rampsize);
 		switch (filter->depth) {
 #define X(SUFFIX, TYPE, MAX, TRUE_MAX, DEPTH)\
 		case DEPTH:\