1: /* Copyright (C) 1996,1997,1998,1999,2000,2003,2004 Free Software Foundation, Inc.
    2:    This file is part of the GNU C Library.
    3:    Written by Ulrich Drepper, <drepper@cygnus.com>.
    4: 
    5:    The GNU C Library is free software; you can redistribute it and/or
    6:    modify it under the terms of the GNU Lesser General Public
    7:    License as published by the Free Software Foundation; either
    8:    version 2.1 of the 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:    Lesser General Public License for more details.
   14: 
   15:    You should have received a copy of the GNU Lesser General Public
   16:    License along with the GNU C Library; if not, write to the Free
   17:    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   18:    02111-1307 USA.  */
   19: 
   20: /* Find index of weight.  */
   21: auto inline int32_t
   22: __attribute ((always_inline))
   23: findidx (const unsigned char **cpp)
   24: {
   25:   int_fast32_t i = table[*(*cpp)++];
   26:   const unsigned char *cp;
   27:   const unsigned char *usrc;
   28: 
   29:   if (i >= 0)
   30:     /* This is an index into the weight table.  Cool.  */
   31:     return i;
   32: 
   33:   /* Oh well, more than one sequence starting with this byte.
   34:      Search for the correct one.  */
   35:   cp = &extra[-i];
   36:   usrc = *cpp;
   37:   while (1)
   38:     {
   39:       size_t nhere;
   40: 
   41:       /* The first thing is the index.  */
   42:       i = *((const int32_t *) cp);
   43:       cp += sizeof (int32_t);
   44: 
   45:       /* Next is the length of the byte sequence.  These are always
   46:          short byte sequences so there is no reason to call any
   47:          function (even if they are inlined).  */
   48:       nhere = *cp++;
   49: 
   50:       if (i >= 0)
   51:         {
   52:           /* It is a single character.  If it matches we found our
   53:              index.  Note that at the end of each list there is an
   54:              entry of length zero which represents the single byte
   55:              sequence.  The first (and here only) byte was tested
   56:              already.  */
   57:           size_t cnt;
   58: 
   59:           for (cnt = 0; cnt < nhere; ++cnt)
   60:             if (cp[cnt] != usrc[cnt])
   61:               break;
   62: 
   63:           if (cnt == nhere)
   64:             {
   65:               /* Found it.  */
   66:               *cpp += nhere;
   67:               return i;
   68:             }
   69: 
   70:           /* Up to the next entry.  */
   71:           cp += nhere;
   72:           if ((1 + nhere) % __alignof__ (int32_t) != 0)
   73:             cp += __alignof__ (int32_t) - (1 + nhere) % __alignof__ (int32_t);
   74:         }
   75:       else
   76:         {
   77:           /* This is a range of characters.  First decide whether the
   78:              current byte sequence lies in the range.  */
   79:           size_t cnt;
   80:           size_t offset = 0;
   81: 
   82:           for (cnt = 0; cnt < nhere; ++cnt)
   83:             if (cp[cnt] != usrc[cnt])
   84:               break;
   85: 
   86:           if (cnt != nhere)
   87:             {
   88:               if (cp[cnt] > usrc[cnt])
   89:                 {
   90:                   /* Cannot be in this range.  */
   91:                   cp += 2 * nhere;
   92:                   if ((1 + 2 * nhere) % __alignof__ (int32_t) != 0)
   93:                     cp += (__alignof__ (int32_t)
   94:                            - (1 + 2 * nhere) % __alignof__ (int32_t));
   95:                   continue;
   96:                 }
   97: 
   98:               /* Test against the end of the range.  */
   99:               for (cnt = 0; cnt < nhere; ++cnt)
  100:                 if (cp[nhere + cnt] != usrc[cnt])
  101:                   break;
  102: 
  103:               if (cnt != nhere && cp[nhere + cnt] < usrc[cnt])
  104:                 {
  105:                   /* Cannot be in this range.  */
  106:                   cp += 2 * nhere;
  107:                   if ((1 + 2 * nhere) % __alignof__ (int32_t) != 0)
  108:                     cp += (__alignof__ (int32_t)
  109:                            - (1 + 2 * nhere) % __alignof__ (int32_t));
  110:                   continue;
  111:                 }
  112: 
  113:               /* This range matches the next characters.  Now find
  114:                  the offset in the indirect table.  */
  115:               for (cnt = 0; cp[cnt] == usrc[cnt]; ++cnt);
  116: 
  117:               do
  118:                 {
  119:                   offset <<= 8;
  120:                   offset += usrc[cnt] - cp[cnt];
  121:                 }
  122:               while (++cnt < nhere);
  123:             }
  124: 
  125:           *cpp += nhere;
  126:           return indirect[-i + offset];
  127:         }
  128:     }
  129: 
  130:   /* NOTREACHED */
  131:   return 0x43219876;
  132: }