cursor: rename local variables to snake case

Signed-off-by: Simon Ser <contact@emersion.fr>

diff --git a/cursor/xcursor.c b/cursor/xcursor.c
index 307fb36..19b56c0 100644 (file)
--- a/cursor/xcursor.c
+++ b/cursor/xcursor.c
@@ -266,34 +266,34 @@ xcursor_read_uint(FILE *file, uint32_t *u)
 }
 
 static void
-xcursor_file_header_destroy(struct xcursor_file_header *fileHeader)
+xcursor_file_header_destroy(struct xcursor_file_header *file_header)
 {
-       free(fileHeader);
+       free(file_header);
 }
 
 static struct xcursor_file_header *
 xcursor_file_header_create(uint32_t ntoc)
 {
-       struct xcursor_file_header *fileHeader;
+       struct xcursor_file_header *file_header;
 
        if (ntoc > 0x10000)
                return NULL;
-       fileHeader = malloc(sizeof(struct xcursor_file_header) +
+       file_header = malloc(sizeof(struct xcursor_file_header) +
                            ntoc * sizeof(struct xcursor_file_toc));
-       if (!fileHeader)
-               return NULL;
-       fileHeader->magic = XCURSOR_MAGIC;
-       fileHeader->header = XCURSOR_FILE_HEADER_LEN;
-       fileHeader->version = XCURSOR_FILE_VERSION;
-       fileHeader->ntoc = ntoc;
-       fileHeader->tocs = (struct xcursor_file_toc *) (fileHeader + 1);
-       return fileHeader;
+       if (!file_header)
+               return NULL;
+       file_header->magic = XCURSOR_MAGIC;
+       file_header->header = XCURSOR_FILE_HEADER_LEN;
+       file_header->version = XCURSOR_FILE_VERSION;
+       file_header->ntoc = ntoc;
+       file_header->tocs = (struct xcursor_file_toc *) (file_header + 1);
+       return file_header;
 }
 
 static struct xcursor_file_header *
 xcursor_read_file_header(FILE *file)
 {
-       struct xcursor_file_header head, *fileHeader;
+       struct xcursor_file_header head, *file_header;
        uint32_t skip;
        unsigned int n;
 
@@ -314,60 +314,60 @@ xcursor_read_file_header(FILE *file)
        if (skip)
                if (fseek(file, skip, SEEK_CUR) == EOF)
                        return NULL;
-       fileHeader = xcursor_file_header_create(head.ntoc);
-       if (!fileHeader)
-               return NULL;
-       fileHeader->magic = head.magic;
-       fileHeader->header = head.header;
-       fileHeader->version = head.version;
-       fileHeader->ntoc = head.ntoc;
-       for (n = 0; n < fileHeader->ntoc; n++) {
-               if (!xcursor_read_uint(file, &fileHeader->tocs[n].type))
+       file_header = xcursor_file_header_create(head.ntoc);
+       if (!file_header)
+               return NULL;
+       file_header->magic = head.magic;
+       file_header->header = head.header;
+       file_header->version = head.version;
+       file_header->ntoc = head.ntoc;
+       for (n = 0; n < file_header->ntoc; n++) {
+               if (!xcursor_read_uint(file, &file_header->tocs[n].type))
                        break;
-               if (!xcursor_read_uint(file, &fileHeader->tocs[n].subtype))
+               if (!xcursor_read_uint(file, &file_header->tocs[n].subtype))
                        break;
-               if (!xcursor_read_uint(file, &fileHeader->tocs[n].position))
+               if (!xcursor_read_uint(file, &file_header->tocs[n].position))
                        break;
        }
-       if (n != fileHeader->ntoc) {
-               xcursor_file_header_destroy(fileHeader);
+       if (n != file_header->ntoc) {
+               xcursor_file_header_destroy(file_header);
                return NULL;
        }
-       return fileHeader;
+       return file_header;
 }
 
 static bool
 xcursor_seek_to_toc(FILE *file,
-                   struct xcursor_file_header *fileHeader,
+                   struct xcursor_file_header *file_header,
                    int toc)
 {
-       if (!file || !fileHeader ||
-           fseek(file, fileHeader->tocs[toc].position, SEEK_SET) == EOF)
+       if (!file || !file_header ||
+           fseek(file, file_header->tocs[toc].position, SEEK_SET) == EOF)
                return false;
        return true;
 }
 
 static bool
 xcursor_file_read_chunk_header(FILE *file,
-                              struct xcursor_file_header *fileHeader,
+                              struct xcursor_file_header *file_header,
                               int toc,
-                              struct xcursor_chunk_header *chunkHeader)
+                              struct xcursor_chunk_header *chunk_header)
 {
-       if (!file || !fileHeader || !chunkHeader)
+       if (!file || !file_header || !chunk_header)
                return false;
-       if (!xcursor_seek_to_toc(file, fileHeader, toc))
+       if (!xcursor_seek_to_toc(file, file_header, toc))
                return false;
-       if (!xcursor_read_uint(file, &chunkHeader->header))
+       if (!xcursor_read_uint(file, &chunk_header->header))
                return false;
-       if (!xcursor_read_uint(file, &chunkHeader->type))
+       if (!xcursor_read_uint(file, &chunk_header->type))
                return false;
-       if (!xcursor_read_uint(file, &chunkHeader->subtype))
+       if (!xcursor_read_uint(file, &chunk_header->subtype))
                return false;
-       if (!xcursor_read_uint(file, &chunkHeader->version))
+       if (!xcursor_read_uint(file, &chunk_header->version))
                return false;
        /* sanity check */
-       if (chunkHeader->type != fileHeader->tocs[toc].type ||
-           chunkHeader->subtype != fileHeader->tocs[toc].subtype)
+       if (chunk_header->type != file_header->tocs[toc].type ||
+           chunk_header->subtype != file_header->tocs[toc].subtype)
                return false;
        return true;
 }
@@ -379,72 +379,72 @@ dist(uint32_t a, uint32_t b)
 }
 
 static uint32_t
-xcursor_file_best_size(struct xcursor_file_header *fileHeader,
+xcursor_file_best_size(struct xcursor_file_header *file_header,
                       uint32_t size, int *nsizesp)
 {
        unsigned int n;
        int nsizes = 0;
-       uint32_t bestSize = 0;
-       uint32_t thisSize;
+       uint32_t best_size = 0;
+       uint32_t this_size;
 
-       if (!fileHeader || !nsizesp)
+       if (!file_header || !nsizesp)
                return 0;
 
-       for (n = 0; n < fileHeader->ntoc; n++) {
-               if (fileHeader->tocs[n].type != XCURSOR_IMAGE_TYPE)
+       for (n = 0; n < file_header->ntoc; n++) {
+               if (file_header->tocs[n].type != XCURSOR_IMAGE_TYPE)
                        continue;
-               thisSize = fileHeader->tocs[n].subtype;
-               if (!bestSize || dist(thisSize, size) < dist(bestSize, size)) {
-                       bestSize = thisSize;
+               this_size = file_header->tocs[n].subtype;
+               if (!best_size || dist(this_size, size) < dist(best_size, size)) {
+                       best_size = this_size;
                        nsizes = 1;
-               } else if (thisSize == bestSize) {
+               } else if (this_size == best_size) {
                        nsizes++;
                }
        }
        *nsizesp = nsizes;
-       return bestSize;
+       return best_size;
 }
 
 static int
-xcursor_find_image_toc(struct xcursor_file_header *fileHeader,
+xcursor_find_image_toc(struct xcursor_file_header *file_header,
                       uint32_t size, int count)
 {
        unsigned int toc;
-       uint32_t thisSize;
+       uint32_t this_size;
 
-       if (!fileHeader)
+       if (!file_header)
                return 0;
 
-       for (toc = 0; toc < fileHeader->ntoc; toc++) {
-               if (fileHeader->tocs[toc].type != XCURSOR_IMAGE_TYPE)
+       for (toc = 0; toc < file_header->ntoc; toc++) {
+               if (file_header->tocs[toc].type != XCURSOR_IMAGE_TYPE)
                        continue;
-               thisSize = fileHeader->tocs[toc].subtype;
-               if (thisSize != size)
+               this_size = file_header->tocs[toc].subtype;
+               if (this_size != size)
                        continue;
                if (!count)
                        break;
                count--;
        }
-       if (toc == fileHeader->ntoc)
+       if (toc == file_header->ntoc)
                return -1;
        return toc;
 }
 
 static struct xcursor_image *
 xcursor_read_image(FILE *file,
-                  struct xcursor_file_header *fileHeader,
+                  struct xcursor_file_header *file_header,
                   int toc)
 {
-       struct xcursor_chunk_header chunkHeader;
+       struct xcursor_chunk_header chunk_header;
        struct xcursor_image head;
        struct xcursor_image *image;
        int n;
        uint32_t *p;
 
-       if (!file || !fileHeader)
+       if (!file || !file_header)
                return NULL;
 
-       if (!xcursor_file_read_chunk_header(file, fileHeader, toc, &chunkHeader))
+       if (!xcursor_file_read_chunk_header(file, file_header, toc, &chunk_header))
                return NULL;
        if (!xcursor_read_uint(file, &head.width))
                return NULL;
@@ -469,9 +469,9 @@ xcursor_read_image(FILE *file,
        image = xcursor_image_create(head.width, head.height);
        if (image == NULL)
                return NULL;
-       if (chunkHeader.version < image->version)
-               image->version = chunkHeader.version;
-       image->size = chunkHeader.subtype;
+       if (chunk_header.version < image->version)
+               image->version = chunk_header.version;
+       image->size = chunk_header.subtype;
        image->xhot = head.xhot;
        image->yhot = head.yhot;
        image->delay = head.delay;
@@ -490,8 +490,8 @@ xcursor_read_image(FILE *file,
 static struct xcursor_images *
 xcursor_xc_file_load_images(FILE *file, int size)
 {
-       struct xcursor_file_header *fileHeader;
-       uint32_t bestSize;
+       struct xcursor_file_header *file_header;
+       uint32_t best_size;
        int nsize;
        struct xcursor_images *images;
        int n;
@@ -499,30 +499,30 @@ xcursor_xc_file_load_images(FILE *file, int size)
 
        if (!file || size < 0)
                return NULL;
-       fileHeader = xcursor_read_file_header(file);
-       if (!fileHeader)
+       file_header = xcursor_read_file_header(file);
+       if (!file_header)
                return NULL;
-       bestSize = xcursor_file_best_size(fileHeader, (uint32_t) size, &nsize);
-       if (!bestSize) {
-               xcursor_file_header_destroy(fileHeader);
+       best_size = xcursor_file_best_size(file_header, (uint32_t) size, &nsize);
+       if (!best_size) {
+               xcursor_file_header_destroy(file_header);
                return NULL;
        }
        images = xcursor_images_create(nsize);
        if (!images) {
-               xcursor_file_header_destroy(fileHeader);
+               xcursor_file_header_destroy(file_header);
                return NULL;
        }
        for (n = 0; n < nsize; n++) {
-               toc = xcursor_find_image_toc(fileHeader, bestSize, n);
+               toc = xcursor_find_image_toc(file_header, best_size, n);
                if (toc < 0)
                        break;
-               images->images[images->nimage] = xcursor_read_image(file, fileHeader,
+               images->images[images->nimage] = xcursor_read_image(file, file_header,
                                                                    toc);
                if (!images->images[images->nimage])
                        break;
                images->nimage++;
        }
-       xcursor_file_header_destroy(fileHeader);
+       xcursor_file_header_destroy(file_header);
        if (images->nimage != nsize) {
                xcursor_images_destroy(images);
                images = NULL;