stdlib/grouping.h

   1 /* Internal header for proving correct grouping in strings of numbers.
   2 Copyright (C) 1995 Free Software Foundation, Inc.
   3 Contributed by Ulrich Drepper.
   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
  17 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  18 Cambridge, MA 02139, 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 char *
  32 correctly_grouped_prefix (const char *begin, const char *end,
  33                           wchar_t thousands, const char *grouping)
  34 {
  35   if (! grouping)
  36     return end;
  37
  38   while (end > begin)
  39     {
  40       const char *cp = end - 1;
  41       const char *gp = grouping;
  42
  43       /* Check first group.  */
  44       while (cp >= begin && (wchar_t) *cp != thousands)
  45         --cp;
  46
  47       if (end - cp == (int) *gp + 1)
  48         {
  49           /* This group matches the specification.  */
  50
  51           const char *new_end;
  52
  53           if (cp < begin)
  54             /* There is just one complete group.  We are done.  */
  55             return end;
  56
  57           /* CP points to a thousands separator character.  The preceding
  58              remainder of the string from BEGIN to NEW_END is the part we
  59              will consider if there is a grouping error in this trailing
  60              portion from CP to END.  */
  61           new_end = cp - 1;
  62
  63           /* Loop while the grouping is correct.  */
  64           while (1)
  65             {
  66               /* Get the next grouping rule.  */
  67               ++gp;
  68               if (*gp == 0)
  69                 /* If end is reached use last rule.  */
  70                 --gp;
  71
  72               /* Skip the thousands separator.  */
  73               --cp;
  74
  75               if (*gp == CHAR_MAX || *gp < 0)
  76                 {
  77                   /* No more thousands separators are allowed to follow.  */
  78                   while (cp >= begin && (wchar_t) *cp != thousands)
  79                     --cp;
  80
  81                   if (cp < begin)
  82                     /* OK, only digits followed.  */
  83                     return end;
  84                 }
  85               else
  86                 {
  87                   /* Check the next group.  */
  88                   const char *group_end = cp;
  89
  90                   while (cp >= begin && (wchar_t) *cp != thousands)
  91                     --cp;
  92
  93                   if (cp < begin && group_end - cp <= (int) *gp)
  94                     /* Final group is correct.  */
  95                     return end;
  96
  97                   if (cp < begin || group_end - cp != (int) *gp)
  98                     /* Incorrect group.  Punt.  */
  99                     break;
 100                 }
 101             }
 102
 103           /* The trailing portion of the string starting at NEW_END
 104              contains a grouping error.  So we will look for a correctly
 105              gouped number in the preceding portion instead.  */
 106           end = new_end;
 107         }
 108       else
 109         {
 110           /* Even the first group was wrong; determine maximum shift.  */
 111           if (end - cp > (int) *gp + 1)
 112             end = cp + (int) *gp + 1;
 113           else if (cp < begin)
 114             /* This number does not fill the first group, but is correct.  */
 115             return end;
 116           else
 117             /* CP points to a thousands seperator character.  */
 118             end = cp;
 119         }
 120     }
 121
 122   return MAX (begin, end);
 123 }