Coding style: reindent to Linux KNF

Signed-off-by: Joachim Nilsson <troglobit@gmail.com>

src/helpers.c

@@ -6,229 +6,209 @@
 #include <sys/types.h>
 #include <dirent.h>
 
-LIGHT_BOOL light_readUInt(char const * filename, unsigned int *i)
+bool light_readUInt(char const *filename, unsigned int *i)
 {
-  FILE* fileHandle;
-  unsigned int iCopy;
-
-  fileHandle = fopen(filename, "r");
-
-  if(!fileHandle)
-  {
-    LIGHT_PERMERR("reading");
-    return FALSE;
-  }
-
-  if(fscanf(fileHandle, "%u", &iCopy) != 1)
-  {
-    LIGHT_ERR_FMT("Couldn't parse a positive integer number from '%s'", filename);
-    fclose(fileHandle);
-    return FALSE;
-  }
-  
-  *i = iCopy;
-
-  fclose(fileHandle);
-  return TRUE;
-}
+	FILE *fileHandle;
+	unsigned int iCopy;
 
-LIGHT_BOOL light_writeUInt(char const * filename, unsigned int i)
-{
-  FILE* fileHandle;
+	fileHandle = fopen(filename, "r");
 
-  fileHandle = fopen(filename, "w");
+	if (!fileHandle) {
+		LIGHT_PERMERR("reading");
+		return false;
+	}
 
-  if(!fileHandle)
-  {
-    LIGHT_PERMERR("writing");
-    return FALSE;
-  }
+	if (fscanf(fileHandle, "%u", &iCopy) != 1) {
+		LIGHT_ERR_FMT("Couldn't parse a positive integer number from '%s'", filename);
+		fclose(fileHandle);
+		return false;
+	}
 
-  if(fprintf(fileHandle, "%u", i) < 0)
-  {
-    LIGHT_ERR("fprintf failed");
-    fclose(fileHandle);
-    return FALSE;
-  }
+	*i = iCopy;
 
-  fclose(fileHandle);
-  return TRUE;
+	fclose(fileHandle);
+	return true;
 }
 
-
-LIGHT_BOOL light_readULong(char const * filename, unsigned long *i)
+bool light_writeUInt(char const *filename, unsigned int i)
 {
-  FILE* fileHandle;
-  unsigned long iCopy;;
-
-  fileHandle = fopen(filename, "r");
-
-  if(!fileHandle)
-  {
-    LIGHT_PERMERR("reading");
-    return FALSE;
-  }
-
-  if(fscanf(fileHandle, "%lu", &iCopy) != 1)
-  {
-    LIGHT_ERR_FMT("Couldn't parse a positive integer number from '%s'", filename);
-    fclose(fileHandle);
-    return FALSE;
-  }
-  
-  *i = iCopy;
-
-  fclose(fileHandle);
-  return TRUE;
+	FILE *fileHandle;
+
+	fileHandle = fopen(filename, "w");
+
+	if (!fileHandle) {
+		LIGHT_PERMERR("writing");
+		return false;
+	}
+
+	if (fprintf(fileHandle, "%u", i) < 0) {
+		LIGHT_ERR("fprintf failed");
+		fclose(fileHandle);
+		return false;
+	}
+
+	fclose(fileHandle);
+	return true;
 }
 
-LIGHT_BOOL light_writeULong(char const * filename, unsigned long i)
+bool light_readULong(char const *filename, unsigned long *i)
 {
-  FILE* fileHandle;
+	FILE *fileHandle;
+	unsigned long iCopy;;
 
-  fileHandle = fopen(filename, "w");
+	fileHandle = fopen(filename, "r");
 
-  if(!fileHandle)
-  {
-    LIGHT_PERMERR("writing");
-    return FALSE;
-  }
+	if (!fileHandle) {
+		LIGHT_PERMERR("reading");
+		return false;
+	}
 
-  if(fprintf(fileHandle, "%lu", i) < 0)
-  {
-    LIGHT_ERR("fprintf failed");
-    fclose(fileHandle);
-    return FALSE;
-  }
+	if (fscanf(fileHandle, "%lu", &iCopy) != 1) {
+		LIGHT_ERR_FMT("Couldn't parse a positive integer number from '%s'", filename);
+		fclose(fileHandle);
+		return false;
+	}
 
-  fclose(fileHandle);
-  return TRUE;
+	*i = iCopy;
+
+	fclose(fileHandle);
+	return true;
 }
 
+bool light_writeULong(char const *filename, unsigned long i)
+{
+	FILE *fileHandle;
+
+	fileHandle = fopen(filename, "w");
 
+	if (!fileHandle) {
+		LIGHT_PERMERR("writing");
+		return false;
+	}
+
+	if (fprintf(fileHandle, "%lu", i) < 0) {
+		LIGHT_ERR("fprintf failed");
+		fclose(fileHandle);
+		return false;
+	}
+
+	fclose(fileHandle);
+	return true;
+}
 
-LIGHT_BOOL light_readString(char const * filename, char *buffer, long* size)
+bool light_readString(char const *filename, char *buffer, long *size)
 {
-  FILE *fileHandle;
-  long fileSize;
-  long readSize;
-
-  /* Make sure buffer pointer is null */
-  if(buffer != NULL)
-  {
-    LIGHT_ERR("buffer passed to function isn't NULL");
-    return FALSE;
-  }
-
-  /* Open file */
-  fileHandle = fopen(filename, "r");
-
-  if(!fileHandle)
-  {
-    LIGHT_PERMERR("reading");
-    return FALSE;
-  }
-
-  /* Get the file size */
-  fseek(fileHandle, 0L, SEEK_END);
-  fileSize = ftell(fileHandle);
-  rewind(fileHandle);
-
-  /* Allocate the string and null-terminate it */
-  buffer = malloc(sizeof(char)*(fileSize+1));
-  memset(buffer, '\0', fileSize);
-
-  if(buffer == NULL)
-  {
-    LIGHT_MEMERR();
-    fclose(fileHandle);
-    return FALSE;
-  }
-
-  /* Read the file */
-  readSize = fread(buffer, sizeof(char), fileSize, fileHandle);
-
-  if(readSize != fileSize)
-  {
-    LIGHT_ERR("read error");
-    free(buffer);
-    fclose(fileHandle);
-    return FALSE;
-  }
-  
-  /* Set the size */
-  if(size != NULL)
-  {
-    *size = readSize;
-  }
-
-  /* All well, close handle and return TRUE */
-  fclose(fileHandle);
-  return TRUE;
+	FILE *fileHandle;
+	long fileSize;
+	long readSize;
+
+	/* Make sure buffer pointer is null */
+	if (buffer != NULL) {
+		LIGHT_ERR("buffer passed to function isn't NULL");
+		return false;
+	}
+
+	/* Open file */
+	fileHandle = fopen(filename, "r");
+
+	if (!fileHandle) {
+		LIGHT_PERMERR("reading");
+		return false;
+	}
+
+	/* Get the file size */
+	fseek(fileHandle, 0L, SEEK_END);
+	fileSize = ftell(fileHandle);
+	rewind(fileHandle);
+
+	/* Allocate the string and null-terminate it */
+	buffer = malloc(sizeof(char) * (fileSize + 1));
+	memset(buffer, '\0', fileSize);
+
+	if (buffer == NULL) {
+		LIGHT_MEMERR();
+		fclose(fileHandle);
+		return false;
+	}
+
+	/* Read the file */
+	readSize = fread(buffer, sizeof(char), fileSize, fileHandle);
+
+	if (readSize != fileSize) {
+		LIGHT_ERR("read error");
+		free(buffer);
+		fclose(fileHandle);
+		return false;
+	}
+
+	/* Set the size */
+	if (size != NULL) {
+		*size = readSize;
+	}
+
+	/* All well, close handle and return true */
+	fclose(fileHandle);
+	return true;
 }
 
-LIGHT_BOOL light_isDir(char const * path)
+bool light_isDir(char const *path)
 {
-  DIR *dirHandle = opendir(path);
+	DIR *dirHandle = opendir(path);
 
-  if(!dirHandle)
-  {
-    return FALSE;
-  }
+	if (!dirHandle) {
+		return false;
+	}
 
-  closedir(dirHandle);
-  return TRUE;
+	closedir(dirHandle);
+	return true;
 }
 
-LIGHT_BOOL light_isWritable(char const * filename)
+bool light_isWritable(char const *filename)
 {
-  FILE* fileHandle = fopen(filename, "r+");
+	FILE *fileHandle = fopen(filename, "r+");
 
-  if(!fileHandle)
-  {
-    LIGHT_PERMWARN("writing");
-    return FALSE;
-  }
+	if (!fileHandle) {
+		LIGHT_PERMWARN("writing");
+		return false;
+	}
 
-  fclose(fileHandle);
-  return TRUE;
+	fclose(fileHandle);
+	return true;
 }
 
-LIGHT_BOOL light_isReadable(char const * filename)
+bool light_isReadable(char const *filename)
 {
-  FILE* fileHandle = fopen(filename, "r");
+	FILE *fileHandle = fopen(filename, "r");
 
-  if(!fileHandle)
-  {
-    LIGHT_PERMWARN("reading");
-    return FALSE;
-  }
+	if (!fileHandle) {
+		LIGHT_PERMWARN("reading");
+		return false;
+	}
 
-  fclose(fileHandle);
-  return TRUE;
+	fclose(fileHandle);
+	return true;
 }
 
 unsigned long light_logInfClamp(unsigned long x)
 {
-  LIGHT_NOTE_FMT("specified value is inferior to %lu (raw), so adjusting it to this mininum value", x);
-  return x;
+	LIGHT_NOTE_FMT("specified value is inferior to %lu (raw), so adjusting it to this mininum value", x);
+	return x;
 }
 
 unsigned long light_logSupClamp(unsigned long x)
 {
-  LIGHT_NOTE_FMT("specified value is superior to %lu (raw), so adjusting it to this maximum value", x);
-  return x;
+	LIGHT_NOTE_FMT("specified value is superior to %lu (raw), so adjusting it to this maximum value", x);
+	return x;
 }
 
 double light_clampPercent(double p)
 {
-  if(p < 0.0)
-  {
-    LIGHT_WARN_FMT("specified value %g%% is not valid, adjusting it to 0%%", p);
-    return 0.0;
-  }else if(p > 100.0){
-    LIGHT_WARN_FMT("specified value %g%% is not valid, adjusting it to 100%%", p);
-    return 100.0;
-  }
-  return p;
+	if (p < 0.0) {
+		LIGHT_WARN_FMT("specified value %g%% is not valid, adjusting it to 0%%", p);
+		return 0.0;
+	} else if (p > 100.0) {
+		LIGHT_WARN_FMT("specified value %g%% is not valid, adjusting it to 100%%", p);
+		return 100.0;
+	}
+	return p;
 }

src/helpers.h

@@ -1,6 +1,8 @@
 #ifndef LIGHT_HELPERS_H
 #define LIGHT_HELPERS_H
 
+#include <stdbool.h>
+
 /* Clamps x(value) between y(min) and z(max) in a nested ternary operation. 
  * if(x < y)
  * {
@@ -20,14 +22,15 @@
  * 0 - No output
  * 1 - Errors
  * 2 - Errors, warnings 
- * 3 - Errors, warnings, notices */
-typedef enum LIGHT_LOG_LEVEL {
-  LIGHT_ERROR_LEVEL = 1,
-  LIGHT_WARN_LEVEL,
-  LIGHT_NOTE_LEVEL
-} LIGHT_LOG_LEVEL;
-
-LIGHT_LOG_LEVEL light_verbosity;
+ * 3 - Errors, warnings, notices
+ */
+typedef enum {
+	LIGHT_ERROR_LEVEL = 1,
+	LIGHT_WARN_LEVEL,
+	LIGHT_NOTE_LEVEL
+} light_loglevel_t;
+
+light_loglevel_t light_verbosity;
 char light_log_buffer[LIGHT_LOG_FMT_BUF_SIZE];
 
 #define LIGHT_LOG(lvl,f,t,x)if(light_verbosity >= lvl){fprintf(f,t": \"%s\", in \"%s\" on line %u.\n", x, __FILE__, __LINE__);}
@@ -54,35 +57,29 @@ char light_log_buffer[LIGHT_LOG_FMT_BUF_SIZE];
 
 #define LIGHT_PERMWARN(x) LIGHT_PERMLOG(x,LIGHT_WARN)
 
-/* Typedef for boolean values */
-typedef enum LIGHT_BOOL {
-  FALSE = 0,
-  TRUE
-} LIGHT_BOOL;
-
-/* Reads an unsigned integer from a file into `i` if able, otherwise returns FALSE and leaves `i` untouched */
-LIGHT_BOOL light_readUInt(char const *filename, unsigned int *v);
+/* Reads an unsigned integer from a file into `i` if able, otherwise returns false and leaves `i` untouched */
+bool light_readUInt(char const *filename, unsigned int *v);
 
-/* Writes an unsigned integer `i` into file `filename` if able, otherwise returns FALSE */
-LIGHT_BOOL light_writeUInt(char const *filename, unsigned int v);
+/* Writes an unsigned integer `i` into file `filename` if able, otherwise returns false */
+bool light_writeUInt(char const *filename, unsigned int v);
 
-LIGHT_BOOL light_writeULong(char const *filename, unsigned long v);
-LIGHT_BOOL light_readULong(char const *filename, unsigned long *v);
+bool light_writeULong(char const *filename, unsigned long v);
+bool light_readULong(char const *filename, unsigned long *v);
 
-/* Reads a file into null-terminated `buffer` if able, otherwise returns FALSE
+/* Reads a file into null-terminated `buffer` if able, otherwise returns false
  * If `size` isn't NULL, it will be set to the read size.
  *
  * WARNING: `buffer` HAS to be freed by the user, also make sure it is NULL before passed */
-LIGHT_BOOL light_readString(char const * filename, char * buffer, long * size);
+bool light_readString(char const *filename, char *buffer, long *size);
 
-/* Returns TRUE if `path` is a valid directory, FALSE otherwise */
-LIGHT_BOOL light_isDir(char const * path);
+/* Returns true if `path` is a valid directory, false otherwise */
+bool light_isDir(char const *path);
 
-/* Returns TRUE if file is writable, FALSE otherwise */
-LIGHT_BOOL light_isWritable(char const * filename);
+/* Returns true if file is writable, false otherwise */
+bool light_isWritable(char const *filename);
 
-/* Returns TRUE if file is readable, FALSE otherwise */
-LIGHT_BOOL light_isReadable(char const * filename);
+/* Returns true if file is readable, false otherwise */
+bool light_isReadable(char const *filename);
 
 /* Clamps the `percent` value between 0% and 100% */
 double light_clampPercent(double percent);

src/light.h

@@ -4,6 +4,7 @@
 #include "config.h"
 #include "helpers.h"
 
+#include <stdbool.h>
 #include <sys/types.h>
 #include <dirent.h>
 #include <linux/limits.h>
@@ -14,9 +15,9 @@
 #define ASSERT_SET(t,v)							\
 	if (v) {							\
 		fprintf(stderr, t" arguments cannot be used in conjunction.\n"); \
-		return FALSE;						\
+		return false;						\
 	}								\
-	v = TRUE;
+	v = true;
 
 #define ASSERT_OPSET() ASSERT_SET("Operation", opSet)
 #define ASSERT_TARGETSET() ASSERT_SET("Target", targetSet)
@@ -24,58 +25,57 @@
 #define ASSERT_CTRLSET() ASSERT_SET("Controller", ctrlSet)
 #define ASSERT_VALSET() ASSERT_SET("Value", valSet)
 
-typedef enum LIGHT_FIELD {
-  LIGHT_BRIGHTNESS = 0,
-  LIGHT_MAX_BRIGHTNESS,
-  LIGHT_MIN_CAP,
-  LIGHT_SAVERESTORE
-} LIGHT_FIELD;
-
-typedef enum LIGHT_TARGET {
-  LIGHT_BACKLIGHT = 0,
-  LIGHT_KEYBOARD
-} LIGHT_TARGET;
-
-typedef enum LIGHT_CTRL_MODE {
-  LIGHT_AUTO = 0,
-  LIGHT_SPECIFY
-} LIGHT_CTRL_MODE;
-
-typedef enum LIGHT_OP_MODE {
-  LIGHT_GET = 0,
-  LIGHT_SET,
-  LIGHT_ADD,
-  LIGHT_SUB,
-  LIGHT_PRINT_HELP,   /* Prints help and exits  */
-  LIGHT_PRINT_VERSION, /* Prints version info and exits */
-  LIGHT_LIST_CTRL,
-  LIGHT_RESTORE,
-  LIGHT_SAVE
-
-} LIGHT_OP_MODE;
-
-typedef enum LIGHT_VAL_MODE {
-  LIGHT_RAW = 0,
-  LIGHT_PERCENT
-} LIGHT_VAL_MODE;
+typedef enum {
+	LIGHT_BRIGHTNESS = 0,
+	LIGHT_MAX_BRIGHTNESS,
+	LIGHT_MIN_CAP,
+	LIGHT_SAVERESTORE
+} light_field_t;
+
+typedef enum {
+	LIGHT_BACKLIGHT = 0,
+	LIGHT_KEYBOARD
+} light_target_t;
+
+typedef enum {
+	LIGHT_AUTO = 0,
+	LIGHT_SPECIFY
+} light_ctrl_mode_t;
+
+typedef enum {
+	LIGHT_GET = 0,
+	LIGHT_SET,
+	LIGHT_ADD,
+	LIGHT_SUB,
+	LIGHT_PRINT_HELP,	/* Prints help and exits  */
+	LIGHT_PRINT_VERSION,	/* Prints version info and exits */
+	LIGHT_LIST_CTRL,
+	LIGHT_RESTORE,
+	LIGHT_SAVE
+} light_cmd_t;
+
+typedef enum {
+	LIGHT_RAW = 0,
+	LIGHT_PERCENT
+} light_val_mode_t;
 
 typedef struct light_runtimeArguments_s {
-  /* Which controller to use */
-  LIGHT_CTRL_MODE controllerMode;
-  char            specifiedController[NAME_MAX + 1];
+	/* Which controller to use */
+	light_ctrl_mode_t controllerMode;
+	char specifiedController[NAME_MAX + 1];
 
-  /* What to do with the controller */
-  LIGHT_OP_MODE   operationMode;
-  LIGHT_VAL_MODE  valueMode;
-  unsigned long   specifiedValueRaw; /* The specified value in raw mode */
-  double          specifiedValuePercent; /* The specified value in percent */
+	/* What to do with the controller */
+	light_cmd_t operationMode;
+	light_val_mode_t valueMode;
+	unsigned long specifiedValueRaw;	/* The specified value in raw mode */
+	double specifiedValuePercent;	/* The specified value in percent */
 
-  LIGHT_TARGET   target;
-  LIGHT_FIELD    field;
+	light_target_t target;
+	light_field_t field;
 
-  /* Cache data */
-  LIGHT_BOOL      hasCachedMaxBrightness;
-  unsigned long   cachedMaxBrightness;
+	/* Cache data */
+	bool hasCachedMaxBrightness;
+	unsigned long cachedMaxBrightness;
 
 } light_runtimeArguments, *light_runtimeArguments_p;
 
@@ -85,9 +85,8 @@ light_runtimeArguments light_Configuration;
 /* Sets default values for the configuration */
 void light_defaultConfig();
 
-
 /* Parses the program arguments and sets the configuration accordingly (unsanitized) */
-LIGHT_BOOL light_parseArguments(int argc, char** argv);
+bool light_parseArguments(int argc, char **argv);
 
 /* Prints a header if verbosity level > 0 */
 void light_printVersion(void);
@@ -98,10 +97,10 @@ void light_printHelp(void);
 /* -- SECTION: Main code -- */
 
 /* Initializes the application */
-LIGHT_BOOL light_initialize(int argc, char** argv);
+bool light_initialize(int argc, char **argv);
 
 /* Does the work */
-LIGHT_BOOL light_execute(void);
+bool light_execute(void);
 
 /* Frees up resources */
 void light_free();
@@ -110,29 +109,29 @@ void light_free();
 
 /* WARNING: `buffer` HAS to be freed by the user if not null once returned!
  * Size is always NAME_MAX + 1 */
-LIGHT_BOOL light_genPath(char const *controller, LIGHT_TARGET target, LIGHT_FIELD type, char **buffer);
+bool light_genPath(char const *controller, light_target_t target, light_field_t type, char **buffer);
 
-LIGHT_BOOL light_validControllerName(char const *controller);
+bool light_validControllerName(char const *controller);
 
-LIGHT_BOOL light_getBrightness(char const *controller, unsigned long *v);
+bool light_getBrightness(char const *controller, unsigned long *v);
 
-LIGHT_BOOL light_getMaxBrightness(char const *controller, unsigned long *v);
+bool light_getMaxBrightness(char const *controller, unsigned long *v);
 
-LIGHT_BOOL light_setBrightness(char const *controller, unsigned long v);
+bool light_setBrightness(char const *controller, unsigned long v);
 
-LIGHT_BOOL light_controllerAccessible(char const *controller);
+bool light_controllerAccessible(char const *controller);
 
 /* WARNING: `controller` HAS to be at most NAME_MAX, otherwise fails */
-LIGHT_BOOL light_getBestController(char *controller);
+bool light_getBestController(char *controller);
 
-LIGHT_BOOL light_getMinCap(char const *controller, LIGHT_BOOL *hasMinCap, unsigned long *minCap);
+bool light_getMinCap(char const *controller, bool * hasMinCap, unsigned long *minCap);
 
-LIGHT_BOOL light_setMinCap(char const *controller, unsigned long v);
+bool light_setMinCap(char const *controller, unsigned long v);
 
-LIGHT_BOOL light_listControllers();
+bool light_listControllers();
 
-LIGHT_BOOL light_saveBrightness(char const *controller, unsigned long v);
+bool light_saveBrightness(char const *controller, unsigned long v);
 
-LIGHT_BOOL light_restoreBrightness(char const *controller);
+bool light_restoreBrightness(char const *controller);
 
 #endif /* LIGHT_H_ */

src/main.c

@@ -6,21 +6,19 @@
 #define LIGHT_RETURNVAL_EXECFAIL  1
 #define LIGHT_RETURNVAL_SUCCESS   0
 
-int main(int argc, char** argv)
+int main(int argc, char **argv)
 {
-  if(!light_initialize(argc, argv))
-  {
-    LIGHT_ERR("Initialization failed");
-    return LIGHT_RETURNVAL_INITFAIL;
-  }
+	if (!light_initialize(argc, argv)) {
+		LIGHT_ERR("Initialization failed");
+		return LIGHT_RETURNVAL_INITFAIL;
+	}
 
-  if(!light_execute())
-  {
-    LIGHT_ERR("Execution failed");
-    light_free();
-    return LIGHT_RETURNVAL_EXECFAIL;
-  }
+	if (!light_execute()) {
+		LIGHT_ERR("Execution failed");
+		light_free();
+		return LIGHT_RETURNVAL_EXECFAIL;
+	}
 
-  light_free();
-  return LIGHT_RETURNVAL_SUCCESS;
+	light_free();
+	return LIGHT_RETURNVAL_SUCCESS;
 }