Remove trailing whitespaces

Removing the trailing whitespaces, that can be quite annoying for
people who use editors which show them. Additionally, it is a good
practice to avoid them.

Signed-off-by: Leonid Bloch <lb.workbox@gmail.com>

DOCUMENTATION.md

 
 The following two sources should be clear enough examples of our coding style:
 
-### Header files 
+### Header files
 
 ```c
-    
+
     #pragma once
-    
+
     #include <stdbool.h>
     #include <stdint.h>
     #include <stdfoo.h> /* foo_type_t */
-    
-    
+
+
     typedef struct _some_struct_t some_struct_t;
-    struct _some_struct_t 
+    struct _some_struct_t
     {
         uint64_t    id;
         foo_type_t  my_foo_thing;
         foo_type_t  *my_foo_ptr;
     }
-    
+
     /* Describe what the purpose of this function is, what it does with/to foo_struct, and what it returns. */
     bool do_some_stuff(some_struct_t *foo_struct);
-    
+
 ```
 
 ### Source files
 bool do_some_stuff(some_struct_t *foo_struct)
 {
     _increment_one(foo_struct->id);
-    
+
     if(foo_struct->id > 33)
     {
         return false;
     }
-    
+
     if(foo_struct->my_foo_ptr != NULL)
     {
         free(foo_struct->my_foo_ptr);
     }
-    
+
     foo_struct->my_foo_ptr = malloc(sizeof(foo_type_t));
-    
+
     return true;
 }
 
 ```
 
-## Implementing an enumerator 
+## Implementing an enumerator
 
 Implementing your own devices through an enumerator is pretty easy. The required steps are as follows:
 
 
 ```c
 
-#pragma once 
+#pragma once
 
 #include "light.h"
 
 // Implementation of the foo enumerator
 // Enumerates devices for quacking ducks
 
-// Device target data 
+// Device target data
 struct _impl_foo_data_t
 {
     int32_t internal_quack_id;
 bool impl_foo_init(light_device_enumerator_t *enumerator)
 {
     /* Lets create a single device, with a single target, for simplicity */
-    
+
     /* Create a new device called new_device_name, we dont need any userdata so pass NULL to the device_data parameter */
     light_device_t *new_device = light_create_device(enumerator, "new_device_name", NULL)
-    
-    /* Setup userdata specific to the target we will create*/ 
+
+    /* Setup userdata specific to the target we will create*/
     /* Useful to for example reference an ID in a third-party API or likewise */
     /* NOTE: The userdata will be free()'d automatically on exit, so you do not need to free it yourself */
     impl_foo_data_t *custom_data = malloc(sizeof(impl_foo_data_t));
     custom_data->internal_quack_id = 333;
-    
-    
+
+
     /* Create a new device target called new_target_name, and pass in the functions and userdata that we just allocated */
     light_create_device_target(new_device, "new_target_name", impl_foo_set, impl_foo_get, impl_foo_getmax, impl_foo_command, custom_data)
-    
+
     /* Return true because we didnt get any errors! */
     return true;
 }

README.md

 -----
 
 Usage follows the following pattern, where options are optional and the neccesity of value depends on the options used
-    
+
     light [options] <value>
 
 ### Command options
 
 ### Extra options
 
-These can be mixed, combined and matched after convenience. 
+These can be mixed, combined and matched after convenience.
 
 * `-r` Raw mode, values (printed and interpreted from commandline) will be treated as integers in the controllers native range, instead of in percent.
 * `-v <verbosity>` Specifies the verbosity level. 0 is default and prints nothing. 1 prints only errors, 2 prints only errors and warnings, and 3 prints both errors, warnings and notices.

src/helpers.c

 #include <sys/types.h>
 #include <dirent.h>
 #include <errno.h> // errno
-#include <libgen.h> // dirname 
+#include <libgen.h> // dirname
 
 
 bool light_file_read_uint64(char const *filename, uint64_t *val)
     char *tempdir = strdup(dir);
     light_mkpath(dirname(tempdir), mode);
     free(tempdir);
-    
+
     return mkdir(dir, mode);
 }
 

src/helpers.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))
 
-/* Verbosity levels: 
+/* Verbosity levels:
 * 0 - No output
 * 1 - Errors
-* 2 - Errors, warnings 
+* 2 - Errors, warnings
 * 3 - Errors, warnings, notices
 */
 typedef enum {

src/impl/razer.c

     impl_razer_data_t *target_data = malloc(sizeof(impl_razer_data_t));
     snprintf(target_data->brightness, sizeof(target_data->brightness), "/sys/bus/hid/drivers/razerkbd/%s/%s", device->name, filename);
     target_data->max_brightness = max_brightness;
-    
+
     // Only add targets that actually exist, as we aren't fully sure exactly what targets exist for a given device
     if(light_file_exists(target_data->brightness))
     {
         light_create_device_target(device, name, impl_razer_set, impl_razer_get, impl_razer_getmax, impl_razer_command, target_data);
     }
-    else 
+    else
     {
         LIGHT_WARN("razer: couldn't add target %s to device %s, the file %s doesn't exist", name, device->name, filename);
         // target_data will not be freed automatically if we dont add a device target with it as userdata, so free it here
 
     // Setup a target to backlight
     _impl_razer_add_target(new_device, "backlight", "matrix_brightness", 255);
-    
+
     // Setup targets to different possible leds
     _impl_razer_add_target(new_device, "game_led", "game_led_state", 1);
     _impl_razer_add_target(new_device, "macro_led", "macro_led_state", 1);
 
 bool impl_razer_init(light_device_enumerator_t *enumerator)
 {
-    // Iterate through the led controllers and create a device_target for each controller 
+    // Iterate through the led controllers and create a device_target for each controller
     DIR *razer_dir;
     struct dirent *curr_entry;
-    
+
     if((razer_dir = opendir("/sys/bus/hid/drivers/razerkbd/")) == NULL)
     {
-        // Razer driver isnt properly installed, so we cant add devices in this enumerator 
+        // Razer driver isnt properly installed, so we cant add devices in this enumerator
         return true;
     }
-    
+
     while((curr_entry = readdir(razer_dir)) != NULL)
     {
         // Skip dot entries
         {
             continue;
         }
- 
+
         _impl_razer_add_device(enumerator, curr_entry->d_name);
     }
-    
+
     closedir(razer_dir);
-    
+
     return true;
 }
 
         LIGHT_ERR("failed to write to razer device");
         return false;
     }
-    
+
     return true;
 }
 
         LIGHT_ERR("failed to read from razer device");
         return false;
     }
-    
+
     return true;
 }
 
     impl_razer_data_t *data = (impl_razer_data_t*)target->device_target_data;
 
     *out_value = data->max_brightness;
-    
+
     return true;
 }
 

src/impl/razer.h

 
-#pragma once 
+#pragma once
 
 #include "light.h"
 
 // Implementation of the razer enumerator
 // Enumerates devices for the openrazer driver https://github.com/openrazer/openrazer
 
-// Device target data 
+// Device target data
 struct _impl_razer_data_t
 {
     char brightness[NAME_MAX];

src/impl/sysfs.c

     // Create a new backlight device
     light_device_t *leds_device = light_create_device(enumerator, "leds", NULL);
 
-    // Iterate through the led controllers and create a device_target for each controller 
+    // 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
         {
             continue;
         }
-        
-        // Setup the target data 
+
+        // Setup the target data
         impl_sysfs_data_t *dev_data = malloc(sizeof(impl_sysfs_data_t));
         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);
-        
-        // Create a new device target for the controller 
+
+        // Create a new device target for the controller
         light_create_device_target(leds_device, curr_entry->d_name, impl_sysfs_set, impl_sysfs_get, impl_sysfs_getmax, impl_sysfs_command, dev_data);
     }
-    
+
     closedir(leds_dir);
-    
+
     return true;
 }
 
     // Create a new backlight device
     light_device_t *backlight_device = light_create_device(enumerator, "backlight", NULL);
 
-    // Iterate through the backlight controllers and create a device_target for each controller 
+    // 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
         {
             continue;
         }
-        
-        // Setup the target data 
+
+        // Setup the target data
         impl_sysfs_data_t *dev_data = malloc(sizeof(impl_sysfs_data_t));
         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);
-        
-        // Create a new device target for the controller 
+
+        // Create a new device target for the controller
         light_create_device_target(backlight_device, curr_entry->d_name, impl_sysfs_set, impl_sysfs_get, impl_sysfs_getmax, impl_sysfs_command, dev_data);
-        
+
         // 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))
             }
         }
     }
-    
+
     closedir(backlight_dir);
-    
+
     // If we found at least one usable controller, create an auto target mapped to that controller
     if(best_value > 0)
     {
-        // Setup the target data 
+        // Setup the target data
         impl_sysfs_data_t *dev_data = malloc(sizeof(impl_sysfs_data_t));
         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);
-        
-        // Create a new device target for the controller 
+
+        // Create a new device target for the controller
         light_create_device_target(backlight_device, "auto", impl_sysfs_set, impl_sysfs_get, impl_sysfs_getmax, impl_sysfs_command, dev_data);
     }
-    
+
     return true;
 }
 
 bool impl_sysfs_init(light_device_enumerator_t *enumerator)
 {
-    // Create a device for the backlight 
+    // Create a device for the backlight
     _impl_sysfs_init_backlight(enumerator);
-    
+
     // Create devices for the leds
     _impl_sysfs_init_leds(enumerator);
-    
+
     return true;
 }
 
         LIGHT_ERR("failed to write to sysfs device");
         return false;
     }
-    
+
     return true;
 }
 
         LIGHT_ERR("failed to read from sysfs device");
         return false;
     }
-    
+
     return true;
 }
 
         LIGHT_ERR("failed to read from sysfs device");
         return false;
     }
-    
+
     return true;
 }
 

src/impl/sysfs.h

 
-#pragma once 
+#pragma once
 
 #include "light.h"
 
 // Implementation of the sysfs enumerator
 // Enumerates devices for backlights and leds
 
-// Device target data 
+// Device target data
 struct _impl_sysfs_data_t
 {
     char brightness[NAME_MAX];

src/impl/util.h

 
-#pragma once 
+#pragma once
 
 #include "light.h"
 

src/light.c

 
 static void _light_add_enumerator_device(light_device_enumerator_t *enumerator, light_device_t *new_device)
 {
-    // Create a new device array 
+    // Create a new device array
     uint64_t new_num_devices = enumerator->num_devices + 1;
     light_device_t **new_devices = malloc(new_num_devices * sizeof(light_device_t*));
-    
+
     // Copy old device array to new one
     for(uint64_t i = 0; i < enumerator->num_devices; i++)
     {
         new_devices[i] = enumerator->devices[i];
     }
-    
+
     // Set the new device
     new_devices[enumerator->num_devices] = new_device;
-    
+
     // Free the old devices array, if needed
     if(enumerator->devices != NULL)
     {
         free(enumerator->devices);
     }
-    
+
     // Replace the devices array with the new one
     enumerator->devices = new_devices;
     enumerator->num_devices = new_num_devices;
 
 static void _light_add_device_target(light_device_t *device, light_device_target_t *new_target)
 {
-    // Create a new targets array 
+    // Create a new targets array
     uint64_t new_num_targets = device->num_targets + 1;
     light_device_target_t **new_targets = malloc(new_num_targets * sizeof(light_device_target_t*));
-    
+
     // Copy old targets array to new one
     for(uint64_t i = 0; i < device->num_targets; i++)
     {
         new_targets[i] = device->targets[i];
     }
-    
+
     // Set the new target
     new_targets[device->num_targets] = new_target;
-    
+
     // Free the old targets array, if needed
     if(device->targets != NULL)
     {
         free(device->targets);
     }
-    
+
     // Replace the targets array with the new one
     device->targets= new_targets;
     device->num_targets = new_num_targets;
     {
         return 0;
     }
-    
+
     return minimum_value;
 }
 
             return ctx->enumerators[e];
         }
     }
-    
+
     return NULL;
 }
 
             return en->devices[d];
         }
     }
-    
+
     return NULL;
 }
 
             return dev->targets[t];
         }
     }
-    
+
     return NULL;
 }
 
         double max_value_d = (double)max_value;
         double percent = light_percent_clamp((inraw_d / max_value_d) * 100.0);
         *outpercent = percent;
-        
+
         return true;
 }
 
     double target_value_d = max_value_d * (light_percent_clamp(inpercent) / 100.0);
     uint64_t target_value = LIGHT_CLAMP((uint64_t)target_value_d, 0, max_value);
     *outraw = target_value;
-    
+
     return true;
 }
 
         "  -H, -h      Show this help and exit\n"
         "  -V          Show program version and exit\n"
         "  -L          List available devices\n"
-        
+
         "  -A          Increase brightness by value\n"
-        "  -U          Decrease brightness by value\n" 
+        "  -U          Decrease brightness by value\n"
         "  -T          Multiply brightness by value (can be a non-whole number, ignores raw mode)\n"
         "  -S          Set brightness to value\n"
         "  -G          Get brightness\n"
         LIGHT_WARN("a command was already set. ignoring.");
         return false;
     }
-    
+
     ctx->run_params.command = new_cmd;
     return true;
 }
 {
     int32_t curr_arg = -1;
     int32_t log_level = 0;
-    
+
     char ctrl_name[NAME_MAX];
     bool need_value = false;
     bool need_float_value = false;
     bool need_target = true; // default cmd is get brightness
     bool specified_target = false;
     snprintf(ctrl_name, sizeof(ctrl_name), "%s", "sysfs/backlight/auto");
-    
+
     while((curr_arg = getopt(argc, argv, "HhVGSLMNPAUTOIv:s:r")) != -1)
     {
         switch(curr_arg)
         {
             // Options
-            
+
             case 'v':
                 if (sscanf(optarg, "%i", &log_level) != 1)
                 {
                     _light_print_usage();
                     return false;
                 }
-                
+
                 if (log_level < 0 || log_level > 3)
                 {
                     fprintf(stderr, "-v argument must be between 0 and 3.\n\n");
                     _light_print_usage();
                     return false;
                 }
-                
+
                 light_loglevel = (light_loglevel_t)log_level;
                 break;
             case 's':
             case 'r':
                 ctx->run_params.raw_mode = true;
                 break;
-            
+
             // Commands
             case 'H':
             case 'h':
     {
         _light_set_context_command(ctx, light_cmd_get_brightness);
     }
-    
+
     if(need_target)
     {
         light_device_target_t *curr_target = light_find_device_target(ctx, ctrl_name);
                 fprintf(stderr, "We couldn't find the specified device target at the path \"%s\". Use -L to find one.\n\n", ctrl_name);
                 return false;
             }
-            else 
+            else
             {
                 fprintf(stderr, "No backlight controller was found, so we could not decide an automatic target. The current command will have no effect. Please use -L to find a target and then specify it with -s.\n\n");
                 curr_target = light_find_device_target(ctx, "util/test/dryrun");
             }
         }
-        
+
         ctx->run_params.device_target = curr_target;
     }
 
                 _light_print_usage();
                 return false;
             }
-            
+
             percent_value = light_percent_clamp(percent_value);
-            
+
             uint64_t raw_value = 0;
             if(!_light_percent_to_raw(ctx->run_params.device_target, percent_value, &raw_value))
             {
                 LIGHT_ERR("failed to convert from percent to raw for device target");
                 return false;
             }
-            
+
             ctx->run_params.value = raw_value;
         }
     }
     }
 
     return true;
-    
+
 }
 
 
     else
     {
         char *xdg_conf = getenv("XDG_CONFIG_HOME");
-        
+
         if (xdg_conf != NULL)
         {
             snprintf(new_ctx->sys_params.conf_dir, sizeof(new_ctx->sys_params.conf_dir), "%s/light", xdg_conf);
             snprintf(new_ctx->sys_params.conf_dir, sizeof(new_ctx->sys_params.conf_dir), "%s/.config/light", getenv("HOME"));
         }
     }
-    
+
     // Make sure the configuration folder exists, otherwise attempt to create it
     int32_t rc = light_mkpath(new_ctx->sys_params.conf_dir, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
     if (rc && errno != EEXIST)
         LIGHT_WARN("couldn't create configuration directory");
         return false;
     }
-    
+
     // Create the built-in enumerators
     light_create_enumerator(new_ctx, "sysfs", &impl_sysfs_init, &impl_sysfs_free);
     light_create_enumerator(new_ctx, "util", &impl_util_init, &impl_util_free);
         LIGHT_ERR("failed to parse arguments");
         return NULL;
     }
-    
+
     return new_ctx;
 }
 
         LIGHT_ERR("run parameters command was null, can't execute");
         return false;
     }
-    
+
     return ctx->run_params.command(ctx);
 }
 
     {
         LIGHT_WARN("failed to free all enumerators");
     }
-    
+
     free(ctx);
 }
 
 light_device_enumerator_t * light_create_enumerator(light_context_t *ctx, char const * name, LFUNCENUMINIT init_func, LFUNCENUMFREE free_func)
 {
-    // Create a new enumerator array 
+    // Create a new enumerator array
     uint64_t new_num_enumerators = ctx->num_enumerators + 1;
     light_device_enumerator_t **new_enumerators = malloc(new_num_enumerators * sizeof(light_device_enumerator_t*));
-    
+
     // Copy old enumerator array to new one
     for(uint64_t i = 0; i < ctx->num_enumerators; i++)
     {
         new_enumerators[i] = ctx->enumerators[i];
     }
-    
+
     // Allocate the new enumerator
     new_enumerators[ctx->num_enumerators] = malloc(sizeof(light_device_enumerator_t));
     light_device_enumerator_t *returner = new_enumerators[ctx->num_enumerators];
-    
+
     returner->devices = NULL;
     returner->num_devices = 0;
     returner->init = init_func;
     returner->free = free_func;
     snprintf(returner->name, sizeof(returner->name), "%s", name);
-    
+
     // Free the old enumerator array, if needed
     if(ctx->enumerators != NULL)
     {
         free(ctx->enumerators);
     }
-    
+
     // Replace the enumerator array with the new one
     ctx->enumerators = new_enumerators;
     ctx->num_enumerators = new_num_enumerators;
-    
+
     // Return newly created device
     return returner;
 }
             success = false;
         }
     }
-    
+
     return success;
 }
 
     for(uint64_t i = 0; i < ctx->num_enumerators; i++)
     {
         light_device_enumerator_t * curr_enumerator = ctx->enumerators[i];
-        
+
         if(!curr_enumerator->free(curr_enumerator))
         {
             success = false;
         }
-        
+
         if(curr_enumerator->devices != NULL)
         {
             for(uint64_t d = 0; d < curr_enumerator->num_devices; d++)
             {
                 light_delete_device(curr_enumerator->devices[d]);
             }
-            
+
             free(curr_enumerator->devices);
             curr_enumerator->devices = NULL;
         }
-        
+
         free(curr_enumerator);
     }
-    
+
     free(ctx->enumerators);
     ctx->enumerators = NULL;
     ctx->num_enumerators = 0;
-    
+
     return success;
 }
 
         LIGHT_WARN("invalid path passed to split_target_path");
         return false;
     }
-    
+
     size_t size = end - begin;
     strncpy(out_path->enumerator, begin, size);
     out_path->enumerator[size] = '\0';
-    
+
     begin = end + 1;
     end = strstr(begin, "/");
     if(end == NULL)
         LIGHT_WARN("invalid path passed to split_target_path");
         return false;
     }
-    
+
     size = end - begin;
     strncpy(out_path->device, begin, size);
     out_path->device[size] = '\0';
-    
+
     strcpy(out_path->target, end + 1);
-    
+
     return true;
 }
 
         LIGHT_WARN("light_find_device_target needs a path in the format of \"enumerator/device/target\", the following format is not recognized:  \"%s\"", name);
         return NULL;
     }
-    
+
     /*
     Uncomment to debug the split function
     printf("enumerator: %s %u\ndevice: %s %u\ntarget: %s %u\n",
             new_path.device, strlen(new_path.device),
             new_path.target, strlen(new_path.target));
     */
-    
-    // find a matching enumerator 
-    
+
+    // find a matching enumerator
+
     light_device_enumerator_t *enumerator = _light_find_enumerator(ctx, new_path.enumerator);
     if(enumerator == NULL)
     {
         LIGHT_WARN("no such enumerator, \"%s\"", new_path.enumerator);
         return NULL;
     }
-    
+
     light_device_t *device = _light_find_device(enumerator, new_path.device);
     if(device == NULL)
     {
         LIGHT_WARN("no such device, \"%s\"", new_path.device);
         return NULL;
     }
-    
+
     light_device_target_t *target = _light_find_target(device, new_path.target);
     if(target == NULL)
     {
         LIGHT_WARN("no such target, \"%s\"", new_path.target);
         return NULL;
     }
-    
+
     return target;
 }
 
             for(uint64_t target = 0; target < curr_device->num_targets; target++)
             {
                 light_device_target_t *curr_target = curr_device->targets[target];
-                
+
                 printf("\t%s/%s/%s\n", curr_enumerator->name, curr_device->name, curr_target->name);
             }
         }
     }
-    
+
     return true;
 }
 
         LIGHT_ERR("didn't have a valid target, programmer mistake");
         return false;
     }
-    
-    
+
+
     uint64_t mincap = _light_get_min_cap(ctx);
     uint64_t value = ctx->run_params.value;
     if(mincap > value)
     {
         value = mincap;
     }
-    
+
     if(!target->set_value(target, value))
     {
         LIGHT_ERR("failed to write to target");
         return false;
     }
-    
+
     return true;
 }
 
         LIGHT_ERR("didn't have a valid target, programmer mistake");
         return false;
     }
-    
+
     uint64_t value = 0;
     if(!target->get_value(target, &value))
     {
         LIGHT_ERR("failed to read from target");
         return false;
     }
-    
+
     if(ctx->run_params.raw_mode)
     {
         printf("%" PRIu64 "\n", value);
     }
-    else 
+    else
     {
         double percent = 0.0;
         if(!_light_raw_to_percent(target, value, &percent))
         }
         printf("%.2f\n", percent);
     }
-    
+
     return true;
 }
 
         LIGHT_ERR("didn't have a valid target, programmer mistake");
         return false;
     }
-    
+
     if(!ctx->run_params.raw_mode)
     {
         printf("100.0\n");
         return true;
     }
-    
+
     uint64_t max_value = 0;
     if(!target->get_max_value(target, &max_value))
     {
         LIGHT_ERR("failed to read from device target");
         return false;
     }
-    
+
     printf("%" PRIu64 "\n", max_value);
     return true;
 }
 {
     char target_path[NAME_MAX];
     _light_get_target_path(ctx, target_path, sizeof(target_path));
-    
+
     // Make sure the target folder exists, otherwise attempt to create it
     int32_t rc = light_mkpath(target_path, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
     if (rc && errno != EEXIST)
         LIGHT_ERR("couldn't create target directory for minimum brightness");
         return false;
     }
-    
+
     char target_filepath[NAME_MAX];
     _light_get_target_file(ctx, target_filepath, sizeof(target_filepath), "minimum");
-    
+
     if(!light_file_write_uint64(target_filepath, ctx->run_params.value))
     {
         LIGHT_ERR("couldn't write value to minimum file");
         return false;
     }
-    
+
     return true;
 }
 
         {
             printf("0\n");
         }
-        else 
+        else
         {
             printf("0.00\n");
         }
 
         return true;
     }
-    
+
     if(ctx->run_params.raw_mode)
     {
         printf("%" PRIu64 "\n", minimum_value);
     }
-    else 
+    else
     {
         double minimum_d = 0.0;
         if(!_light_raw_to_percent(ctx->run_params.device_target, minimum_value, &minimum_d))
             LIGHT_ERR("failed to convert value from raw to percent for device target");
             return false;
         }
-        
+
         printf("%.2f\n", minimum_d);
     }
-    
+
     return true;
 }
 
         LIGHT_ERR("didn't have a valid target, programmer mistake");
         return false;
     }
-    
+
     uint64_t value = 0;
     if(!target->get_value(target, &value))
     {
         LIGHT_ERR("failed to read from target");
         return false;
     }
-    
+
     uint64_t max_value = 0;
     if(!target->get_max_value(target, &max_value))
     {
         LIGHT_ERR("failed to read from target");
         return false;
     }
-    
+
     value += ctx->run_params.value;
-    
+
     uint64_t mincap = _light_get_min_cap(ctx);
     if(mincap > value)
     {
         value = mincap;
     }
-    
-    
+
+
     if(value > max_value)
     {
         value = max_value;
     }
-    
+
     if(!target->set_value(target, value))
     {
         LIGHT_ERR("failed to write to target");
         return false;
     }
-    
+
     return true;
 }
 
         LIGHT_ERR("didn't have a valid target, programmer mistake");
         return false;
     }
-    
+
     uint64_t value = 0;
     if(!target->get_value(target, &value))
     {
         LIGHT_ERR("failed to read from target");
         return false;
     }
-    
+
     if(value > ctx->run_params.value)
     {
         value -= ctx->run_params.value;
     }
-    else 
+    else
     {
         value = 0;
     }
-    
+
     uint64_t mincap = _light_get_min_cap(ctx);
     if(mincap > value)
     {
         LIGHT_ERR("failed to write to target");
         return false;
     }
-    
+
     return true;
 }
 
 
     uint64_t old_value = value;
     value *= ctx->run_params.float_value;
- 
+
     // Check that we actually de/increase value
     if(value == old_value)
     {
 {
     char target_path[NAME_MAX];
     _light_get_target_path(ctx, target_path, sizeof(target_path));
-    
+
     // Make sure the target folder exists, otherwise attempt to create it
     int32_t rc = light_mkpath(target_path, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
     if (rc && errno != EEXIST)
         LIGHT_ERR("couldn't create target directory for save brightness");
         return false;
     }
-    
+
     char target_filepath[NAME_MAX];
     _light_get_target_file(ctx, target_filepath, sizeof(target_filepath), "save");
 
         LIGHT_ERR("couldn't read from device target");
         return false;
     }
-    
+
     if(!light_file_write_uint64(target_filepath, curr_value))
     {
         LIGHT_ERR("couldn't write value to savefile");
         return false;
     }
-    
+
     return true;
 }
 
         LIGHT_ERR("couldn't read value from savefile");
         return false;
     }
-    
+
     uint64_t mincap = _light_get_min_cap(ctx);
     if(mincap > saved_value)
     {
         saved_value = mincap;
     }
-    
+
     if(!ctx->run_params.device_target->set_value(ctx->run_params.device_target, saved_value))
     {
         LIGHT_ERR("couldn't write saved value to device target");
         return false;
     }
-    
+
     return true;
 }
 
     new_device->targets = NULL;
     new_device->num_targets = 0;
     new_device->device_data = device_data;
-    
+
     snprintf(new_device->name, sizeof(new_device->name), "%s", name);
-    
+
     _light_add_enumerator_device(enumerator, new_device);
-    
+
     return new_device;
 }
 
     {
         light_delete_device_target(device->targets[i]);
     }
-    
+
     if(device->targets != NULL)
     {
         free(device->targets);
     }
-    
+
     if(device->device_data != NULL)
     {
         free(device->device_data);
     }
-    
+
     free(device);
 }
 
     new_target->get_max_value = getmaxfunc;
     new_target->custom_command = cmdfunc;
     new_target->device_target_data = target_data;
-    
+
     snprintf(new_target->name, sizeof(new_target->name), "%s", name);
-    
+
     _light_add_device_target(device, new_target);
-    
+
     return new_target;
 }
 
     {
         free(device_target->device_target_data);
     }
-    
+
     free(device_target);
 }

src/light.h

 
 struct _light_context_t
 {
-    struct 
+    struct
     {
         LFUNCCOMMAND            command; // What command was issued
         // Only one of value and raw_value is populated; which one depends on the command
 
     struct
     {
-        char                    conf_dir[NAME_MAX]; // The path to the application cache directory 
+        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 
+bool light_cmd_print_help(light_context_t *ctx); // H,h
 bool light_cmd_print_version(light_context_t *ctx); // V
 bool light_cmd_list_devices(light_context_t *ctx); // L
 bool light_cmd_set_brightness(light_context_t *ctx); // S
 void light_delete_device_target(light_device_target_t *device_target);
 
 typedef struct _light_target_path_t light_target_path_t;
-struct _light_target_path_t 
+struct _light_target_path_t
 {
     char enumerator[NAME_MAX];
     char device[NAME_MAX];