stdlib/grouping.h

   1 /* Internal header for proving correct grouping in strings of numbers.
   2    Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
   3    Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, USA.  */
  19
  20 #include <limits.h>
  21
  22 #ifndef MAX
  23 #define MAX(a,b)        ({ typeof(a) _a = (a); typeof(b) _b = (b); \
  24                            _a > _b ? _a : _b; })
  25 #endif
  26
  27 /* Find the maximum prefix of the string between BEGIN and END which
  28    satisfies the grouping rules.  It is assumed that at least one digit
  29    follows BEGIN directly.  */
  30
  31 static inline const STRING_TYPE *
  32 correctly_grouped_prefix (const STRING_TYPE *begin, const STRING_TYPE *end,
  33                           wchar_t thousands, const char *grouping)
  34 {
  35   if (grouping == NULL)
  36     return end;
  37
  38   if (*grouping == '\0')
  39     {
  40       /* No grouping allowed.  Accept all characters up to the first
  41          thousands separator.  */
  42       while (begin < end && *begin != thousands)
  43         ++begin;
  44       return begin;
  45     }
  46
  47   while (end > begin)
  48     {
  49       const STRING_TYPE *cp = end - 1;
  50       const char *gp = grouping;
  51
  52       /* Check first group.  */
  53       while (cp >= begin && (wchar_t) *cp != thousands)
  54         --cp;
  55
  56       if (end - cp == (int) *gp + 1)
  57         {
  58           /* This group matches the specification.  */
  59
  60           const STRING_TYPE *new_end;
  61
  62           if (cp < begin)
  63             /* There is just one complete group.  We are done.  */
  64             return end;
  65
  66           /* CP points to a thousands separator character.  The preceding
  67              remainder of the string from BEGIN to NEW_END is the part we
  68              will consider if there is a grouping error in this trailing
  69              portion from CP to END.  */
  70           new_end = cp - 1;
  71
  72           /* Loop while the grouping is correct.  */
  73           while (1)
  74             {
  75               /* Get the next grouping rule.  */
  76               ++gp;
  77               if (*gp == 0)
  78                 /* If end is reached use last rule.  */
  79                 --gp;
  80
  81               /* Skip the thousands separator.  */
  82               --cp;
  83
  84               if (*gp == CHAR_MAX
  85 #if CHAR_MIN < 0
  86                   || *gp < 0
  87 #endif
  88                   )
  89                 {
  90                   /* No more thousands separators are allowed to follow.  */
  91                   while (cp >= begin && (wchar_t) *cp != thousands)
  92                     --cp;
  93
  94                   if (cp < begin)
  95                     /* OK, only digits followed.  */
  96                     return end;
  97                 }
  98               else
  99                 {
 100                   /* Check the next group.  */
 101                   const STRING_TYPE *group_end = cp;
 102
 103                   while (cp >= begin && (wchar_t) *cp != thousands)
 104                     --cp;
 105
 106                   if (cp < begin && group_end - cp <= (int) *gp)
 107                     /* Final group is correct.  */
 108                     return end;
 109
 110                   if (cp < begin || group_end - cp != (int) *gp)
 111                     /* Incorrect group.  Punt.  */
 112                     break;
 113                 }
 114             }
 115
 116           /* The trailing portion of the string starting at NEW_END
 117              contains a grouping error.  So we will look for a correctly
 118              grouped number in the preceding portion instead.  */
 119           end = new_end;
 120         }
 121       else
 122         {
 123           /* Even the first group was wrong; determine maximum shift.  */
 124           if (end - cp > (int) *gp + 1)
 125             end = cp + (int) *gp + 1;
 126           else if (cp < begin)
 127             /* This number does not fill the first group, but is correct.  */
 128             return end;
 129           else
 130             /* CP points to a thousands separator character.  */
 131             end = cp;
 132         }
 133     }
 134
 135   return MAX (begin, end);
 136 }