Use 'unsigned char' instead of 'char' in many places, to reduce casts.

1 files changed, 50 insertions, 39 deletions

diff --git a/src/keyword.cc b/src/keyword.cc
index ad65dd9..a7aae2c 100644
--- a/src/keyword.cc
+++ b/src/keyword.cc
@@ -29,31 +29,16 @@
 #include "options.h"
 
 
-/* Keyword class.  */
+/* --------------------------- KeywordExt class --------------------------- */
 
-/* Constructor.  */
-Keyword::Keyword (const char *s, int s_len, const char *r)
-  : _allchars (s), _allchars_length (s_len), _rest (r)
-{
-}
-
-
-/* KeywordExt class.  */
-
-/* Constructor.  */
-KeywordExt::KeywordExt (const char *s, int s_len, const char *r)
-  : Keyword (s, s_len, r), _duplicate_link (NULL), _final_index (0)
-{
-}
-
-/* Sort a small set of 'char', base[0..len-1], in place.  */
-static inline void sort_char_set (char *base, int len)
+/* Sort a small set of 'unsigned char', base[0..len-1], in place.  */
+static inline void sort_char_set (unsigned char *base, int len)
 {
   /* Bubble sort is sufficient here.  */
   for (int i = 1; i < len; i++)
     {
       int j;
-      char tmp;
+      unsigned char tmp;
 
       for (j = i, tmp = base[j]; j > 0 && tmp < base[j - 1]; j--)
         base[j] = base[j - 1];
@@ -62,42 +47,55 @@ static inline void sort_char_set (char *base, int len)
     }
 }
 
-/* Initialize selchars and selchars_length, and update occurrences.  */
+/* Initialize selchars and selchars_length, and update occurrences.
+   The hash function will be computed as
+   asso_values[allchars[key_pos[0]]] + asso_values[allchars[key_pos[1]]] + ...
+   We compute selchars as the multiset
+     { allchars[key_pos[0]], allchars[key_pos[1]], ... }
+   so that the hash function becomes
+     asso_values[selchars[0]] + asso_values[selchars[1]] + ...
+   Furthermore we sort the selchars array, to ease detection of duplicates
+   later.
+ */
 void KeywordExt::init_selchars (int *occurrences)
 {
   const char *k = _allchars;
-  char *key_set =
-    new char[(option[ALLCHARS] ? _allchars_length : option.get_max_keysig_size ())];
-  char *ptr = key_set;
+  unsigned char *key_set =
+    new unsigned char[(option[ALLCHARS] ? _allchars_length : option.get_max_keysig_size ())];
+  unsigned char *ptr = key_set;
 
   if (option[ALLCHARS])
-    /* Use all the character positions in the KEY. */
-    for (int i = _allchars_length; i > 0; k++, ptr++, i--)
-      occurrences[static_cast<unsigned char>(*ptr = *k)]++;
+    /* Use all the character positions in the KEY.  */
+    for (int i = _allchars_length; i > 0; k++, i--)
+      {
+        *ptr = static_cast<unsigned char>(*k);
+        occurrences[*ptr]++;
+        ptr++;
+      }
   else
-    /* Only use those character positions specified by the user. */
+    /* Only use those character positions specified by the user.  */
     {
       /* Iterate through the list of key_positions, initializing occurrences
-         table and selchars (via char * pointer ptr). */
+         table and selchars (via ptr).  */
       PositionIterator iter (option.get_key_positions ());
 
       for (int i; (i = iter.next ()) != PositionIterator::EOS; )
         {
           if (i == Positions::LASTCHAR)
-            /* Special notation for last KEY position, i.e. '$'. */
-            *ptr = _allchars[_allchars_length - 1];
+            /* Special notation for last KEY position, i.e. '$'.  */
+            *ptr = static_cast<unsigned char>(_allchars[_allchars_length - 1]);
           else if (i <= _allchars_length)
-            /* Within range of KEY length, so we'll keep it. */
-            *ptr = _allchars[i - 1];
+            /* Within range of KEY length, so we'll keep it.  */
+            *ptr = static_cast<unsigned char>(_allchars[i - 1]);
           else
-            /* Out of range of KEY length, so we'll just skip it. */
+            /* Out of range of KEY length, so we'll just skip it.  */
             continue;
-          occurrences[static_cast<unsigned char>(*ptr)]++;
+          occurrences[*ptr]++;
           ptr++;
         }
 
       /* Didn't get any hits and user doesn't want to consider the
-         keylength, so there are essentially no usable hash positions! */
+         keylength, so there are essentially no usable hash positions!  */
       if (ptr == key_set && option[NOLENGTH])
         {
           fprintf (stderr, "Can't hash keyword %.*s with chosen key positions.\n",
@@ -106,7 +104,7 @@ void KeywordExt::init_selchars (int *occurrences)
         }
     }
 
-  /* Sort the KEY_SET items alphabetically. */
+  /* Sort the KEY_SET items alphabetically.  */
   sort_char_set (key_set, ptr - key_set);
 
   _selchars = key_set;
@@ -114,8 +112,21 @@ void KeywordExt::init_selchars (int *occurrences)
 }
 
 
-/* Keyword_Factory class.  */
+/* ------------------------- Keyword_Factory class ------------------------- */
+
+Keyword_Factory::Keyword_Factory ()
+{
+}
+
+Keyword_Factory::~Keyword_Factory ()
+{
+}
+
+
+#ifndef __OPTIMIZE__
 
-Keyword_Factory::Keyword_Factory () {}
+#define INLINE /* not inline */
+#include "keyword.icc"
+#undef INLINE
 
-Keyword_Factory::~Keyword_Factory () {}
+#endif /* not defined __OPTIMIZE__ */