Create utils.[ch]

6 files changed, 345 insertions, 328 deletions

diff --git a/Makefile.am b/Makefile.am
index 3a1536a..2b90458 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,6 +1,7 @@
 bin_PROGRAMS = smenu
 smenu_SOURCES = smenu.c smenu.h ptrlist.c ptrlist.h xmalloc.c xmalloc.h \
-                index.c index.h utf8.c utf8.h fgetc.c fgetc.h
+                index.c index.h utf8.c utf8.h fgetc.c fgetc.h           \
+		utils.c utils.h
 dist_man_MANS = smenu.1
 EXTRA_DIST = smenu.spec.in smenu.spec ChangeLog build.sh version \
 	COPYRIGHT LICENSE.rst README.rst examples build-aux tests
diff --git a/Makefile.in b/Makefile.in
index a3bc94c..58c6eef 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -103,7 +103,7 @@ CONFIG_CLEAN_VPATH_FILES =
 am__installdirs = "$(DESTDIR)$(bindir)" "$(DESTDIR)$(man1dir)"
 PROGRAMS = $(bin_PROGRAMS)
 am_smenu_OBJECTS = smenu.$(OBJEXT) ptrlist.$(OBJEXT) xmalloc.$(OBJEXT) \
-	index.$(OBJEXT) utf8.$(OBJEXT) fgetc.$(OBJEXT)
+	index.$(OBJEXT) utf8.$(OBJEXT) fgetc.$(OBJEXT) utils.$(OBJEXT)
 smenu_OBJECTS = $(am_smenu_OBJECTS)
 smenu_LDADD = $(LDADD)
 AM_V_P = $(am__v_P_@AM_V@)
@@ -307,7 +307,8 @@ top_build_prefix = @top_build_prefix@
 top_builddir = @top_builddir@
 top_srcdir = @top_srcdir@
 smenu_SOURCES = smenu.c smenu.h ptrlist.c ptrlist.h xmalloc.c xmalloc.h \
-                index.c index.h utf8.c utf8.h fgetc.c fgetc.h
+                index.c index.h utf8.c utf8.h fgetc.c fgetc.h           \
+		utils.c utils.h
 
 dist_man_MANS = smenu.1
 EXTRA_DIST = smenu.spec.in smenu.spec ChangeLog build.sh version \
@@ -427,6 +428,7 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ptrlist.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/smenu.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/utf8.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/utils.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xmalloc.Po@am__quote@
 
 .c.o:
diff --git a/smenu.c b/smenu.c
index 526af2d..7220208 100644
--- a/smenu.c
+++ b/smenu.c
@@ -43,6 +43,7 @@
 #include "index.h"
 #include "utf8.h"
 #include "fgetc.h"
+#include "utils.h"
 #include "smenu.h"
 
 /* **************** */
@@ -73,6 +74,8 @@ int help_mode = 0; /* 1 if help is display else 0      */
 
 char * word_buffer;
 
+int (*my_isprint)(int);
+
 /* UTF-8 useful symbols */
 /* """""""""""""""""""" */
 char * left_arrow      = "\xe2\x86\x90";
@@ -938,62 +941,6 @@ make_ini_path(char * name, char * base)
   return path;
 }
 
-/* ****************** */
-/* Interval functions */
-/* ****************** */
-
-/* ===================== */
-/* Create a new interval */
-/* ===================== */
-interval_t *
-interval_new(void)
-{
-  interval_t * ret = xmalloc(sizeof(interval_t));
-
-  return ret;
-}
-
-/* ====================================== */
-/* Compare 2 intervals as integer couples */
-/* same return values as for strcmp       */
-/* ====================================== */
-int
-interval_comp(void * a, void * b)
-{
-  interval_t * ia = (interval_t *)a;
-  interval_t * ib = (interval_t *)b;
-
-  if (ia->low < ib->low)
-    return -1;
-  if (ia->low > ib->low)
-    return 1;
-  if (ia->high < ib->high)
-    return -1;
-  if (ia->high > ib->high)
-    return 1;
-
-  return 0;
-}
-
-/* ================================ */
-/* Swap the values of two intervals */
-/* ================================ */
-void
-interval_swap(void * a, void * b)
-{
-  interval_t * ia = (interval_t *)a;
-  interval_t * ib = (interval_t *)b;
-  long         tmp;
-
-  tmp     = ia->low;
-  ia->low = ib->low;
-  ib->low = tmp;
-
-  tmp      = ia->high;
-  ia->high = ib->high;
-  ib->high = tmp;
-}
-
 /* =========================================================== */
 /* Compare the pin order of two pinned word in the output list */
 /* =========================================================== */
@@ -1049,26 +996,6 @@ sub_tst_new(void)
   return elem;
 }
 
-/* =============================== */
-/* 7 bits aware version of isprint */
-/* =============================== */
-int
-isprint7(int i)
-{
-  return (i >= 0x20 && i <= 0x7e);
-}
-
-/* =============================== */
-/* 8 bits aware version of isprint */
-/* =============================== */
-int
-isprint8(int i)
-{
-  unsigned char c = i & (unsigned char)0xff;
-
-  return (c >= 0x20 && c < 0x7f) || (c >= (unsigned char)0xa0);
-}
-
 void
 beep(toggle_t * toggle)
 {
@@ -1624,38 +1551,6 @@ get_cursor_position(int * const r, int * const c)
   return 1;
 }
 
-/* ***************************** */
-/* Strings and utility functions */
-/* ***************************** */
-
-/* ======================= */
-/* Trim leading characters */
-/* ======================= */
-void
-ltrim(char * str, const char * trim_str)
-{
-  size_t len   = strlen(str);
-  size_t begin = strspn(str, trim_str);
-  size_t i;
-
-  if (begin > 0)
-    for (i = begin; i <= len; ++i)
-      str[i - begin] = str[i];
-}
-
-/* ================================================= */
-/* Trim trailing characters                          */
-/* The resulting string will have at least min bytes */
-/* even if trailing spaces remain.                   */
-/* ================================================= */
-void
-rtrim(char * str, const char * trim_str, size_t min)
-{
-  size_t len = strlen(str);
-  while (len > min && strchr(trim_str, str[len - 1]))
-    str[--len] = '\0';
-}
-
 /* ===================================================== */
 /* Returns 1 if a string is empty or only made of spaces */
 /* ===================================================== */
@@ -1671,48 +1566,6 @@ isempty(const char * s)
   return 1;
 }
 
-/* ========================================= */
-/* Case insensitive strcmp                   */
-/* from http://c.snippets.org/code/stricmp.c */
-/* ========================================= */
-int
-my_strcasecmp(const char * str1, const char * str2)
-{
-#ifdef HAVE_STRCASECMP
-  return strcasecmp(str1, str2);
-#else
-  int retval = 0;
-
-  while (1)
-  {
-    retval = tolower(*str1++) - tolower(*str2++);
-
-    if (retval)
-      break;
-
-    if (*str1 && *str2)
-      continue;
-    else
-      break;
-  }
-  return retval;
-#endif
-}
-
-/* =========================================== */
-/* memmove based strcpy (tolerates overlaping) */
-/* =========================================== */
-char *
-my_strcpy(char * str1, char * str2)
-{
-  if (str1 == NULL || str2 == NULL)
-    return NULL;
-
-  memmove(str1, str2, strlen(str2) + 1);
-
-  return str1;
-}
-
 /* ======================================================================== */
 /* Parse a regular expression based selector.                               */
 /* The string to parse is bounded by a delimiter so we must parse something */
@@ -1998,55 +1851,6 @@ parse_selectors(char * str, filters_t * filter, char * unparsed,
   *unparsed = '\0';
 }
 
-/* ===================================================================== */
-/* Merge the intervals from an interval list in order to get the minimum */
-/* number of intervals to consider.                                      */
-/* ===================================================================== */
-void
-merge_intervals(ll_t * list)
-{
-  ll_node_t * node1, *node2;
-  interval_t *data1, *data2;
-
-  if (!list || list->len < 2)
-    return;
-  else
-  {
-    /* Step 1: sort the intervals list */
-    /* """"""""""""""""""""""""""""""" */
-    ll_sort(list, interval_comp, interval_swap);
-
-    /* Step 2: merge the list by merging the consecutive intervals */
-    /* """"""""""""""""""""""""""""""""""""""""""""""""""""""""""" */
-    node1 = list->head;
-    node2 = node1->next;
-
-    while (node2)
-    {
-      data1 = (interval_t *)(node1->data);
-      data2 = (interval_t *)(node2->data);
-
-      if (data1->high >= data2->low - 1)
-      {
-        /* Interval 1 overlaps interval 2 */
-        /* '''''''''''''''''''''''''''''' */
-        if (data2->high >= data1->high)
-          data1->high = data2->high;
-        ll_delete(list, node2);
-        free(data2);
-        node2 = node1->next;
-      }
-      else
-      {
-        /* No overlap */
-        /* '''''''''' */
-        node1 = node2;
-        node2 = node2->next;
-      }
-    }
-  }
-}
-
 /* ======================================================== */
 /* Parse the sed like string passed as argument to -S/-I/-E */
 /* ======================================================== */
@@ -2153,8 +1957,7 @@ err:
 /* ===================================================================== */
 char *
 build_repl_string(char * to_match, char * repl, long match_start,
-                  long match_end, struct range_s * subs_a, long subs_nb,
-                  long match)
+                  long match_end, range_t * subs_a, long subs_nb, long match)
 {
   size_t rsize     = 0;
   size_t allocated = 16;
@@ -2282,10 +2085,8 @@ replace(char * to_match, sed_t * sed)
   if (*to_match == '\0')
     return 1;
 
-  struct range_s * matches_a = xmalloc(strlen(to_match)
-                                       * sizeof(struct range_s));
-
-  struct range_s * subs_a = xmalloc(10 * sizeof(struct range_s));
+  range_t * matches_a = xmalloc(strlen(to_match) * sizeof(range_t));
+  range_t * subs_a    = xmalloc(10 * sizeof(range_t));
 
   const char * p = to_match; /* points to the end of the previous match. */
   regmatch_t   m[10];        /* array containing the start/end offsets   *
@@ -2430,70 +2231,6 @@ strip_ansi_color(char * s, toggle_t * toggle)
   *p = '\0';
 }
 
-/* ========================================================================= */
-/* Allocate memory and safely concatenate strings. Stolen from a public      */
-/* domain implementation which can be found here:                            */
-/* http://openwall.info/wiki/people/solar/software/public-domain-source-code */
-/* ========================================================================= */
-char *
-concat(const char * s1, ...)
-{
-  va_list      args;
-  const char * s;
-  char *       p, *result;
-  size_t       l, m, n;
-
-  m = n = strlen(s1);
-  va_start(args, s1);
-  while ((s = va_arg(args, char *)))
-  {
-    l = strlen(s);
-    if ((m += l) < l)
-      break;
-  }
-  va_end(args);
-  if (s || m >= INT_MAX)
-    return NULL;
-
-  result = (char *)xmalloc(m + 1);
-
-  memcpy(p = result, s1, n);
-  p += n;
-  va_start(args, s1);
-  while ((s = va_arg(args, char *)))
-  {
-    l = strlen(s);
-    if ((n += l) < l || n > m)
-      break;
-    memcpy(p, s, l);
-    p += l;
-  }
-  va_end(args);
-  if (s || m != n || p != result + n)
-  {
-    free(result);
-    return NULL;
-  }
-
-  *p = 0;
-  return result;
-}
-
-/* =============================================== */
-/* Is the string str2 a prefix of the string str1? */
-/* =============================================== */
-int
-strprefix(char * str1, char * str2)
-{
-  while (*str1 != '\0' && *str1 == *str2)
-  {
-    str1++;
-    str2++;
-  }
-
-  return *str2 == '\0';
-}
-
 /* ================================================================ */
 /* Callback to add a word index in the sorted list of matched words */
 /* ================================================================ */
diff --git a/smenu.h b/smenu.h
index 72c742b..1af7074 100644
--- a/smenu.h
+++ b/smenu.h
@@ -40,7 +40,6 @@ typedef struct limits_s      limits_t;
 typedef struct timers_s      timers_t;
 typedef struct misc_s        misc_t;
 typedef struct sed_s         sed_t;
-typedef struct interval_s    interval_t;
 typedef struct timeout_s     timeout_t;
 typedef struct output_s      output_t;
 typedef struct daccess_s     daccess_t;
@@ -66,44 +65,14 @@ short_usage(void);
 void
 usage(void);
 
-char *
-concat(const char * s1, ...);
-
-interval_t *
-interval_new(void);
-
-int
-interval_comp(void * a, void * b);
-
-void
-interval_swap(void * a, void * b);
-
 int
 tag_comp(void * a, void * b);
 
 void
 tag_swap(void * a, void * b);
 
-void
-ltrim(char * str, const char * trim);
-
-void
-rtrim(char * str, const char * trim, size_t min_len);
-
-int
-isempty(const char * str);
-
-int
-my_strcasecmp(const char * str1, const char * str2);
-
-char *
-my_strcpy(char * dst, char * src);
-
-int
-isprint7(int i);
-
 int
-isprint8(int i);
+isempty(const char * s);
 
 void
 beep(toggle_t * toggle);
@@ -131,9 +100,6 @@ void
 strip_ansi_color(char * s, toggle_t * toggle);
 
 int
-strprefix(char * str1, char * str2);
-
-int
 tst_cb(void * elem);
 
 int
@@ -233,9 +199,6 @@ sig_handler(int s);
 void
 set_new_first_column(win_t * win, term_t * term);
 
-void
-merge_intervals(ll_t * list);
-
 int
 parse_sed_like_string(sed_t * sed);
 
@@ -257,8 +220,6 @@ parse_attr(char * str, attr_t * attr, short max_color);
 void
 apply_attr(term_t * term, attr_t attr);
 
-int (*my_isprint)(int);
-
 int
 delims_cmp(const void * a, const void * b);
 
@@ -534,22 +495,6 @@ struct sed_s
   regex_t re;
 };
 
-/* Interval structure for use in lists of columns and rows */
-/* """"""""""""""""""""""""""""""""""""""""""""""""""""""" */
-struct interval_s
-{
-  long low;
-  long high;
-};
-
-/* Structure used by the replace function to delimit matches */
-/* """"""""""""""""""""""""""""""""""""""""""""""""""""""""" */
-struct range_s
-{
-  size_t start;
-  size_t end;
-};
-
 /* Structure used to keep track of the different timeout values */
 /* """""""""""""""""""""""""""""""""""""""""""""""""""""""""""" */
 struct timeout_s
diff --git a/utils.c b/utils.c
new file mode 100644
index 0000000..e595593
--- /dev/null
+++ b/utils.c
@@ -0,0 +1,275 @@
+#include <stdlib.h>
+#include <limits.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdarg.h>
+#include "xmalloc.h"
+#include "ptrlist.h"
+#include "utils.h"
+
+/* ****************** */
+/* Interval functions */
+/* ****************** */
+
+/* ===================== */
+/* Create a new interval */
+/* ===================== */
+interval_t *
+interval_new(void)
+{
+  interval_t * ret = xmalloc(sizeof(interval_t));
+
+  return ret;
+}
+
+/* ====================================== */
+/* Compare 2 intervals as integer couples */
+/* same return values as for strcmp       */
+/* ====================================== */
+int
+interval_comp(void * a, void * b)
+{
+  interval_t * ia = (interval_t *)a;
+  interval_t * ib = (interval_t *)b;
+
+  if (ia->low < ib->low)
+    return -1;
+  if (ia->low > ib->low)
+    return 1;
+  if (ia->high < ib->high)
+    return -1;
+  if (ia->high > ib->high)
+    return 1;
+
+  return 0;
+}
+
+/* ================================ */
+/* Swap the values of two intervals */
+/* ================================ */
+void
+interval_swap(void * a, void * b)
+{
+  interval_t * ia = (interval_t *)a;
+  interval_t * ib = (interval_t *)b;
+  long         tmp;
+
+  tmp     = ia->low;
+  ia->low = ib->low;
+  ib->low = tmp;
+
+  tmp      = ia->high;
+  ia->high = ib->high;
+  ib->high = tmp;
+}
+
+/* ===================================================================== */
+/* Merge the intervals from an interval list in order to get the minimum */
+/* number of intervals to consider.                                      */
+/* ===================================================================== */
+void
+merge_intervals(ll_t * list)
+{
+  ll_node_t * node1, *node2;
+  interval_t *data1, *data2;
+
+  if (!list || list->len < 2)
+    return;
+  else
+  {
+    /* Step 1: sort the intervals list */
+    /* """"""""""""""""""""""""""""""" */
+    ll_sort(list, interval_comp, interval_swap);
+
+    /* Step 2: merge the list by merging the consecutive intervals */
+    /* """"""""""""""""""""""""""""""""""""""""""""""""""""""""""" */
+    node1 = list->head;
+    node2 = node1->next;
+
+    while (node2)
+    {
+      data1 = (interval_t *)(node1->data);
+      data2 = (interval_t *)(node2->data);
+
+      if (data1->high >= data2->low - 1)
+      {
+        /* Interval 1 overlaps interval 2 */
+        /* '''''''''''''''''''''''''''''' */
+        if (data2->high >= data1->high)
+          data1->high = data2->high;
+        ll_delete(list, node2);
+        free(data2);
+        node2 = node1->next;
+      }
+      else
+      {
+        /* No overlap */
+        /* '''''''''' */
+        node1 = node2;
+        node2 = node2->next;
+      }
+    }
+  }
+}
+
+/* ***************** */
+/* Strings functions */
+/* ***************** */
+
+/* ========================================================================= */
+/* Allocate memory and safely concatenate strings. Stolen from a public      */
+/* domain implementation which can be found here:                            */
+/* http://openwall.info/wiki/people/solar/software/public-domain-source-code */
+/* ========================================================================= */
+char *
+concat(const char * s1, ...)
+{
+  va_list      args;
+  const char * s;
+  char *       p, *result;
+  size_t       l, m, n;
+
+  m = n = strlen(s1);
+  va_start(args, s1);
+  while ((s = va_arg(args, char *)))
+  {
+    l = strlen(s);
+    if ((m += l) < l)
+      break;
+  }
+  va_end(args);
+  if (s || m >= INT_MAX)
+    return NULL;
+
+  result = (char *)xmalloc(m + 1);
+
+  memcpy(p = result, s1, n);
+  p += n;
+  va_start(args, s1);
+  while ((s = va_arg(args, char *)))
+  {
+    l = strlen(s);
+    if ((n += l) < l || n > m)
+      break;
+    memcpy(p, s, l);
+    p += l;
+  }
+  va_end(args);
+  if (s || m != n || p != result + n)
+  {
+    free(result);
+    return NULL;
+  }
+
+  *p = 0;
+  return result;
+}
+
+/* =============================================== */
+/* Is the string str2 a prefix of the string str1? */
+/* =============================================== */
+int
+strprefix(char * str1, char * str2)
+{
+  while (*str1 != '\0' && *str1 == *str2)
+  {
+    str1++;
+    str2++;
+  }
+
+  return *str2 == '\0';
+}
+
+/* ***************************** */
+/* Strings and utility functions */
+/* ***************************** */
+
+/* ======================= */
+/* Trim leading characters */
+/* ======================= */
+void
+ltrim(char * str, const char * trim_str)
+{
+  size_t len   = strlen(str);
+  size_t begin = strspn(str, trim_str);
+  size_t i;
+
+  if (begin > 0)
+    for (i = begin; i <= len; ++i)
+      str[i - begin] = str[i];
+}
+
+/* ================================================= */
+/* Trim trailing characters                          */
+/* The resulting string will have at least min bytes */
+/* even if trailing spaces remain.                   */
+/* ================================================= */
+void
+rtrim(char * str, const char * trim_str, size_t min)
+{
+  size_t len = strlen(str);
+  while (len > min && strchr(trim_str, str[len - 1]))
+    str[--len] = '\0';
+}
+
+/* ========================================= */
+/* Case insensitive strcmp                   */
+/* from http://c.snippets.org/code/stricmp.c */
+/* ========================================= */
+int
+my_strcasecmp(const char * str1, const char * str2)
+{
+#ifdef HAVE_STRCASECMP
+  return strcasecmp(str1, str2);
+#else
+  int retval = 0;
+
+  while (1)
+  {
+    retval = tolower(*str1++) - tolower(*str2++);
+
+    if (retval)
+      break;
+
+    if (*str1 && *str2)
+      continue;
+    else
+      break;
+  }
+  return retval;
+#endif
+}
+
+/* =========================================== */
+/* memmove based strcpy (tolerates overlaping) */
+/* =========================================== */
+char *
+my_strcpy(char * str1, char * str2)
+{
+  if (str1 == NULL || str2 == NULL)
+    return NULL;
+
+  memmove(str1, str2, strlen(str2) + 1);
+
+  return str1;
+}
+
+/* =============================== */
+/* 7 bits aware version of isprint */
+/* =============================== */
+int
+isprint7(int i)
+{
+  return (i >= 0x20 && i <= 0x7e);
+}
+
+/* =============================== */
+/* 8 bits aware version of isprint */
+/* =============================== */
+int
+isprint8(int i)
+{
+  unsigned char c = i & (unsigned char)0xff;
+
+  return (c >= 0x20 && c < 0x7f) || (c >= (unsigned char)0xa0);
+}
diff --git a/utils.h b/utils.h
new file mode 100644
index 0000000..93970d7
--- /dev/null
+++ b/utils.h
@@ -0,0 +1,57 @@
+#ifndef UTILS_H
+#define UTILS_H
+
+typedef struct interval_s interval_t;
+typedef struct range_s    range_t;
+
+struct interval_s
+{
+  long low;
+  long high;
+};
+
+/* Structure used by the replace function to delimit matches */
+/* """"""""""""""""""""""""""""""""""""""""""""""""""""""""" */
+struct range_s
+{
+  size_t start;
+  size_t end;
+};
+
+interval_t *
+interval_new(void);
+
+int
+interval_comp(void * a, void * b);
+
+void
+interval_swap(void * a, void * b);
+
+void
+merge_intervals(ll_t * list);
+
+char *
+concat(const char * str1, ...);
+
+int
+strprefix(char * str1, char * str2);
+
+void
+ltrim(char * str, const char * trim);
+
+void
+rtrim(char * str, const char * trim, size_t min_len);
+
+int
+my_strcasecmp(const char * str1, const char * str2);
+
+char *
+my_strcpy(char * dst, char * src);
+
+int
+isprint7(int i);
+
+int
+isprint8(int i);
+
+#endif