Work to get rid of GCC 4.0 warnings, part 2.

In many files, change `unsigned char' to `char'.  This often requires
adding casts to <ctype.h> functions.

diff --git a/src/ChangeLog b/src/ChangeLog
index 4df90e33707071f2402319d57a611a9e6995f3cc..1ba566d1a088bea31f011b06319c3622317928be 100644 (file)
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,17 @@
+Mon Oct 24 21:24:15 2005  Ben Pfaff  <blp@gnu.org>
+
+       Work to get rid of GCC 4.0 warnings, part 2.
+
+       In many files, change `unsigned char' to `char'.  This often
+       requires adding casts to <ctype.h> functions.
+
+       * data-in.c: (parse_A) Use buf_copy_rpad().
+
+       * str.c: (str_copy_buf_trunc) New function.
+
+       * value-labels.c: (value_to_string) Fix mistaken use of strncpy(),
+       by rewriting.
+
 Mon Oct 24 13:42:32 WST 2005 John Darrington <john@darrington.wattle.id.au>
 
        Moved some definitions to make it easier to abstract a dictionary 

diff --git a/src/algorithm.c b/src/algorithm.c
index 74f2be40045cc16171c86d8f5afa94c1281c25d1..47343e3717f88d2cab15590598e2dbc6cba23449 100644 (file)
--- a/src/algorithm.c
+++ b/src/algorithm.c
@@ -117,7 +117,7 @@ find (const void *array, size_t count, size_t size,
       const void *target,
       algo_compare_func *compare, void *aux) 
 {
-  const unsigned char *element = array;
+  const char *element = array;
 
   while (count-- > 0) 
     {
@@ -139,7 +139,7 @@ count_equal (const void *array, size_t count, size_t size,
              const void *element,
              algo_compare_func *compare, void *aux)
 {
-  const unsigned char *first = array;
+  const char *first = array;
   size_t equal_cnt = 0;
 
   while (count-- > 0) 
@@ -161,7 +161,7 @@ size_t
 count_if (const void *array, size_t count, size_t size,
           algo_predicate_func *predicate, void *aux) 
 {
-  const unsigned char *first = array;
+  const char *first = array;
   size_t nonzero_cnt = 0;
 
   while (count-- > 0) 
@@ -294,7 +294,7 @@ is_partitioned (const void *array, size_t count, size_t size,
                 size_t nonzero_cnt,
                 algo_predicate_func *predicate, void *aux) 
 {
-  const unsigned char *first = array;
+  const char *first = array;
   size_t idx;
 
   assert (nonzero_cnt <= count);
@@ -316,9 +316,9 @@ copy_if (const void *array, size_t count, size_t size,
          void *result,
          algo_predicate_func *predicate, void *aux) 
 {
-  const unsigned char *input = array;
-  const unsigned char *last = input + size * count;
-  unsigned char *output = result;
+  const char *input = array;
+  const char *last = input + size * count;
+  char *output = result;
   size_t nonzero_cnt = 0;
   
   while (input < last)
@@ -421,9 +421,9 @@ remove_equal (void *array, size_t count, size_t size,
               void *element,
               algo_compare_func *compare, void *aux) 
 {
-  unsigned char *first = array;
-  unsigned char *last = first + count * size;
-  unsigned char *result;
+  char *first = array;
+  char *last = first + count * size;
+  char *result;
 
   for (;;)
     {
@@ -489,14 +489,14 @@ binary_search (const void *array, size_t count, size_t size,
 
   if (count != 0) 
     {
-      const unsigned char *first = array;
+      const char *first = array;
       int low = 0;
       int high = count - 1;
 
       while (low <= high) 
         {
           int middle = (low + high) / 2;
-          const unsigned char *element = first + middle * size;
+          const char *element = first + middle * size;
           int cmp = compare (value, element, aux);
 
           if (cmp > 0) 
@@ -523,8 +523,8 @@ lexicographical_compare_3way (const void *array1, size_t count1,
                               size_t size,
                               algo_compare_func *compare, void *aux) 
 {
-  const unsigned char *first1 = array1;
-  const unsigned char *first2 = array2;
+  const char *first1 = array1;
+  const char *first2 = array2;
   size_t min_count = count1 < count2 ? count1 : count2;
 
   while (min_count > 0)
@@ -764,7 +764,7 @@ int
 is_sorted (const void *array, size_t count, size_t size,
            algo_compare_func *compare, void *aux) 
 {
-  const unsigned char *first = array;
+  const char *first = array;
   size_t idx;
       
   for (idx = 0; idx + 1 < count; idx++)
@@ -788,11 +788,11 @@ size_t set_difference (const void *array1, size_t count1,
                        void *result_,
                        algo_compare_func *compare, void *aux) 
 {
-  const unsigned char *first1 = array1;
-  const unsigned char *last1 = first1 + count1 * size;
-  const unsigned char *first2 = array2;
-  const unsigned char *last2 = first2 + count2 * size;
-  unsigned char *result = result_;
+  const char *first1 = array1;
+  const char *last1 = first1 + count1 * size;
+  const char *first2 = array2;
+  const char *last2 = first2 + count2 * size;
+  char *result = result_;
   size_t result_count = 0;
   
   while (first1 != last1 && first2 != last2) 
@@ -835,8 +835,8 @@ void *
 adjacent_find_equal (const void *array, size_t count, size_t size,
                      algo_compare_func *compare, void *aux) 
 {
-  const unsigned char *first = array;
-  const unsigned char *last = first + count * size;
+  const char *first = array;
+  const char *last = first + count * size;
 
   while (first < last && first + size < last) 
     {
@@ -858,15 +858,15 @@ void
 push_heap (void *array, size_t count, size_t size,
            algo_compare_func *compare, void *aux) 
 {
-  unsigned char *first = array;
+  char *first = array;
   size_t i;
   
   expensive_assert (count < 1 || is_heap (array, count - 1,
                                           size, compare, aux));
   for (i = count; i > 1; i /= 2) 
     {
-      unsigned char *parent = first + (i / 2 - 1) * size;
-      unsigned char *element = first + (i - 1) * size;
+      char *parent = first + (i / 2 - 1) * size;
+      char *element = first + (i - 1) * size;
       if (compare (parent, element, aux) < 0)
         SWAP (parent, element, size);
       else
@@ -885,7 +885,7 @@ heapify (void *array, size_t count, size_t size,
          size_t idx,
          algo_compare_func *compare, void *aux) 
 {
-  unsigned char *first = array;
+  char *first = array;
   
   for (;;) 
     {
@@ -921,7 +921,7 @@ void
 pop_heap (void *array, size_t count, size_t size,
           algo_compare_func *compare, void *aux) 
 {
-  unsigned char *first = array;
+  char *first = array;
 
   expensive_assert (is_heap (array, count, size, compare, aux));
   SWAP (first, first + (count - 1) * size, size);
@@ -952,7 +952,7 @@ void
 sort_heap (void *array, size_t count, size_t size,
            algo_compare_func *compare, void *aux) 
 {
-  unsigned char *first = array;
+  char *first = array;
   size_t idx;
 
   expensive_assert (is_heap (array, count, size, compare, aux));
@@ -972,7 +972,7 @@ int
 is_heap (const void *array, size_t count, size_t size,
          algo_compare_func *compare, void *aux) 
 {
-  const unsigned char *first = array;
+  const char *first = array;
   size_t child;
   
   for (child = 2; child <= count; child++)

diff --git a/src/ascii.c b/src/ascii.c
index 63aa4c1d82465fa96bc1a0c844c5664db755ea44..ae3c805b956a0b18981f56956aabc187ec49f107 100644 (file)
--- a/src/ascii.c
+++ b/src/ascii.c
@@ -202,7 +202,7 @@ ascii_open_global (struct outp_class *this UNUSED)
 }
 
 
-static unsigned char *s=0;
+static char *s;
 static int
 ascii_close_global (struct outp_class *this UNUSED)
 {
@@ -1158,8 +1158,8 @@ text_draw (struct outp_driver *this, struct outp_text *t)
 /* ascii_close_page () and support routines. */
 
 #define LINE_BUF_SIZE 1024
-static unsigned char *line_buf;
-static unsigned char *line_p;
+static char *line_buf;
+static char *line_p;
 
 static inline int
 commit_line_buf (struct outp_driver *this)
@@ -1312,7 +1312,7 @@ output_shorts (struct outp_driver *this,
 /* Writes CH into line_buf N times, or to THIS->output if line_buf
    overflows. */
 static inline void
-output_char (struct outp_driver *this, int n, int ch)
+output_char (struct outp_driver *this, int n, char ch)
 {
   if (LINE_BUF_SIZE - (line_p - line_buf) >= n)
     {
@@ -1474,7 +1474,7 @@ output_lines (struct outp_driver *this, int first, int count)
        }
       if (n_passes > 1)
        {
-         unsigned char ch;
+         char ch;
 
          return_carriage (this, n_chars);
          n_chars = 0;
@@ -1538,7 +1538,7 @@ ascii_close_page (struct outp_driver *this)
 
   struct ascii_driver_ext *x = this->ext;
   int nl_len, ff_len, total_len;
-  unsigned char *cp;
+  char *cp;
   int i;
 
   assert (this->driver_open && this->page_open);
@@ -1624,11 +1624,7 @@ ascii_close_page (struct outp_driver *this)
          output_string (this, s, &s[total_len]);
 
   if (line_p != line_buf && !commit_line_buf (this))
-    {
-    free(s);
-    s=0;
     return 0;
-    }
 
   this->page_open = 0;
   return 1;

diff --git a/src/case.h b/src/case.h
index 541a3e2ebdc9c2c677a67fdfcc301e2e4f9f61ce..cf99e0226e4bb1883050f7d3be2b7611763cd58b 100644 (file)
--- a/src/case.h
+++ b/src/case.h
@@ -73,7 +73,7 @@ CASE_INLINE void case_from_values (struct ccase *,
 
 CASE_INLINE const union value *case_data (const struct ccase *, size_t idx);
 CASE_INLINE double case_num (const struct ccase *, size_t idx);
-CASE_INLINE const unsigned char *case_str (const struct ccase *, size_t idx);
+CASE_INLINE const char *case_str (const struct ccase *, size_t idx);
 
 CASE_INLINE union value *case_data_rw (struct ccase *, size_t idx);
 
@@ -170,7 +170,7 @@ case_num (const struct ccase *c, size_t idx)
   return c->case_data->values[idx].f;
 }
 
-static inline const unsigned char *
+static inline const char *
 case_str (const struct ccase *c, size_t idx)
 {
   return c->case_data->values[idx].s;

diff --git a/src/data-in.c b/src/data-in.c
index 879ad10bd4fc3442a0be3935eb7ba5b0c70875a4..0c21a380ea2a0833641052ea5dba578441c66c55 100644 (file)
--- a/src/data-in.c
+++ b/src/data-in.c
@@ -91,10 +91,10 @@ dls_error (const struct data_in *i, const char *format, ...)
 static void
 trim_whitespace (struct data_in *i)
 {
-  while (i->s < i->e && isspace (i->s[0])) 
+  while (i->s < i->e && isspace ((unsigned char) i->s[0])) 
     i->s++;
 
-  while (i->s < i->e && isspace (i->e[-1]))
+  while (i->s < i->e && isspace ((unsigned char) i->e[-1]))
     i->e--;
 }
 
@@ -172,7 +172,7 @@ parse_numeric (struct data_in *i)
   exponent = 0;
   for (; have_char (i); i->s++)
     {
-      if (isdigit (*i->s))
+      if (isdigit ((unsigned char) *i->s))
        {
          digit_cnt++;
 
@@ -219,7 +219,7 @@ parse_numeric (struct data_in *i)
       /* Get the exponent specified after the `e' or `E'.  */
       long exp;
 
-      if (isalpha (*i->s))
+      if (isalpha ((unsigned char) *i->s))
        i->s++;
       if (!parse_int (i, &exp))
         {
@@ -291,18 +291,18 @@ hexit_value (int c)
 static inline bool
 parse_N (struct data_in *i)
 {
-  const unsigned char *cp;
+  const char *cp;
 
   i->v->f = 0;
   for (cp = i->s; cp < i->e; cp++)
     {
-      if (!isdigit (*cp))
+      if (!isdigit ((unsigned char) *cp))
        {
          dls_error (i, _("All characters in field must be digits."));
          return false;
        }
 
-      i->v->f = i->v->f * 10.0 + *cp - '0';
+      i->v->f = i->v->f * 10.0 + (*cp - '0');
     }
 
   apply_implied_decimals (i);
@@ -313,14 +313,14 @@ static inline bool
 parse_PIBHEX (struct data_in *i)
 {
   double n;
-  const unsigned char *cp;
+  const char *cp;
 
   trim_whitespace (i);
 
   n = 0.0;
   for (cp = i->s; cp < i->e; cp++)
     {
-      if (!isxdigit (*cp))
+      if (!isxdigit ((unsigned char) *cp))
        {
          dls_error (i, _("Unrecognized character in field."));
          return false;
@@ -345,10 +345,10 @@ parse_RBHEX (struct data_in *i)
     }
   
   {
-    const unsigned char *cp;
+    const char *cp;
     
     for (cp = i->s; cp < i->e; cp++)
-      if (!isxdigit (*cp))
+      if (!isxdigit ((unsigned char) *cp))
        {
          dls_error (i, _("Field must contain only hex digits."));
          return false;
@@ -416,7 +416,7 @@ parse_Z (struct data_in *i)
 
   /* Copy digits into buf[1 ... len - 1] and terminate string. */
   {
-    const unsigned char *sp;
+    const char *sp;
     char *dp;
 
     for (sp = i->s, dp = buf + 1; sp < i->e - 1; sp++, dp++)
@@ -440,8 +440,8 @@ parse_Z (struct data_in *i)
   {
     char *tail;
     
-    i->v->f = strtod ((char *) buf, (char **) &tail);
-    if ((unsigned char *) tail != i->e)
+    i->v->f = strtod (buf, &tail);
+    if (tail != i->e)
       {
        dls_error (i, _("Error in syntax of zoned decimal number."));
        return false;
@@ -460,18 +460,18 @@ parse_IB (struct data_in *i)
 #ifndef WORDS_BIGENDIAN
   char buf[64];
 #endif
-  const char *p;
+  const unsigned char *p;
 
   unsigned char xor;
 
   /* We want the data to be in big-endian format.  If this is a
      little-endian machine, reverse the byte order. */
 #ifdef WORDS_BIGENDIAN
-  p = i->s;
+  p = (const unsigned char *) i->s;
 #else
   memcpy (buf, i->s, i->e - i->s);
   buf_reverse (buf, i->e - i->s);
-  p = buf;
+  p = (const unsigned char *) buf;
 #endif
 
   /* If the value is negative, we need to logical-NOT each value
@@ -507,10 +507,10 @@ parse_PIB (struct data_in *i)
   i->v->f = 0.0;
 #if WORDS_BIGENDIAN
   for (j = 0; j < i->e - i->s; j++)
-    i->v->f = i->v->f * 256.0 + i->s[j];
+    i->v->f = i->v->f * 256.0 + (unsigned char) i->s[j];
 #else
   for (j = i->e - i->s - 1; j >= 0; j--)
-    i->v->f = i->v->f * 256.0 + i->s[j];
+    i->v->f = i->v->f * 256.0 + (unsigned char) i->s[j];
 #endif
 
   apply_implied_decimals (i);
@@ -521,15 +521,15 @@ parse_PIB (struct data_in *i)
 static inline bool
 parse_P (struct data_in *i)
 {
-  const unsigned char *cp;
+  const char *cp;
 
   i->v->f = 0.0;
   for (cp = i->s; cp < i->e - 1; cp++)
     {
-      i->v->f = i->v->f * 10 + (*cp >> 4);
+      i->v->f = i->v->f * 10 + ((*cp >> 4) & 15);
       i->v->f = i->v->f * 10 + (*cp & 15);
     }
-  i->v->f = i->v->f * 10 + (*cp >> 4);
+  i->v->f = i->v->f * 10 + ((*cp >> 4) & 15);
   if ((*cp ^ (*cp >> 1)) & 0x10)
       i->v->f = -i->v->f;
 
@@ -541,12 +541,12 @@ parse_P (struct data_in *i)
 static inline bool
 parse_PK (struct data_in *i)
 {
-  const unsigned char *cp;
+  const char *cp;
 
   i->v->f = 0.0;
   for (cp = i->s; cp < i->e; cp++)
     {
-      i->v->f = i->v->f * 10 + (*cp >> 4);
+      i->v->f = i->v->f * 10 + ((*cp >> 4) & 15);
       i->v->f = i->v->f * 10 + (*cp & 15);
     }
 
@@ -566,7 +566,7 @@ parse_RB (struct data_in *i)
   u;
 
   memset (u.c, 0, sizeof u.c);
-  memcpy (u.c, i->s, min ((int) sizeof (u.c), i->e - i->s));
+  memcpy (u.c, i->s, min (sizeof u.c, (size_t) (i->e - i->s)));
   i->v->f = u.d;
 
   return true;
@@ -575,16 +575,7 @@ parse_RB (struct data_in *i)
 static inline bool
 parse_A (struct data_in *i)
 {
-  ptrdiff_t len = i->e - i->s;
-  
-  if (len >= i->format.w)
-    memcpy (i->v->s, i->s, i->format.w);
-  else
-    {
-      memcpy (i->v->s, i->s, len);
-      memset (i->v->s + len, ' ', i->format.w - len);
-    }
-
+  buf_copy_rpad (i->v->s, i->format.w, i->s, i->e - i->s);
   return true;
 }
 
@@ -600,10 +591,10 @@ parse_AHEX (struct data_in *i)
     }
 
   {
-    const unsigned char *cp;
+    const char *cp;
     
     for (cp = i->s; cp < i->e; cp++)
-      if (!isxdigit (*cp))
+      if (!isxdigit ((unsigned char) *cp))
        {
          dls_error (i, _("Field must contain only hex digits."));
          return false;
@@ -669,7 +660,7 @@ parse_int (struct data_in *i, long *result)
       force_have_char (i);
     }
   
-  if (!isdigit (*i->s))
+  if (!isdigit ((unsigned char) *i->s))
     {
       dls_error (i, _("Digit expected in field."));
       return false;
@@ -678,8 +669,8 @@ parse_int (struct data_in *i, long *result)
   *result = 0;
   for (;;)
     {
-      *result = *result * 10 + *i->s++ - '0';
-      if (!have_char (i) || !isdigit (*i->s))
+      *result = *result * 10 + (*i->s++ - '0');
+      if (!have_char (i) || !isdigit ((unsigned char) *i->s))
        break;
     }
 
@@ -712,7 +703,7 @@ parse_date_delimiter (struct data_in *i)
   bool delim = false;
 
   while (have_char (i)
-        && (*i->s == '-' || *i->s == '/' || isspace (*i->s)
+        && (*i->s == '-' || *i->s == '/' || isspace ((unsigned char) *i->s)
             || *i->s == '.' || *i->s == ','))
     {
       delim = true;
@@ -747,7 +738,7 @@ parse_enum (struct data_in *i, const char *what,
   /* Consume alphabetic characters. */
   name = i->s;
   length = 0;
-  while (have_char (i) && isalpha (*i->s)) 
+  while (have_char (i) && isalpha ((unsigned char) *i->s)) 
     {
       length++;
       i->s++; 
@@ -811,7 +802,7 @@ parse_month (struct data_in *i, long *month)
   if (!force_have_char (i))
     return false;
   
-  if (isdigit (*i->s))
+  if (isdigit ((unsigned char) *i->s))
     {
       if (!parse_int (i, month))
        return false;
@@ -898,7 +889,7 @@ static bool
 parse_q_delimiter (struct data_in *i)
 {
   skip_whitespace (i);
-  if (!have_char (i) || tolower (*i->s) != 'q')
+  if (!have_char (i) || tolower ((unsigned char) *i->s) != 'q')
     {
       dls_error (i, _("`Q' expected between quarter and year."));
       return false;
@@ -925,7 +916,8 @@ parse_wk_delimiter (struct data_in *i)
 {
   skip_whitespace (i);
   if (i->s + 1 >= i->e
-      || tolower (i->s[0]) != 'w' || tolower (i->s[1]) != 'k')
+      || tolower ((unsigned char) i->s[0]) != 'w'
+      || tolower ((unsigned char) i->s[1]) != 'k')
     {
       dls_error (i, _("`WK' expected between week and year."));
       return false;
@@ -940,7 +932,8 @@ parse_time_delimiter (struct data_in *i)
 {
   bool delim = false;
 
-  while (have_char (i) && (*i->s == ':' || *i->s == '.' || isspace (*i->s)))
+  while (have_char (i) && (*i->s == ':' || *i->s == '.'
+                           || isspace ((unsigned char) *i->s)))
     {
       delim = true;
       i->s++;
@@ -986,24 +979,24 @@ parse_opt_second (struct data_in *i, double *second)
   char *cp;
 
   while (have_char (i)
-        && (*i->s == ':' || *i->s == '.' || isspace (*i->s)))
+        && (*i->s == ':' || *i->s == '.' || isspace ((unsigned char) *i->s)))
     {
       delim = true;
       i->s++;
     }
   
-  if (!delim || !isdigit (*i->s))
+  if (!delim || !isdigit ((unsigned char) *i->s))
     {
       *second = 0.0;
       return true;
     }
 
   cp = buf;
-  while (have_char (i) && isdigit (*i->s))
+  while (have_char (i) && isdigit ((unsigned char) *i->s))
     *cp++ = *i->s++;
   if (have_char (i) && *i->s == '.')
     *cp++ = *i->s++;
-  while (have_char (i) && isdigit (*i->s))
+  while (have_char (i) && isdigit ((unsigned char) *i->s))
     *cp++ = *i->s++;
   *cp = '\0';
   
@@ -1387,12 +1380,12 @@ data_in (struct data_in *i)
 
   if (fmt->cat & FCAT_BLANKS_SYSMIS)
     {
-      const unsigned char *cp;
+      const char *cp;
 
       cp = i->s;
       for (;;)
        {
-         if (!isspace (*cp))
+         if (!isspace ((unsigned char) *cp))
            break;
 
          if (++cp == i->e)

diff --git a/src/data-in.h b/src/data-in.h
index 9499f78cb0b669994dd0aba78744d9e57f60a33e..287b2fbeda7bf180543c895b483c7cfd2fb82886 100644 (file)
--- a/src/data-in.h
+++ b/src/data-in.h
@@ -34,8 +34,8 @@ enum
 /* Information about parsing one data field. */
 struct data_in
   {
-    const unsigned char *s;    /* Source start. */
-    const unsigned char *e;    /* Source end. */
+    const char *s;              /* Source start. */
+    const char *e;              /* Source end. */
 
     union value *v;            /* Destination. */
 

diff --git a/src/groff-font.c b/src/groff-font.c
index af86e784f2ad958849c41509f3bc56de8eae64a2..a46559cab104c3d0e148fa26e2c0342e45cab62f 100644 (file)
--- a/src/groff-font.c
+++ b/src/groff-font.c
@@ -406,7 +406,7 @@ font_msg (int class, const char *format,...)
 static void
 scan_badchars (char *line, int len)
 {
-  unsigned char *cp = line;
+  char *cp = line;
 
   /* Same bad characters as Groff. */
   static unsigned char badchars[32] =
@@ -417,12 +417,15 @@ scan_badchars (char *line, int len)
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   };
 
-  for (; len--; cp++)
-    if (badchars[*cp >> 3] & (1 << (*cp & 7)))
-      {
-       font_msg (SE, _("Bad character \\%3o."), *cp);
-       *cp = ' ';
-      }
+  for (; len--; cp++) 
+    {
+      int c = (unsigned char) *cp;
+      if (badchars[c >> 3] & (1 << (c & 7)))
+        {
+          font_msg (SE, _("Bad character \\%3o."), *cp);
+          *cp = ' ';
+        } 
+    }
 }
 \f
 /* Character name hashing. */

diff --git a/src/hash.c b/src/hash.c
index 019ddb1a4ae87e02aed24ed115f53fb5c48a4e3e..dd6bc3d24ee20b28fb0acc739dfa8a76db349104 100644 (file)
--- a/src/hash.c
+++ b/src/hash.c
@@ -77,7 +77,7 @@ next_power_of_2 (size_t x)
 unsigned
 hsh_hash_bytes (const void *buf_, size_t size)
 {
-  const unsigned char *buf = buf_;
+  const unsigned char *buf = (const unsigned char *) buf_;
   unsigned hash;
 
   assert (buf != NULL);
@@ -93,7 +93,7 @@ hsh_hash_bytes (const void *buf_, size_t size)
 unsigned
 hsh_hash_string (const char *s_) 
 {
-  const unsigned char *s = s_;
+  const unsigned char *s = (const unsigned char *) s_;
   unsigned hash;
 
   assert (s != NULL);
@@ -109,7 +109,7 @@ hsh_hash_string (const char *s_)
 unsigned
 hsh_hash_case_string (const char *s_) 
 {
-  const unsigned char *s = s_;
+  const unsigned char *s = (const unsigned char *) s_;
   unsigned hash;
 
   assert (s != NULL);

diff --git a/src/lexer.c b/src/lexer.c
index 77d40cfbb07179ba72cbad4b37753f8a4af32109..66324a2508701b65e63261c209e096285bf8b031 100644 (file)
--- a/src/lexer.c
+++ b/src/lexer.c
@@ -801,7 +801,7 @@ lex_preprocess_line (void)
       len--;
 
     /* Check for and remove terminal dot. */
-    if (len > 0 && s[len - 1] == get_endcmd() )
+    if (len > 0 && s[len - 1] == get_endcmd ())
       {
        dot = 1;
        len--;

diff --git a/src/missing-values.c b/src/missing-values.c
index 09192179f1f69da6e9008884659f5b4ac37a998d..bda35b20a19e3f7e432deb12d1d2c29836cae561 100644 (file)
--- a/src/missing-values.c
+++ b/src/missing-values.c
@@ -89,7 +89,7 @@ mv_add_value (struct missing_values *mv, const union value *v)
    missing values.  (Long string variables never accept missing
    values.) */
 bool
-mv_add_str (struct missing_values *mv, const unsigned char s[]) 
+mv_add_str (struct missing_values *mv, const char s[]) 
 {
   assert (mv->width > 0);
   return mv_add_value (mv, (union value *) s);
@@ -223,7 +223,7 @@ using_element (unsigned type, int idx)
    NEW_WIDTH (inclusive) and OLD_WIDTH (exclusive),
    false otherwise. */
 static bool
-can_resize_string (const unsigned char *s, int old_width, int new_width) 
+can_resize_string (const char *s, int old_width, int new_width) 
 {
   int i;
 
@@ -302,8 +302,7 @@ mv_is_num_missing (const struct missing_values *mv, double d)
    MV must be a set of string missing values. 
    S[] must contain exactly as many characters as MV's width. */
 bool
-mv_is_str_missing (const struct missing_values *mv,
-                   const unsigned char s[])
+mv_is_str_missing (const struct missing_values *mv, const char s[])
 {
   return mv_is_str_user_missing (mv, s);
 }
@@ -348,7 +347,7 @@ mv_is_num_user_missing (const struct missing_values *mv, double d)
    S[] must contain exactly as many characters as MV's width. */
 bool
 mv_is_str_user_missing (const struct missing_values *mv,
-                        const unsigned char s[])
+                        const char s[])
 {
   const union value *v = mv->values;
   assert (mv->width > 0);

diff --git a/src/missing-values.h b/src/missing-values.h
index 710fc05e1b2ae9b3e118be2d603ff08a106da152..6eff428556fd17026eff160b24c07c23b20a9bed 100644 (file)
--- a/src/missing-values.h
+++ b/src/missing-values.h
@@ -50,7 +50,7 @@ bool mv_is_empty (const struct missing_values *);
 int mv_get_width (const struct missing_values *);
 
 bool mv_add_value (struct missing_values *, const union value *);
-bool mv_add_str (struct missing_values *, const unsigned char[]);
+bool mv_add_str (struct missing_values *, const char[]);
 bool mv_add_num (struct missing_values *, double);
 bool mv_add_num_range (struct missing_values *, double low, double high);
 
@@ -68,17 +68,16 @@ typedef bool is_missing_func (const struct missing_values *,
 /* Is a value system or user missing? */
 bool mv_is_value_missing (const struct missing_values *, const union value *);
 bool mv_is_num_missing (const struct missing_values *, double);
-bool mv_is_str_missing (const struct missing_values *, const unsigned char[]);
+bool mv_is_str_missing (const struct missing_values *, const char[]);
 
 /* Is a value user missing? */
 bool mv_is_value_user_missing (const struct missing_values *,
                                const union value *);
 bool mv_is_num_user_missing (const struct missing_values *, double);
-bool mv_is_str_user_missing (const struct missing_values *,
-                             const unsigned char[]);
+bool mv_is_str_user_missing (const struct missing_values *, const char[]);
 
 /* Is a value system missing? */
 bool mv_is_value_system_missing (const struct missing_values *,
-                               const union value *);
+                                 const union value *);
 
 #endif /* missing-values.h */

diff --git a/src/pfm-read.c b/src/pfm-read.c
index 1999628c462ae7fdde3c15048d22995d37dcf464..24f9283379dd1b44d98b2e00f2e73e9488321b48 100644 (file)
--- a/src/pfm-read.c
+++ b/src/pfm-read.c
@@ -59,8 +59,7 @@ struct pfm_reader
     struct file_handle *fh;     /* File handle. */
     FILE *file;                        /* File stream. */
     char cc;                   /* Current character. */
-    unsigned char *trans;      /* 256-byte character set translation table. */
-
+    char *trans;                /* 256-byte character set translation table. */
     int var_cnt;                /* Number of variables. */
     int weight_index;          /* 0-based index of weight variable, or -1. */
     int *widths;                /* Variable widths, 0 for numeric. */
@@ -342,7 +341,7 @@ read_string (struct pfm_reader *r, char *buf)
 
 /* Reads a string and returns a copy of it allocated from R's
    pool. */
-static unsigned char *
+static char *
 read_pool_string (struct pfm_reader *r) 
 {
   char string[256];
@@ -356,7 +355,7 @@ read_header (struct pfm_reader *r)
 {
   /* portable_to_local[PORTABLE] translates the given portable
      character into the local character set. */
-  static const unsigned char portable_to_local[256] =
+  static const char portable_to_local[256] =
     {
       "                                                                "
       "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz ."
@@ -364,7 +363,7 @@ read_header (struct pfm_reader *r)
       "                                                                "
     };
 
-  unsigned char *trans;
+  char *trans;
   int i;
 
   /* Read and ignore vanity splash strings. */
@@ -411,6 +410,7 @@ read_header (struct pfm_reader *r)
 static void
 read_version_data (struct pfm_reader *r, struct pfm_read_info *info)
 {
+  static char empty_string[] = "";
   char *date, *time, *product, *author, *subproduct;
   int i;
 
@@ -419,10 +419,9 @@ read_version_data (struct pfm_reader *r, struct pfm_read_info *info)
     error (r, "Unrecognized version code `%c'.", r->cc);
   date = read_pool_string (r);
   time = read_pool_string (r);
-  product = match (r, '1') ? read_pool_string (r) : (unsigned char *) "";
-  author = match (r, '2') ? read_pool_string (r) : (unsigned char *) "";
-  subproduct
-    = match (r, '3') ? read_pool_string (r) : (unsigned char *) "";
+  product = match (r, '1') ? read_pool_string (r) : empty_string;
+  author = match (r, '2') ? read_pool_string (r) : empty_string;
+  subproduct = match (r, '3') ? read_pool_string (r) : empty_string;
 
   /* Validate file. */
   if (strlen (date) != 8)

diff --git a/src/pfm-write.c b/src/pfm-write.c
index cd088b7b85048be501fbd2ccbec3c45b316ddcee..be9812c5b365ca26724f16eb5910abd5138c4b2a 100644 (file)
--- a/src/pfm-write.c
+++ b/src/pfm-write.c
@@ -246,7 +246,7 @@ write_header (struct pfm_writer *w)
   {
     /* PORTME: Translation table from SPSS character code to this
        computer's native character code (which is probably ASCII). */
-    static const unsigned char spss2ascii[256] =
+    static const char spss2ascii[256] =
       {
        "0000000000000000000000000000000000000000000000000000000000000000"
        "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz ."

diff --git a/src/postscript.c b/src/postscript.c
index 11473f6488faaa94de282739ecd556232a3d5ec7..fd738ababba65e1e344a053d53466f1722eb0b6c 100644 (file)
--- a/src/postscript.c
+++ b/src/postscript.c
@@ -1488,7 +1488,7 @@ quote_ps_name (char *dest, const char *string)
   const char *sp;
 
   for (sp = string; *sp; sp++)
-    switch (*(unsigned char *) sp)
+    switch (*sp)
       {
       case 'a':
       case 'f':
@@ -1563,7 +1563,7 @@ quote_ps_name (char *dest, const char *string)
          *dp++ = '<';
          for (sp = string; *sp && dp < &dest[256]; sp++)
            {
-             sprintf (dp, "%02x", *(unsigned char *) sp);
+             sprintf (dp, "%02x", (unsigned char) *sp);
              dp += 2;
            }
          return stpcpy (dp, ">cvn");
@@ -1588,7 +1588,7 @@ quote_ps_string (char *dest, const char *string)
       dp = stpcpy (dp, "\\(");
     else if (*sp == ')')
       dp = stpcpy (dp, "\\)");
-    else if (*sp < 32 || *((unsigned char *) sp) > 127)
+    else if (*sp < 32 || (unsigned char) *sp > 127)
       dp = spprintf (dp, "\\%3o", *sp);
     else
       *dp++ = *sp;
@@ -2466,7 +2466,7 @@ write_text (struct outp_driver *this,
          if (TEST_BIT (literal_chars[ext->data], cp->ch))
            *lp++ = cp->ch;
          else
-           switch (cp->ch)
+           switch ((char) cp->ch)
              {
              case '(':
                lp = stpcpy (lp, "\\(");

diff --git a/src/recode.c b/src/recode.c
index a43498266653dcd236f045ec587b06d8afda5db2..b630d0294548c45221b1df0ea1d73304e7cfb0d7 100644 (file)
--- a/src/recode.c
+++ b/src/recode.c
@@ -237,7 +237,7 @@ cmd_recode (void)
              else
                {
                  for (i = mark; i < rcd->nmap; i++)
-                   rcd->map[i].t.c = (output.c?xstrdup (output.c):NULL);
+                   rcd->map[i].t.c = output.c ? xstrdup (output.c) : NULL;
                  free (output.c);
                }
            }

diff --git a/src/repeat.c b/src/repeat.c
index a5d2dfb8424d28b381d557755688713d34981b60..593263f8c4d490f5e27f91db2b946594aadaa693 100644 (file)
--- a/src/repeat.c
+++ b/src/repeat.c
@@ -579,7 +579,7 @@ perform_DO_REPEAT_substitutions (void)
       }
     }
   if (dot)
-    ds_putc (&output, get_endcmd() );
+    ds_putc (&output, get_endcmd ());
 
   ds_destroy (&getl_buf);
   getl_buf = output;

diff --git a/src/set.q b/src/set.q
index 300111c90b2de5462d95421056be18f2330e18a1..6bbfd5dc91340e61c2558a77d5afd9b9a91153de 100644 (file)
--- a/src/set.q
+++ b/src/set.q
@@ -1330,7 +1330,7 @@ get_include(void)
  return (cmd.inc != STC_OFF );
 }
 
-unsigned char
+char
 get_endcmd(void)
 {
   return cmd.s_endcmd[0];

diff --git a/src/settings.h b/src/settings.h
index 2c426f94fc6f6e68be32d576c5f190841a695789..8cff528ee70fa1494d816cb2ad5622194a3f0466 100644 (file)
--- a/src/settings.h
+++ b/src/settings.h
@@ -207,7 +207,7 @@ int get_mxloops(void);
 int get_nullline(void);
 
 /* The character used to terminate commands. */
-unsigned char get_endcmd(void);
+char get_endcmd(void);
 
 /* Approximate maximum amount of memory to use for cases, in
    bytes. */

diff --git a/src/sfm-read.c b/src/sfm-read.c
index bd8800bb9f9e09b698a5b756b93753a8e592753a..226c8b316f40ec86f54a12e1d5db4c758e58029b 100644 (file)
--- a/src/sfm-read.c
+++ b/src/sfm-read.c
@@ -89,9 +89,9 @@ struct sfm_var
 
 /* Swap bytes *A and *B. */
 static inline void
-bswap (unsigned char *a, unsigned char *b) 
+bswap (char *a, char *b) 
 {
-  unsigned char t = *a;
+  char t = *a;
   *a = *b;
   *b = t;
 }
@@ -100,7 +100,7 @@ bswap (unsigned char *a, unsigned char *b)
 static inline void
 bswap_int32 (int32 *x_)
 {
-  unsigned char *x = (unsigned char *) x_;
+  char *x = (char *) x_;
   bswap (x + 0, x + 3);
   bswap (x + 1, x + 2);
 }
@@ -109,7 +109,7 @@ bswap_int32 (int32 *x_)
 static inline void
 bswap_flt64 (flt64 *x_)
 {
-  unsigned char *x = (unsigned char *) x_;
+  char *x = (char *) x_;
   bswap (x + 0, x + 7);
   bswap (x + 1, x + 6);
   bswap (x + 2, x + 5);
@@ -945,7 +945,7 @@ read_variables (struct sfm_reader *r,
                 if (vv->type == NUMERIC)
                   mv_add_num (&vv->miss, mv[j]);
                 else
-                  mv_add_str (&vv->miss, (unsigned char *) &mv[j]);
+                  mv_add_str (&vv->miss, (char *) &mv[j]);
            }
          else
            {
@@ -1036,7 +1036,7 @@ read_value_labels (struct sfm_reader *r,
 {
   struct label 
     {
-      unsigned char raw_value[8]; /* Value as uninterpreted bytes. */
+      char raw_value[8];        /* Value as uninterpreted bytes. */
       union value value;        /* Value. */
       char *label;              /* Null-terminated label string. */
     };
@@ -1166,8 +1166,8 @@ read_value_labels (struct sfm_reader *r,
       
       if (var[0]->type == ALPHA)
         {
-          const int copy_len = min (sizeof (label->raw_value),
-                                    sizeof (label->label));
+          const int copy_len = min (sizeof label->raw_value,
+                                    sizeof label->label);
           memcpy (label->value.s, label->raw_value, copy_len);
         } else {
           flt64 f;

diff --git a/src/sfm-write.c b/src/sfm-write.c
index 4f0f9ec18a763abcfb1ca4b7cf8c548c637028b2..bdde3cf642ee8982da2fb3b98273d51e09a261da 100644 (file)
--- a/src/sfm-write.c
+++ b/src/sfm-write.c
@@ -527,8 +527,8 @@ write_value_labels (struct sfm_writer *w, struct variable *v, int idx)
 
       *loc++ = vl->value.f;
       *(unsigned char *) loc = len;
-      memcpy (&((unsigned char *) loc)[1], vl->label, len);
-      memset (&((unsigned char *) loc)[1 + len], ' ',
+      memcpy (&((char *) loc)[1], vl->label, len);
+      memset (&((char *) loc)[1 + len], ' ',
              REM_RND_UP (len + 1, sizeof (flt64)));
       loc += DIV_RND_UP (len + 1, sizeof (flt64));
     }

diff --git a/src/str.c b/src/str.c
index fe9ad814680590df36575e9e18fc482c48631cf3..b70ce97c501f7ee29152be1c9088b408a938d507 100644 (file)
--- a/src/str.c
+++ b/src/str.c
@@ -79,8 +79,8 @@ nvsprintf (char *buf, const char *format, va_list args)
 void
 buf_reverse (char *p, size_t nbytes)
 {
-  unsigned char *h = p, *t = &h[nbytes - 1];
-  unsigned char temp;
+  char *h = p, *t = &h[nbytes - 1];
+  char temp;
 
   nbytes /= 2;
   while (nbytes--)
@@ -249,6 +249,21 @@ str_copy_trunc (char *dst, size_t dst_size, const char *src)
     }
 }
 
+/* Copies buffer SRC, of SRC_LEN bytes,
+   to DST, which is in a buffer DST_SIZE bytes long.
+   Truncates DST to DST_SIZE - 1 characters, if necessary. */
+void
+str_copy_buf_trunc (char *dst, size_t dst_size,
+                    const char *src, size_t src_size) 
+{
+  size_t dst_len;
+  assert (dst_size > 0);
+
+  dst_len = src_size < dst_size ? src_size : dst_size - 1;
+  memcpy (dst, src, dst_len);
+  dst[dst_len] = '\0';
+}
+
 /* Converts each character in S to uppercase. */
 void
 str_uppercase (char *s) 

diff --git a/src/str.h b/src/str.h
index 8c9ebc1800b5635dcffccf94bd66591109be7f11..db961959c45205b3a63da19ca773e01c544b121f 100644 (file)
--- a/src/str.h
+++ b/src/str.h
@@ -106,6 +106,7 @@ void buf_copy_str_rpad (char *, size_t, const char *);
 int str_compare_rpad (const char *, const char *);
 void str_copy_rpad (char *, size_t, const char *);
 void str_copy_trunc (char *, size_t, const char *);
+void str_copy_buf_trunc (char *, size_t, const char *, size_t);
 void str_uppercase (char *);
 \f
 /* Fixed-length strings. */

diff --git a/src/val.h b/src/val.h
index 57aaa2af746c02095557a2b4ddc2ffb6a18c9ed5..07b4d7944afce02f210ab47430dacb52358bbea5 100644 (file)
--- a/src/val.h
+++ b/src/val.h
@@ -53,7 +53,7 @@ union value
     double f;
 
     /* A short-string value. */
-    unsigned char s[MAX_SHORT_STRING];
+    char s[MAX_SHORT_STRING];
 
     /* Used by evaluate_expression() to return a string result.
        As currently implemented, it's a pointer to a dynamic
@@ -61,7 +61,7 @@ union value
 
        Also used by the AGGREGATE procedure in handling string
        values. */
-    unsigned char *c;
+    char *c;
   };
 
 /* Maximum number of `union value's in a single number or string

diff --git a/src/value-labels.c b/src/value-labels.c
index 7cd8ff0daa3cd76c5d3aa902dbd13da8052453d9..8dfbb10ead2a662e37eddd00c58a7bb9869369aa 100644 (file)
--- a/src/value-labels.c
+++ b/src/value-labels.c
@@ -496,29 +496,23 @@ free_atom (void *atom_, void *aux UNUSED)
    else format it and return the formatted string
 */
 const char *
-value_to_string(const union value *val, const struct variable *var)
+value_to_string (const union value *val, const struct variable *var)
 {
-  static char buf[100];
   char *s;
-  const struct val_labs *val_labs ;
   
-  if ( !val || ! var ) 
-    return 0;
-
-  val_labs = var->val_labs;
-
-  
-  s = val_labs_find (val_labs, *val);
+  assert (val != NULL);
+  assert (var != NULL);
 
-  if ( s ) 
-    return s;
-
-  if ( 0 == var->width ) 
-    snprintf(buf,100,"%g",val->f);
-  else
+  s = val_labs_find (var->val_labs, *val);
+  if (s == NULL) 
     {
-      strncpy(buf,val->s,MAX_SHORT_STRING);
-      strcat(buf,"\0");
+      static char buf[256];
+      if (var->width != 0) 
+        str_copy_buf_trunc (buf, sizeof buf, val->s, var->width);
+      else
+        snprintf(buf, 100, "%g", val->f);
+      s = buf;
     }
-  return buf;
+  
+  return s;
 }