General cleanup & fixes

src/Makefile.am

@@ -1,7 +1,7 @@
 bin_PROGRAMS   = light
 light_SOURCES  = main.c light.c light.h helpers.c helpers.h impl/sysfs.c impl/sysfs.h
 light_CPPFLAGS = -I../include -D_GNU_SOURCE
-light_CFLAGS   = -W -Wall -Wextra -std=gnu99 -Wno-type-limits
+light_CFLAGS   = -W -Wall -Wextra -std=gnu18 -Wno-type-limits -Wno-format-truncation -Wno-unused-parameter
 
 if CLASSIC
 install-exec-hook:

src/helpers.c

@@ -11,130 +11,132 @@
 
 bool light_file_read_uint64(char const *filename, uint64_t *val)
 {
-	FILE *fp;
-	uint64_t data;
-
-	fp = fopen(filename, "r");
-	if (!fp)
-	{
-		LIGHT_PERMERR("reading");
-		return false;
-	}
-
-	if (fscanf(fp, "%lu", &data) != 1)
-	{
-		LIGHT_ERR("Couldn't parse an unsigned integer from '%s'", filename);
-		fclose(fp);
-		return false;
-	}
-
-	*val = data;
-
-	fclose(fp);
-	return true;
+    FILE *fp;
+    uint64_t data;
+
+    fp = fopen(filename, "r");
+    if (!fp)
+    {
+        LIGHT_PERMERR("reading");
+        return false;
+    }
+
+    if (fscanf(fp, "%lu", &data) != 1)
+    {
+        LIGHT_ERR("Couldn't parse an unsigned integer from '%s'", filename);
+        fclose(fp);
+        return false;
+    }
+
+    *val = data;
+
+    fclose(fp);
+    return true;
 }
 
 bool light_file_write_uint64(char const *filename, uint64_t val)
 {
-	FILE *fp;
-
-	fp = fopen(filename, "w");
-	if (!fp)
-	{
-		LIGHT_PERMERR("writing");
-		return false;
-	}
-
-	if (fprintf(fp, "%lu", val) < 0)
-	{
-		LIGHT_ERR("fprintf failed");
-		fclose(fp);
-		return false;
-	}
-
-	fclose(fp);
-	return true;
+    FILE *fp;
+
+    fp = fopen(filename, "w");
+    if (!fp)
+    {
+        LIGHT_PERMERR("writing");
+        return false;
+    }
+
+    if (fprintf(fp, "%lu", val) < 0)
+    {
+        LIGHT_ERR("fprintf failed");
+        fclose(fp);
+        return false;
+    }
+
+    fclose(fp);
+    return true;
 }
 
 /* Returns true if file is writable, false otherwise */
 bool light_file_is_writable(char const *filename)
 {
-	FILE *fp;
+    FILE *fp;
 
-	fp = fopen(filename, "r+");
-	if (!fp)
-	{
-		LIGHT_PERMWARN("writing");
-		return false;
-	}
+    fp = fopen(filename, "r+");
+    if (!fp)
+    {
+        LIGHT_PERMWARN("writing");
+        return false;
+    }
 
-	fclose(fp);
-	return true;
+    fclose(fp);
+    return true;
 }
 
 /* Returns true if file is readable, false otherwise */
 bool light_file_is_readable(char const *filename)
 {
-	FILE *fp;
+    FILE *fp;
 
-	fp = fopen(filename, "r");
-	if (!fp)
-	{
-		LIGHT_PERMWARN("reading");
-		return false;
-	}
+    fp = fopen(filename, "r");
+    if (!fp)
+    {
+        LIGHT_PERMWARN("reading");
+        return false;
+    }
 
-	fclose(fp);
-	return true;
+    fclose(fp);
+    return true;
 }
 
 /* Prints a notice about a value which was below `x` and was adjusted to it */
 uint64_t light_log_clamp_min(uint64_t min)
 {
-	LIGHT_NOTE("too small value, adjusting to mininum %lu (raw)", min);
-	return min;
+    LIGHT_NOTE("too small value, adjusting to mininum %lu (raw)", min);
+    return min;
 }
 
 /* Prints a notice about a value which was above `x` and was adjusted to it */
 uint64_t light_log_clamp_max(uint64_t max)
 {
-	LIGHT_NOTE("too large value, adjusting to mavalimum %lu (raw)", max);
-	return max;
+    LIGHT_NOTE("too large value, adjusting to mavalimum %lu (raw)", max);
+    return max;
 }
 
 /* Clamps the `percent` value between 0% and 100% */
 double light_percent_clamp(double val)
 {
-	if (val < 0.0)
-	{
-		LIGHT_WARN("specified value %g%% is not valid, adjusting it to 0%%", val);
-		return 0.0;
-	}
-
-	if (val > 100.0)
-	{
-		LIGHT_WARN("specified value %g%% is not valid, adjusting it to 100%%", val);
-		return 100.0;
-	}
-
-	return val;
+    if (val < 0.0)
+    {
+        LIGHT_WARN("specified value %g%% is not valid, adjusting it to 0%%", val);
+        return 0.0;
+    }
+
+    if (val > 100.0)
+    {
+        LIGHT_WARN("specified value %g%% is not valid, adjusting it to 100%%", val);
+        return 100.0;
+    }
+
+    return val;
 }
 
 int light_mkpath(char *dir, mode_t mode)
 {
-	struct stat sb;
-
-	if (!dir)
-	{
-		errno = EINVAL;
-		return -1;
-	}
-
-	if (!stat(dir, &sb))
-		return 0;
-
-	light_mkpath(dirname(strdupa(dir)), mode);
-
-	return mkdir(dir, mode);
+    struct stat sb;
+
+    if (!dir)
+    {
+        errno = EINVAL;
+        return -1;
+    }
+
+    if (!stat(dir, &sb))
+        return 0;
+
+    char *tempdir = strdup(dir);
+    light_mkpath(dirname(tempdir), mode);
+    free(tempdir);
+    
+    return mkdir(dir, mode);
 }
 

src/helpers.h

@@ -7,40 +7,36 @@
 #include <stdio.h>
 
 /* Clamps x(value) between y(min) and z(max) in a nested ternary operation */
-#define LIGHT_CLAMP(val, min, max)					\
-	(val < min							\
-	 ? light_log_clamp_min(min)					\
-	 : (val > max							\
-	    ? light_log_clamp_max(max)					\
-	    : val ))
+#define LIGHT_CLAMP(val, min, max) (val < min ? light_log_clamp_min(min) : (val > max ? light_log_clamp_max(max) : val))
 
 /* Verbosity levels: 
- * 0 - No output
- * 1 - Errors
- * 2 - Errors, warnings 
- * 3 - Errors, warnings, notices
- */
+* 0 - No output
+* 1 - Errors
+* 2 - Errors, warnings 
+* 3 - Errors, warnings, notices
+*/
 typedef enum {
-	LIGHT_ERROR_LEVEL = 1,
-	LIGHT_WARN_LEVEL,
-	LIGHT_NOTE_LEVEL
+    LIGHT_ERROR_LEVEL = 1,
+    LIGHT_WARN_LEVEL,
+    LIGHT_NOTE_LEVEL
 } light_loglevel_t;
 
 light_loglevel_t light_loglevel;
 
-#define LIGHT_LOG(lvl, fp, fmt, args...)				\
-	if (light_loglevel >= lvl)					\
-		fprintf(fp, "%s:%d:" fmt "\n", __FILE__, __LINE__, ##args)
+#define LIGHT_LOG(lvl, fp, fmt, args...)\
+    if (light_loglevel >= lvl)\
+        fprintf(fp, "%s:%d:" fmt "\n", __FILE__, __LINE__, ##args)
 
 #define LIGHT_NOTE(fmt, args...) LIGHT_LOG(LIGHT_NOTE_LEVEL,  stdout, " Notice: " fmt, ##args)
 #define LIGHT_WARN(fmt, args...) LIGHT_LOG(LIGHT_WARN_LEVEL,  stderr, " Warning: " fmt, ##args)
 #define LIGHT_ERR(fmt, args...)  LIGHT_LOG(LIGHT_ERROR_LEVEL, stderr, " Error: " fmt, ##args)
 #define LIGHT_MEMERR()           LIGHT_ERR("memory error");
-#define LIGHT_PERMLOG(act, log)						\
-	do {								\
-		log("could not open '%s' for " act, filename);		\
-		log("Verify it exists with the right permissions");	\
-	} while (0)
+#define LIGHT_PERMLOG(act, log)\
+    do {\
+        log("could not open '%s' for " act, filename);\
+        log("Verify it exists with the right permissions");\
+    } while (0)
+
 #define LIGHT_PERMERR(x)         LIGHT_PERMLOG(x, LIGHT_ERR)
 #define LIGHT_PERMWARN(x)        LIGHT_PERMLOG(x, LIGHT_WARN)
 

src/impl/sysfs.c

@@ -9,247 +9,251 @@
 
 static bool _impl_sysfs_init_leds(light_device_enumerator_t *enumerator)
 {
-	// Create a new backlight device
-	light_device_t *leds_device = malloc(sizeof(light_device_t));
-	snprintf(leds_device->name, sizeof(leds_device->name), "%s", "leds");
-	
-	// Add it to the enumerator 
-	light_add_enumerator_device(enumerator, leds_device);
-	
-	// Iterate through the led controllers and create a device_target for each controller 
-	DIR *leds_dir;
-	struct dirent *curr_entry;
-	
-	if((leds_dir = opendir("/sys/class/leds")) == NULL)
-	{
-		LIGHT_ERR("failed to open leds controller directory for reading");
-		return false;
-	}
-	
-	while((curr_entry = readdir(leds_dir)) != NULL)
-	{
-		// Skip dot entries
-		if(curr_entry->d_name[0] == '.')
-		{
-			continue;
-		}
-		
-		// Create a new device target for the controller 
-		light_device_target_t *led_controller = malloc(sizeof(light_device_target_t));
-		snprintf(led_controller->name, sizeof(led_controller->name), "%s", curr_entry->d_name);
-		
-		// Setup the function bindings
-		led_controller->set_value = impl_sysfs_set;
-		led_controller->get_value = impl_sysfs_get;
-		led_controller->get_max_value = impl_sysfs_getmax;
-		led_controller->custom_command = impl_sysfs_command;
-		
-		// Setup the target data 
-		impl_sysfs_data_t *dev_data = malloc(sizeof(impl_sysfs_data_t));
-		led_controller->device_target_data = dev_data;
-		snprintf(dev_data->brightness, sizeof(dev_data->brightness), "/sys/class/leds/%s/brightness", curr_entry->d_name);
-		snprintf(dev_data->max_brightness, sizeof(dev_data->max_brightness), "/sys/class/leds/%s/max_brightness", curr_entry->d_name);
-		
-		// Add it to the device
-		light_add_device_target(leds_device, led_controller);
-	}
-	
-	return true;
+    // Create a new backlight device
+    light_device_t *leds_device = malloc(sizeof(light_device_t));
+    snprintf(leds_device->name, sizeof(leds_device->name), "%s", "leds");
+    
+    // Add it to the enumerator 
+    light_add_enumerator_device(enumerator, leds_device);
+    
+    // Iterate through the led controllers and create a device_target for each controller 
+    DIR *leds_dir;
+    struct dirent *curr_entry;
+    
+    if((leds_dir = opendir("/sys/class/leds")) == NULL)
+    {
+        LIGHT_ERR("failed to open leds controller directory for reading");
+        return false;
+    }
+    
+    while((curr_entry = readdir(leds_dir)) != NULL)
+    {
+        // Skip dot entries
+        if(curr_entry->d_name[0] == '.')
+        {
+            continue;
+        }
+        
+        // Create a new device target for the controller 
+        light_device_target_t *led_controller = malloc(sizeof(light_device_target_t));
+        snprintf(led_controller->name, sizeof(led_controller->name), "%s", curr_entry->d_name);
+        
+        // Setup the function bindings
+        led_controller->set_value = impl_sysfs_set;
+        led_controller->get_value = impl_sysfs_get;
+        led_controller->get_max_value = impl_sysfs_getmax;
+        led_controller->custom_command = impl_sysfs_command;
+        
+        // Setup the target data 
+        impl_sysfs_data_t *dev_data = malloc(sizeof(impl_sysfs_data_t));
+        led_controller->device_target_data = dev_data;
+        snprintf(dev_data->brightness, sizeof(dev_data->brightness), "/sys/class/leds/%s/brightness", curr_entry->d_name);
+        snprintf(dev_data->max_brightness, sizeof(dev_data->max_brightness), "/sys/class/leds/%s/max_brightness", curr_entry->d_name);
+        
+        // Add it to the device
+        light_add_device_target(leds_device, led_controller);
+    }
+    
+    closedir(leds_dir);
+    
+    return true;
 }
 
 static bool _impl_sysfs_init_backlight(light_device_enumerator_t *enumerator)
 {
-	// Create a new backlight device
-	light_device_t *backlight_device = malloc(sizeof(light_device_t));
-	snprintf(backlight_device->name, sizeof(backlight_device->name), "%s", "backlight");
-	
-	// Add it to the enumerator 
-	light_add_enumerator_device(enumerator, backlight_device);
-	
-	// Iterate through the backlight controllers and create a device_target for each controller 
-	DIR *backlight_dir;
-	struct dirent *curr_entry;
-	
-	// Keep track of the best controller, and create an autodevice from that
-	char best_controller[NAME_MAX];
-	uint64_t best_value = 0;
-	
-	if((backlight_dir = opendir("/sys/class/backlight")) == NULL)
-	{
-		LIGHT_ERR("failed to open backlight controller directory for reading");
-		return false;
-	}
-	
-	while((curr_entry = readdir(backlight_dir)) != NULL)
-	{
-		// Skip dot entries
-		if(curr_entry->d_name[0] == '.')
-		{
-			continue;
-		}
-		
-		// Create a new device target for the controller 
-		light_device_target_t *backlight_controller = malloc(sizeof(light_device_target_t));
-		snprintf(backlight_controller->name, sizeof(backlight_controller->name), "%s", curr_entry->d_name);
-		
-		// Setup the function bindings
-		backlight_controller->set_value = impl_sysfs_set;
-		backlight_controller->get_value = impl_sysfs_get;
-		backlight_controller->get_max_value = impl_sysfs_getmax;
-		backlight_controller->custom_command = impl_sysfs_command;
-		
-		// Setup the target data 
-		impl_sysfs_data_t *dev_data = malloc(sizeof(impl_sysfs_data_t));
-		backlight_controller->device_target_data = dev_data;
-		snprintf(dev_data->brightness, sizeof(dev_data->brightness), "/sys/class/backlight/%s/brightness", curr_entry->d_name);
-		snprintf(dev_data->max_brightness, sizeof(dev_data->max_brightness), "/sys/class/backlight/%s/max_brightness", curr_entry->d_name);
-		
-		// Read the max brightness to get the best one
-		uint64_t curr_value = 0;
-		if(light_file_read_uint64(dev_data->max_brightness, &curr_value))
-		{
-			if(curr_value > best_value)
-			{
-				best_value = curr_value;
-				snprintf(best_controller, sizeof(best_controller), "%s", backlight_controller->name);
-			}
-		}
-		
-		// Add it to the device
-		light_add_device_target(backlight_device, backlight_controller);
-	}
-	
-	// Create an auto controller 
-	light_device_target_t *auto_controller = malloc(sizeof(light_device_target_t));
-	snprintf(auto_controller->name, sizeof(auto_controller->name), "%s", "auto");
-	
-	// Setup the function bindings
-	auto_controller->set_value = impl_sysfs_set;
-	auto_controller->get_value = impl_sysfs_get;
-	auto_controller->get_max_value = impl_sysfs_getmax;
-	auto_controller->custom_command = impl_sysfs_command;
-	
-	// Setup the target data 
-	impl_sysfs_data_t *dev_data = malloc(sizeof(impl_sysfs_data_t));
-	auto_controller->device_target_data = dev_data;
-	snprintf(dev_data->brightness, sizeof(dev_data->brightness), "/sys/class/backlight/%s/brightness", best_controller);
-	snprintf(dev_data->max_brightness, sizeof(dev_data->max_brightness), "/sys/class/backlight/%s/max_brightness", best_controller);
-	
-	// Add it to the device
-	light_add_device_target(backlight_device, auto_controller);
-	
-	return true;
+    // Create a new backlight device
+    light_device_t *backlight_device = malloc(sizeof(light_device_t));
+    snprintf(backlight_device->name, sizeof(backlight_device->name), "%s", "backlight");
+    
+    // Add it to the enumerator 
+    light_add_enumerator_device(enumerator, backlight_device);
+    
+    // Iterate through the backlight controllers and create a device_target for each controller 
+    DIR *backlight_dir;
+    struct dirent *curr_entry;
+    
+    // Keep track of the best controller, and create an autodevice from that
+    char best_controller[NAME_MAX];
+    uint64_t best_value = 0;
+    
+    if((backlight_dir = opendir("/sys/class/backlight")) == NULL)
+    {
+        LIGHT_ERR("failed to open backlight controller directory for reading");
+        return false;
+    }
+    
+    while((curr_entry = readdir(backlight_dir)) != NULL)
+    {
+        // Skip dot entries
+        if(curr_entry->d_name[0] == '.')
+        {
+            continue;
+        }
+        
+        // Create a new device target for the controller 
+        light_device_target_t *backlight_controller = malloc(sizeof(light_device_target_t));
+        snprintf(backlight_controller->name, sizeof(backlight_controller->name), "%s", curr_entry->d_name);
+        
+        // Setup the function bindings
+        backlight_controller->set_value = impl_sysfs_set;
+        backlight_controller->get_value = impl_sysfs_get;
+        backlight_controller->get_max_value = impl_sysfs_getmax;
+        backlight_controller->custom_command = impl_sysfs_command;
+        
+        // Setup the target data 
+        impl_sysfs_data_t *dev_data = malloc(sizeof(impl_sysfs_data_t));
+        backlight_controller->device_target_data = dev_data;
+        snprintf(dev_data->brightness, sizeof(dev_data->brightness), "/sys/class/backlight/%s/brightness", curr_entry->d_name);
+        snprintf(dev_data->max_brightness, sizeof(dev_data->max_brightness), "/sys/class/backlight/%s/max_brightness", curr_entry->d_name);
+        
+        // Read the max brightness to get the best one
+        uint64_t curr_value = 0;
+        if(light_file_read_uint64(dev_data->max_brightness, &curr_value))
+        {
+            if(curr_value > best_value)
+            {
+                best_value = curr_value;
+                snprintf(best_controller, sizeof(best_controller), "%s", backlight_controller->name);
+            }
+        }
+        
+        // Add it to the device
+        light_add_device_target(backlight_device, backlight_controller);
+    }
+    
+    closedir(backlight_dir);
+    
+    // Create an auto controller 
+    light_device_target_t *auto_controller = malloc(sizeof(light_device_target_t));
+    snprintf(auto_controller->name, sizeof(auto_controller->name), "%s", "auto");
+    
+    // Setup the function bindings
+    auto_controller->set_value = impl_sysfs_set;
+    auto_controller->get_value = impl_sysfs_get;
+    auto_controller->get_max_value = impl_sysfs_getmax;
+    auto_controller->custom_command = impl_sysfs_command;
+    
+    // Setup the target data 
+    impl_sysfs_data_t *dev_data = malloc(sizeof(impl_sysfs_data_t));
+    auto_controller->device_target_data = dev_data;
+    snprintf(dev_data->brightness, sizeof(dev_data->brightness), "/sys/class/backlight/%s/brightness", best_controller);
+    snprintf(dev_data->max_brightness, sizeof(dev_data->max_brightness), "/sys/class/backlight/%s/max_brightness", best_controller);
+    
+    // Add it to the device
+    light_add_device_target(backlight_device, auto_controller);
+    
+    return true;
 }
 
 bool impl_sysfs_init(light_device_enumerator_t *enumerator)
 {
-	// Create a device for the backlight 
-	_impl_sysfs_init_backlight(enumerator);
-	
-	// Create devices for the leds
-	 _impl_sysfs_init_leds(enumerator);
-	
-	return true;
+    // Create a device for the backlight 
+    _impl_sysfs_init_backlight(enumerator);
+    
+    // Create devices for the leds
+    _impl_sysfs_init_leds(enumerator);
+    
+    return true;
 }
 
 bool impl_sysfs_free(light_device_enumerator_t *enumerator)
 {
-	// Iterate through the devices in the enumerator
-	for(uint64_t d = 0; d < enumerator->num_devices; d++)
-	{
-		light_device_t *curr_device = enumerator->devices[d];
-		
-		// If the given device points to NULL, we can safely skip it
-		if(curr_device == NULL)
-		{
-			continue;
-		}
-		
-		// If the given device has a targets array that isnt NULL, iterate through it to free the targets, then free the array
-		if(curr_device->targets != NULL)
-		{
-			for(uint64_t t = 0; t < curr_device->num_targets; t++)
-			{
-				light_device_target_t *curr_target = curr_device->targets[t];
-				
-				if(curr_target == NULL)
-				{
-					continue;
-				}
-				
-				if(curr_target->device_target_data != NULL)
-				{
-					free(curr_target->device_target_data);
-				}
-				
-				free(curr_target);
-			}
-			
-			free(curr_device->targets);
-		}
-		
-		// If the given device has any device_data, free it
-		if(curr_device->device_data != NULL)
-		{
-			free(curr_device->device_data);
-		}
-		
-		// Free the device
-		free(curr_device);
-	}
-	
-	// Free the devices array
-	free(enumerator->devices);
-	enumerator->devices = NULL;
-	enumerator->num_devices = 0;
-	
-	return true;
+    // Iterate through the devices in the enumerator
+    for(uint64_t d = 0; d < enumerator->num_devices; d++)
+    {
+        light_device_t *curr_device = enumerator->devices[d];
+        
+        // If the given device points to NULL, we can safely skip it
+        if(curr_device == NULL)
+        {
+            continue;
+        }
+        
+        // If the given device has a targets array that isnt NULL, iterate through it to free the targets, then free the array
+        if(curr_device->targets != NULL)
+        {
+            for(uint64_t t = 0; t < curr_device->num_targets; t++)
+            {
+                light_device_target_t *curr_target = curr_device->targets[t];
+                
+                if(curr_target == NULL)
+                {
+                    continue;
+                }
+                
+                if(curr_target->device_target_data != NULL)
+                {
+                    free(curr_target->device_target_data);
+                }
+                
+                free(curr_target);
+            }
+            
+            free(curr_device->targets);
+        }
+        
+        // If the given device has any device_data, free it
+        if(curr_device->device_data != NULL)
+        {
+            free(curr_device->device_data);
+        }
+        
+        // Free the device
+        free(curr_device);
+    }
+    
+    // Free the devices array
+    free(enumerator->devices);
+    enumerator->devices = NULL;
+    enumerator->num_devices = 0;
+    
+    return true;
 }
 
 bool impl_sysfs_set(light_device_target_t *target, uint64_t in_value)
 {
-	impl_sysfs_data_t *data = (impl_sysfs_data_t*)target->device_target_data;
+    impl_sysfs_data_t *data = (impl_sysfs_data_t*)target->device_target_data;
 
-	if(!light_file_write_uint64(data->brightness, in_value))
-	{
-		LIGHT_ERR("failed to write to sysfs device");
-		return false;
-	}
-	
-	return true;
+    if(!light_file_write_uint64(data->brightness, in_value))
+    {
+        LIGHT_ERR("failed to write to sysfs device");
+        return false;
+    }
+    
+    return true;
 }
 
 bool impl_sysfs_get(light_device_target_t *target, uint64_t *out_value)
 {
-	impl_sysfs_data_t *data = (impl_sysfs_data_t*)target->device_target_data;
+    impl_sysfs_data_t *data = (impl_sysfs_data_t*)target->device_target_data;
 
-	if(!light_file_read_uint64(data->brightness, out_value))
-	{
-		LIGHT_ERR("failed to read from sysfs device");
-		return false;
-	}
-	
-	return true;
+    if(!light_file_read_uint64(data->brightness, out_value))
+    {
+        LIGHT_ERR("failed to read from sysfs device");
+        return false;
+    }
+    
+    return true;
 }
 
 bool impl_sysfs_getmax(light_device_target_t *target, uint64_t *out_value)
 {
-	impl_sysfs_data_t *data = (impl_sysfs_data_t*)target->device_target_data;
+    impl_sysfs_data_t *data = (impl_sysfs_data_t*)target->device_target_data;
 
-	if(!light_file_read_uint64(data->max_brightness, out_value))
-	{
-		LIGHT_ERR("failed to read from sysfs device");
-		return false;
-	}
-	
-	return true;
+    if(!light_file_read_uint64(data->max_brightness, out_value))
+    {
+        LIGHT_ERR("failed to read from sysfs device");
+        return false;
+    }
+    
+    return true;
 }
 
 bool impl_sysfs_command(light_device_target_t *target, char const *command_string)
 {
-	// No current need for custom commands in sysfs enumerator
-	// To implement support, simply parse the command string to your liking, and return false on invalid input or results!
-	return true;
+    // No current need for custom commands in sysfs enumerator
+    // To implement support, simply parse the command string to your liking, and return false on invalid input or results!
+    return true;
 }
 
 

src/impl/sysfs.h

@@ -7,10 +7,13 @@
 // Enumerates devices for backlights and leds
 
 // Device target data 
-typedef struct {
-	char brightness[NAME_MAX];
-	char max_brightness[NAME_MAX];
-} impl_sysfs_data_t;
+struct _impl_sysfs_data_t
+{
+    char brightness[NAME_MAX];
+    char max_brightness[NAME_MAX];
+};
+
+typedef struct _impl_sysfs_data_t impl_sysfs_data_t;
 
 bool impl_sysfs_init(light_device_enumerator_t *enumerator);
 bool impl_sysfs_free(light_device_enumerator_t *enumerator);

src/light.h

@@ -29,24 +29,23 @@ typedef bool (*LFUNCCUSTOMCMD)(light_device_target_t*, char const *);
 /* Describes a target within a device (for example a led on a keyboard, or a controller for a backlight) */
 struct _light_device_target_t
 {
-	char           name[256];
-	LFUNCVALSET    set_value;
-	LFUNCVALGET    get_value;
-	LFUNCMAXVALGET get_max_value;
-	LFUNCCUSTOMCMD custom_command;
-	void           *device_target_data;
-	light_device_t *device;
+    char           name[256];
+    LFUNCVALSET    set_value;
+    LFUNCVALGET    get_value;
+    LFUNCMAXVALGET get_max_value;
+    LFUNCCUSTOMCMD custom_command;
+    void           *device_target_data;
+    light_device_t *device;
 };
 
-
 /* Describes a device (a backlight, a keyboard, a led-strip) */
 struct _light_device_t
 {
-	char                  name[256];
-	light_device_target_t **targets;
-	uint64_t              num_targets;
-	void                  *device_data;
-	light_device_enumerator_t *enumerator;
+    char                  name[256];
+    light_device_target_t **targets;
+    uint64_t              num_targets;
+    void                  *device_data;
+    light_device_enumerator_t *enumerator;
 };
 
 
@@ -56,12 +55,12 @@ typedef bool (*LFUNCENUMFREE)(light_device_enumerator_t*);
 /* An enumerator that is responsible for creating and freeing devices as well as their targets */
 struct _light_device_enumerator_t
 {
-	char          name[256];
-	LFUNCENUMINIT init;
-	LFUNCENUMFREE free;
+    char            name[256];
+    LFUNCENUMINIT   init;
+    LFUNCENUMFREE   free;
 
-	light_device_t **devices;
-	uint64_t num_devices;
+    light_device_t  **devices;
+    uint64_t        num_devices;
 };
 
 typedef struct _light_context_t light_context_t;
@@ -69,29 +68,24 @@ typedef struct _light_context_t light_context_t;
 // A command that can be run (set, get, add, subtract, print help, print version, list devices etc.)
 typedef bool (*LFUNCCOMMAND)(light_context_t *);
 
-
-/*
-	Options
-	v		Specify verbosity, defaults to o
-	s		Specify target, defaults to sysfs/backlight/auto
-	r		Use raw values instead of percentage
-	
-	Operations
-	H,h 	Print help and exit
-	V		Print version and exit
-	L		List devices
-	
-	G		Get brigthness 
-	M		Get max brightness
-	N		Set minimum cap
-	P		Get minimum cap
-	S		Set brigthness
-	
-	A		Increase brightness
-	U		Decrease brightness
-	O		Save brightness
-	I		Restore brightness
- */
+struct _light_context_t
+{
+    struct 
+    {
+        LFUNCCOMMAND            command; // What command was issued 
+        uint64_t                value; // The input value, in raw mode
+        bool                    raw_mode; // Whether or not we use raw or percentage mode
+        light_device_target_t   *device_target; // The device target to act on
+    } run_params;
+
+    struct
+    {
+        char                    conf_dir[NAME_MAX]; // The path to the application cache directory 
+    } sys_params;
+    
+    light_device_enumerator_t   **enumerators;
+    uint64_t                    num_enumerators;
+};
 
 // The different available commands
 bool light_cmd_print_help(light_context_t *ctx); // H,h 
@@ -107,29 +101,6 @@ bool light_cmd_sub_brightness(light_context_t *ctx); // U
 bool light_cmd_save_brightness(light_context_t *ctx); // O
 bool light_cmd_restore_brightness(light_context_t *ctx); // I
 
-
-// CONFDIR/targets/<enumerator>/<device>/<target>/ minimum|saved
-
-struct _light_context_t
-{
-	struct 
-	{
-		LFUNCCOMMAND			command; // What command was issued 
-		uint64_t				value; // The input value, in raw mode
-		bool					raw_mode; // Whether or not we use raw or percentage mode
-		light_device_target_t	*device_target; // The device target to act on
-	} run_params;
-
-	struct
-	{
-		char					conf_dir[NAME_MAX]; // The path to the application cache directory 
-	} sys_params;
-	
-	light_device_enumerator_t **enumerators;
-	uint64_t num_enumerators;
-
-};
-
 /* Initializes the application, given the command-line. Returns a context. */
 light_context_t* light_initialize(int argc, char **argv);
 
@@ -155,9 +126,9 @@ void light_add_device_target(light_device_t *device, light_device_target_t *new_
 typedef struct _light_target_path_t light_target_path_t;
 struct _light_target_path_t 
 {
-	char enumerator[NAME_MAX];
-	char device[NAME_MAX];
-	char target[NAME_MAX];
+    char enumerator[NAME_MAX];
+    char device[NAME_MAX];
+    char target[NAME_MAX];
 };
 
 bool light_split_target_path(char const * in_path, light_target_path_t *out_path);

src/main.c

@@ -10,18 +10,18 @@
 
 int main(int argc, char **argv)
 {
-	light_context_t *light_ctx = light_initialize(argc, argv);
-	if (light_ctx == NULL) {
-		LIGHT_ERR("Initialization failed");
-		return LIGHT_RETURNVAL_INITFAIL;
-	}
+    light_context_t *light_ctx = light_initialize(argc, argv);
+    if (light_ctx == NULL) {
+        LIGHT_ERR("Initialization failed");
+        return LIGHT_RETURNVAL_INITFAIL;
+    }
 
-	if (!light_execute(light_ctx)) {
-		LIGHT_ERR("Execution failed");
-		light_free(light_ctx);
-		return LIGHT_RETURNVAL_EXECFAIL;
-	}
+    if (!light_execute(light_ctx)) {
+        LIGHT_ERR("Execution failed");
+        light_free(light_ctx);
+        return LIGHT_RETURNVAL_EXECFAIL;
+    }
 
-	light_free(light_ctx);
-	return LIGHT_RETURNVAL_SUCCESS;
+    light_free(light_ctx);
+    return LIGHT_RETURNVAL_SUCCESS;
 }