gcc/scan.c

   1 /* Utility functions for scan-decls and fix-header programs.
   2    Copyright (C) 1993, 1994 Free Software Foundation, Inc.
   3
   4 This program is free software; you can redistribute it and/or modify it
   5 under the terms of the GNU General Public License as published by the
   6 Free Software Foundation; either version 2, or (at your option) any
   7 later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  17
  18 #include "scan.h"
  19 #include "hconfig.h"
  20 #include <ctype.h>
  21
  22 int lineno = 1;
  23 int source_lineno = 1;
  24 sstring source_filename;
  25
  26 void
  27 make_sstring_space (str, count)
  28      sstring *str;
  29      int count;
  30 {
  31   int cur_pos = str->ptr - str->base;
  32   int cur_size = str->limit - str->base;
  33   int new_size = cur_pos + count + 100;
  34
  35   if (new_size <= cur_size)
  36     return;
  37
  38   if (str->base == NULL)
  39     str->base = xmalloc (new_size);
  40   else
  41     str->base = xrealloc (str->base, new_size);
  42   str->ptr = str->base + cur_size;
  43   str->limit = str->base + new_size;
  44 }
  45
  46 void
  47 sstring_append (dst, src)
  48      sstring *dst;
  49      sstring *src;
  50 {
  51   register char *d, *s;
  52   register count = SSTRING_LENGTH(src);
  53   MAKE_SSTRING_SPACE(dst, count + 1);
  54   d = dst->ptr;
  55   s = src->base;
  56   while (--count >= 0) *d++ = *s++;
  57   dst->ptr = d;
  58   *d = 0;
  59 }
  60
  61 memory_full ()
  62 {
  63   abort();
  64 }
  65
  66 char *
  67 xmalloc (size)
  68      unsigned size;
  69 {
  70   register char *ptr = (char *) malloc (size);
  71   if (ptr != 0) return (ptr);
  72   memory_full ();
  73   /*NOTREACHED*/
  74   return 0;
  75 }
  76
  77
  78 char *
  79 xrealloc (old, size)
  80      char *old;
  81      unsigned size;
  82 {
  83   register char *ptr = (char *) realloc (old, size);
  84   if (ptr != 0) return (ptr);
  85   memory_full ();
  86   /*NOTREACHED*/
  87   return 0;
  88 }
  89
  90 int
  91 scan_ident (fp, s, c)
  92      register FILE *fp;
  93      register sstring *s;
  94      int c;
  95 {
  96   s->ptr = s->base;
  97   if (isalpha(c) || c == '_')
  98     {
  99       for (;;)
 100         {
 101           SSTRING_PUT(s, c);
 102           c = getc (fp);
 103           if (c == EOF || !(isalnum(c) || c == '_'))
 104             break;
 105         }
 106     }
 107   MAKE_SSTRING_SPACE(s, 1);
 108   *s->ptr = 0;
 109   return c;
 110 }
 111
 112 int
 113 scan_string (fp, s, init)
 114      register FILE *fp;
 115      register sstring *s;
 116 {
 117   int c;
 118   for (;;)
 119     {
 120       c = getc (fp);
 121       if (c == EOF || c == '\n')
 122         break;
 123       if (c == init)
 124         {
 125           c = getc (fp);
 126           break;
 127         }
 128       if (c == '\\')
 129         {
 130           c = getc (fp);
 131           if (c == EOF)
 132             break;
 133           if (c == '\n')
 134             continue;
 135         }
 136       SSTRING_PUT(s, c);
 137     }
 138   MAKE_SSTRING_SPACE(s, 1);
 139   *s->ptr = 0;
 140   return c;
 141 }
 142
 143 /* Skip horizontal white spaces (spaces, tabs, and C-style comments). */
 144
 145 int
 146 skip_spaces (fp, c)
 147      register FILE *fp;
 148      int c;
 149 {
 150   for (;;)
 151     {
 152       if (c == ' ' || c == '\t')
 153         c = getc (fp);
 154       else if (c == '/')
 155         {
 156           c = getc (fp);
 157           if (c != '*')
 158             {
 159               ungetc (c, fp);
 160               return '/';
 161             }
 162           c = getc (fp);
 163           for (;;)
 164             {
 165               if (c == EOF)
 166                 return EOF;
 167               else if (c != '*')
 168                 {
 169                   if (c == '\n')
 170                     source_lineno++, lineno++;
 171                   c = getc (fp);
 172                 }
 173               else if ((c = getc (fp)) == '/')
 174                 return getc (fp);
 175             }
 176         }
 177       else
 178         break;
 179     }
 180   return c;
 181 }
 182
 183 int
 184 read_upto (fp, str, delim)
 185      FILE *fp;
 186      sstring *str;
 187      int delim;
 188 {
 189   int ch;
 190   for (;;)
 191     {
 192       ch = getc (fp);
 193       if (ch == EOF || ch == delim)
 194         break;
 195       SSTRING_PUT(str, ch);
 196     }
 197   MAKE_SSTRING_SPACE(str, 1);
 198   *str->ptr = 0;
 199   return ch;
 200 }
 201
 202 int
 203 get_token (fp, s)
 204      register FILE *fp;
 205      register sstring *s;
 206 {
 207   int c;
 208   s->ptr = s->base;
 209  retry:
 210   c = ' ';
 211   c = skip_spaces (fp, c);
 212   if (c == '\n')
 213     {
 214       source_lineno++;
 215       lineno++;
 216       goto retry;
 217     }
 218   if (c == '#')
 219     {
 220       c = get_token (fp, s);
 221       if (c == INT_TOKEN)
 222         {
 223           source_lineno = atoi (s->base) - 1; /* '\n' will add 1 */
 224           get_token (fp, &source_filename);
 225         }
 226       for (;;)
 227         {
 228           c = getc (fp);
 229           if (c == EOF)
 230             return EOF;
 231           if (c == '\n')
 232             {
 233             source_lineno++;
 234             lineno++;
 235             goto retry;
 236             }
 237         }
 238     }
 239   if (c == EOF)
 240     return EOF;
 241   if (isdigit (c))
 242     {
 243       do
 244         {
 245           SSTRING_PUT(s, c);
 246           c = getc (fp);
 247         } while (c != EOF && isdigit(c));
 248       ungetc (c, fp);
 249       c = INT_TOKEN;
 250       goto done;
 251     }
 252   if (isalpha (c) || c == '_')
 253     {
 254       c = scan_ident (fp, s, c);
 255       ungetc (c, fp);
 256       return IDENTIFIER_TOKEN;
 257     }
 258   if (c == '\'' || c == '"')
 259     {
 260       c = scan_string (fp, s, c);
 261       ungetc (c, fp);
 262       return c == '\'' ? CHAR_TOKEN : STRING_TOKEN;
 263     }
 264   SSTRING_PUT(s, c);
 265  done:
 266   MAKE_SSTRING_SPACE(s, 1);
 267   *s->ptr = 0;
 268   return c;
 269 }
 270
 271 unsigned long
 272 hash (str)
 273      char *str;
 274 {
 275   int h = 0;
 276   /* Replace this with something faster/better! FIXME! */
 277   while (*str) h = (h << 3) + *str++;
 278   return h & 0x7FFFFFFF;
 279 }