Various small changes

9 files changed, 51 insertions, 47 deletions

diff --git a/fgetc.c b/fgetc.c
index 4aaffeb..98c7f6a 100644
--- a/fgetc.c
+++ b/fgetc.c
@@ -1,10 +1,10 @@
-#include <stdio.h>
-#include "fgetc.h"
-
 /* ************************************************************************ */
 /* Custom fgetc/ungetc implementation able to unget more than one character */
 /* ************************************************************************ */
 
+#include <stdio.h>
+#include "fgetc.h"
+
 enum
 {
   GETC_BUFF_SIZE = 16
diff --git a/index.c b/index.c
index b1e69d6..5aa0bcd 100644
--- a/index.c
+++ b/index.c
@@ -1,5 +1,5 @@
 /* *************************************************************** */
-/* Ternary Search Tree functions                                   */
+/* Ternary Search Tree and sorted array creation functions         */
 /* Inspired by: https://www.cs.princeton.edu/~rs/strings/tstdemo.c */
 /* *************************************************************** */
 
diff --git a/index.h b/index.h
index a22d236..02c4679 100644
--- a/index.h
+++ b/index.h
@@ -1,5 +1,5 @@
-#ifndef TST_H
-#define TST_H
+#ifndef INDEX_H
+#define INDEX_H
 
 /* *************************************** */
 /* Ternary Search Tree specific structures */
diff --git a/list.c b/list.c
index 6f0996f..1daefc0 100644
--- a/list.c
+++ b/list.c
@@ -1,13 +1,3 @@
-#include "config.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <limits.h>
-#include <string.h>
-#include <errno.h>
-
-#include "xmalloc.h"
-#include "list.h"
-
 /* ********************************************************************* */
 /* Tiny list immplementation.                                            */
 /*                                                                       */
@@ -18,6 +8,16 @@
 /* the structure members (head, tail, len, data, prev, next)             */
 /* ********************************************************************* */
 
+#include "config.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <string.h>
+#include <errno.h>
+
+#include "xmalloc.h"
+#include "list.h"
+
 /* ======================== */
 /* Create a new linked list */
 /* ======================== */
@@ -186,7 +186,7 @@ ll_insert_after(ll_t * const list, ll_node_t * node, void * const data)
 /* Based on code found here:                              */
 /* http://www.geeksforgeeks.org/quicksort-for-linked-list */
 /* ====================================================== */
-ll_node_t *
+static ll_node_t *
 ll_partition(ll_node_t * l, ll_node_t * h, int (*comp)(void *, void *),
              void (*swap)(void *, void *))
 {
@@ -221,7 +221,7 @@ ll_partition(ll_node_t * l, ll_node_t * h, int (*comp)(void *, void *),
 /* ======================================================= */
 /* A recursive implementation of quicksort for linked list */
 /* ======================================================= */
-void
+static void
 ll_quicksort(ll_node_t * l, ll_node_t * h, int (*comp)(void *, void *),
              void (*swap)(void * a, void *))
 {
diff --git a/list.h b/list.h
index 76c7b40..90bca3f 100644
--- a/list.h
+++ b/list.h
@@ -29,21 +29,20 @@ struct ll_s
 int
 ll_append(ll_t * const list, void * const data);
 
-#if 0 /* here for coherency but not used. */
-int ll_prepend(ll_t * const list, void *const data);
+int
+ll_prepend(ll_t * const list, void * const data);
 
 void
-ll_insert_before(ll_t * const list, ll_node_t * node, void *const data);
+ll_insert_before(ll_t * const list, ll_node_t * node, void * const data);
 
 void
-ll_insert_after(ll_t * const list, ll_node_t * node, void *const data);
-#endif
+ll_insert_after(ll_t * const list, ll_node_t * node, void * const data);
 
-ll_node_t *
+static ll_node_t *
 ll_partition(ll_node_t * l, ll_node_t * h, int (*comp)(void *, void *),
              void (*swap)(void *, void *));
 
-void
+static void
 ll_quicksort(ll_node_t * l, ll_node_t * h, int (*comp)(void *, void *),
              void (*swap)(void * a, void *));
 
diff --git a/smenu.c b/smenu.c
index 76dc443..baa16ed 100644
--- a/smenu.c
+++ b/smenu.c
@@ -1055,7 +1055,7 @@ update_bitmaps(search_mode_t mode, search_data_t * data,
   char * str;      /* copy of the current word put in lower case        */
   char * str_orig; /* oiginal version of the word                       */
 
-  char * first_mb;
+  char * first_glyph;
 
   char * sb_orig = data->buf; /* sb: search buffer                      */
   char * sb;
@@ -1072,7 +1072,7 @@ update_bitmaps(search_mode_t mode, search_data_t * data,
 
   if (mode == FUZZY || mode == SUBSTRING)
   {
-    first_mb = xmalloc(5);
+    first_glyph = xmalloc(5);
 
     if (mode == FUZZY)
     {
@@ -1196,7 +1196,8 @@ update_bitmaps(search_mode_t mode, search_data_t * data,
           long  i = 1;
           long  utf8_len;
 
-          first_mb = utf8_strprefix(first_mb, word_a[n].str, 1, &utf8_len);
+          first_glyph = utf8_strprefix(first_glyph, word_a[n].str, 1,
+                                       &utf8_len);
 
           if (!BIT_ISSET(word_a[n].bitmap, 0))
           {
@@ -1204,7 +1205,7 @@ update_bitmaps(search_mode_t mode, search_data_t * data,
             ptr1 = word_a[n].str;
             while ((ptr2 = utf8_next(ptr1)) != NULL)
             {
-              if (memcmp(ptr2, first_mb, utf8_len) == 0)
+              if (memcmp(ptr2, first_glyph, utf8_len) == 0)
               {
                 if (BIT_ISSET(word_a[n].bitmap, i))
                 {
@@ -1278,7 +1279,7 @@ update_bitmaps(search_mode_t mode, search_data_t * data,
     if (mode == FUZZY)
       free(sb);
 
-    free(first_mb);
+    free(first_glyph);
   }
   else if (mode == PREFIX)
   {
@@ -3962,7 +3963,7 @@ select_ending_matches(win_t * win, term_t * term, search_data_t * search_data,
     long   nb;
     long * tmp;
     char * ptr;
-    char * last_mb;
+    char * last_glyph;
     int    utf8_len;
 
     /* Creation of an alternate array which will      */
@@ -4004,12 +4005,12 @@ select_ending_matches(win_t * win, term_t * term, search_data_t * search_data,
         /* """""""""""""""""""""""""""""""""""""""""""""""""" */
         if (search_mode == FUZZY)
         {
-          utf8_len = mblen(ptr, 4);
-          last_mb  = search_data->buf + search_data->len - utf8_len;
+          utf8_len   = mblen(ptr, 4);
+          last_glyph = search_data->buf + search_data->len - utf8_len;
 
           /* in fuzzy search mode we only look the last glyph */
           /* """""""""""""""""""""""""""""""""""""""""""""""" */
-          if (memcmp(ptr, last_mb, utf8_len) == 0)
+          if (memcmp(ptr, last_glyph, utf8_len) == 0)
             alt_matching_words_a[j++] = index;
           else
             memset(word_a[index].bitmap, '\0',
@@ -4071,13 +4072,13 @@ select_starting_matches(win_t * win, term_t * term, search_data_t * search_data,
     long   index;
     long * tmp;
     long   pos;
-    char * first_mb;
+    char * first_glyph;
     int    utf8_len;
 
     alt_matching_words_a = xrealloc(alt_matching_words_a,
                                     matches_count * (sizeof(long)));
 
-    first_mb = xmalloc(5);
+    first_glyph = xmalloc(5);
 
     for (i = 0; i < matches_count; i++)
     {
@@ -4088,14 +4089,14 @@ select_starting_matches(win_t * win, term_t * term, search_data_t * search_data,
       {
         if (search_mode == FUZZY)
         {
-          first_mb = utf8_strprefix(first_mb,
-                                    word_a[index].str + daccess.flength, 1,
-                                    &pos);
-          utf8_len = pos;
+          first_glyph = utf8_strprefix(first_glyph,
+                                       word_a[index].str + daccess.flength, 1,
+                                       &pos);
+          utf8_len    = pos;
 
           /* in fuzzy search mode we only look the first glyph */
           /* """"""""""""""""""""""""""""""""""""""""""""""""" */
-          if (memcmp(search_data->buf, first_mb, utf8_len) == 0)
+          if (memcmp(search_data->buf, first_glyph, utf8_len) == 0)
             alt_matching_words_a[j++] = index;
           else
             memset(word_a[index].bitmap, '\0',
@@ -4115,7 +4116,7 @@ select_starting_matches(win_t * win, term_t * term, search_data_t * search_data,
       }
     }
 
-    free(first_mb);
+    free(first_glyph);
 
     matches_count         = j;
     matching_words_a_size = j;
diff --git a/utf8.c b/utf8.c
index 1507660..ddff417 100644
--- a/utf8.c
+++ b/utf8.c
@@ -1,3 +1,7 @@
+/* ************************************ */
+/* Various UTF-8 manipulation functions */
+/* ************************************ */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
diff --git a/utils.c b/utils.c
index c854821..1e8ee2a 100644
--- a/utils.c
+++ b/utils.c
@@ -1,3 +1,7 @@
+/* ******************************* */
+/* Various small utility functions */
+/* ******************************* */
+
 #include <stdlib.h>
 #include <limits.h>
 #include <string.h>
@@ -180,10 +184,6 @@ strprefix(char * str1, char * str2)
   return *str2 == '\0';
 }
 
-/* ***************************** */
-/* Strings and utility functions */
-/* ***************************** */
-
 /* ======================= */
 /* Trim leading characters */
 /* ======================= */
diff --git a/xmalloc.c b/xmalloc.c
index 3e9633e..b7ea8fc 100644
--- a/xmalloc.c
+++ b/xmalloc.c
@@ -1,5 +1,5 @@
 /* *************************** */
-/* Memory allocation functions */
+/* Memory management functions */
 /* *************************** */
 
 /* Created by Kevin Locke (from numerous canonical examples)         */