gcc/cpphash.h

   1 /* Part of CPP library.
   2    Copyright (C) 1997, 1998, 1999, 2000 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 /* This header defines all the internal data structures and functions
  19    that need to be visible across files.  It's called cpphash.h for
  20    historical reasons.  */
  21
  22 #ifndef __GCC_CPPHASH__
  23 #define __GCC_CPPHASH__
  24
  25 typedef unsigned char U_CHAR;
  26
  27 /* Structure allocated for every #define.  For a simple replacement
  28    such as
  29         #define foo bar ,
  30    nargs = -1, the `pattern' list is null, and the expansion is just
  31    the replacement text.  Nargs = 0 means a functionlike macro with no args,
  32    e.g.,
  33        #define getchar() getc (stdin) .
  34    When there are args, the expansion is the replacement text with the
  35    args squashed out, and the reflist is a list describing how to
  36    build the output from the input: e.g., "3 chars, then the 1st arg,
  37    then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
  38    The chars here come from the expansion.  Whatever is left of the
  39    expansion after the last arg-occurrence is copied after that arg.
  40    Note that the reflist can be arbitrarily long---
  41    its length depends on the number of times the arguments appear in
  42    the replacement text, not how many args there are.  Example:
  43    #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
  44    pattern list
  45      { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
  46    where (x, y) means (nchars, argno). */
  47
  48 struct reflist
  49 {
  50   struct reflist *next;
  51   char stringify;               /* nonzero if this arg was preceded by a
  52                                    # operator. */
  53   char raw_before;              /* Nonzero if a ## operator before arg. */
  54   char raw_after;               /* Nonzero if a ## operator after arg. */
  55   char rest_args;               /* Nonzero if this arg. absorbs the rest */
  56   int nchars;                   /* Number of literal chars to copy before
  57                                    this arg occurrence.  */
  58   int argno;                    /* Number of arg to substitute (origin-0) */
  59 };
  60
  61 typedef struct definition DEFINITION;
  62 struct definition
  63 {
  64   int nargs;
  65   int length;                   /* length of expansion string */
  66   U_CHAR *expansion;
  67   int line;                     /* Line number of definition */
  68   int col;
  69   const char *file;             /* File of definition */
  70   char rest_args;               /* Nonzero if last arg. absorbs the rest */
  71   struct reflist *pattern;
  72
  73   /* Names of macro args, concatenated in order with \0 between
  74      them.  The only use of this is that we warn on redefinition if
  75      this differs between the old and new definitions.  */
  76   U_CHAR *argnames;
  77 };
  78
  79 /* The structure of a node in the hash table.  The hash table
  80    has entries for all tokens defined by #define commands (type T_MACRO),
  81    plus some special tokens like __LINE__ (these each have their own
  82    type, and the appropriate code is run when that type of node is seen.
  83    It does not contain control words like "#define", which are recognized
  84    by a separate piece of code. */
  85
  86 /* different flavors of hash nodes */
  87 enum node_type
  88 {
  89   T_SPECLINE,      /* `__LINE__' */
  90   T_DATE,          /* `__DATE__' */
  91   T_FILE,          /* `__FILE__' */
  92   T_BASE_FILE,     /* `__BASE_FILE__' */
  93   T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
  94   T_TIME,          /* `__TIME__' */
  95   T_STDC,          /* `__STDC__' */
  96   T_CONST,         /* Constant string, used by `__SIZE_TYPE__' etc */
  97   T_MCONST,        /* Ditto, but the string is malloced memory */
  98   T_MACRO,         /* macro defined by `#define' */
  99   T_DISABLED,      /* macro temporarily turned off for rescan */
 100   T_POISON,        /* macro defined with `#pragma poison' */
 101   T_EMPTY          /* macro defined to nothing */
 102 };
 103
 104 /* different kinds of things that can appear in the value field
 105    of a hash node. */
 106 union hashval
 107 {
 108   const char *cpval;            /* some predefined macros */
 109   DEFINITION *defn;             /* #define */
 110   struct hashnode *aschain;     /* #assert */
 111 };
 112
 113 typedef struct hashnode HASHNODE;
 114 struct hashnode
 115 {
 116   const U_CHAR *name;           /* the actual name */
 117   size_t length;                /* length of token, for quick comparison */
 118   unsigned long hash;           /* cached hash value */
 119   union hashval value;          /* pointer to expansion, or whatever */
 120   enum node_type type;          /* type of special token */
 121 };
 122
 123 /* List of directories to look for include files in. */
 124 struct file_name_list
 125 {
 126   struct file_name_list *next;
 127   struct file_name_list *alloc; /* for the cache of
 128                                    current directory entries */
 129   char *name;
 130   unsigned int nlen;
 131   /* We use these to tell if the directory mentioned here is a duplicate
 132      of an earlier directory on the search path. */
 133   ino_t ino;
 134   dev_t dev;
 135   /* If the following is nonzero, it is a C-language system include
 136      directory.  */
 137   int sysp;
 138   /* Mapping of file names for this directory.
 139      Only used on MS-DOS and related platforms. */
 140   struct file_name_map *name_map;
 141 };
 142 #define ABSOLUTE_PATH ((struct file_name_list *)-1)
 143
 144 /* This structure is used for the table of all includes.  It is
 145    indexed by the `short name' (the name as it appeared in the
 146    #include statement) which is stored in *nshort.  */
 147 struct ihash
 148 {
 149   /* Next file with the same short name but a
 150      different (partial) pathname). */
 151   struct ihash *next_this_file;
 152
 153   /* Location of the file in the include search path.
 154      Used for include_next */
 155   struct file_name_list *foundhere;
 156
 157   unsigned long hash;           /* save hash value for future reference */
 158   const char *nshort;           /* name of file as referenced in #include;
 159                                    points into name[]  */
 160   const U_CHAR *control_macro;  /* macro, if any, preventing reinclusion -
 161                                    see redundant_include_p */
 162   const char name[1];           /* (partial) pathname of file */
 163 };
 164 typedef struct ihash IHASH;
 165
 166 /* Character classes.
 167    If the definition of `numchar' looks odd to you, please look up the
 168    definition of a pp-number in the C standard [section 6.4.8 of C99] */
 169 #define ISidnum         0x01    /* a-zA-Z0-9_ */
 170 #define ISidstart       0x02    /* _a-zA-Z */
 171 #define ISnumstart      0x04    /* 0-9 */
 172 #define IShspace        0x08    /* ' ' \t \f \v */
 173 #define ISspace         0x10    /* ' ' \t \f \v \n */
 174
 175 #define _dollar_ok(x)   ((x) == '$' && CPP_OPTION (pfile, dollars_in_ident))
 176
 177 #define is_idchar(x)    ((_cpp_IStable[x] & ISidnum) || _dollar_ok(x))
 178 #define is_idstart(x)   ((_cpp_IStable[x] & ISidstart) || _dollar_ok(x))
 179 #define is_numchar(x)   (_cpp_IStable[x] & ISidnum)
 180 #define is_numstart(x)  (_cpp_IStable[x] & ISnumstart)
 181 #define is_hspace(x)    (_cpp_IStable[x] & IShspace)
 182 #define is_space(x)     (_cpp_IStable[x] & ISspace)
 183
 184 /* This table is constant if it can be initialized at compile time,
 185    which is the case if cpp was compiled with GCC >=2.7, or another
 186    compiler that supports C99.  */
 187 #if (GCC_VERSION >= 2007) || (__STDC_VERSION__ >= 199901L)
 188 extern const unsigned char _cpp_IStable[256];
 189 #else
 190 extern unsigned char _cpp_IStable[256];
 191 #endif
 192
 193 /* Macros.  */
 194
 195 /* One character lookahead in the input buffer.  Note that if this
 196    returns EOF, it does *not* necessarily mean the file's end has been
 197    reached.  */
 198 #define CPP_BUF_PEEK(BUFFER) \
 199   ((BUFFER)->cur < (BUFFER)->rlimit ? *(BUFFER)->cur : EOF)
 200
 201 /* Make sure PFILE->token_buffer has space for at least N more characters. */
 202 #define CPP_RESERVE(PFILE, N) \
 203   (CPP_WRITTEN (PFILE) + (size_t)(N) > (PFILE)->token_buffer_size \
 204    && (_cpp_grow_token_buffer (PFILE, N), 0))
 205
 206 /* Append string STR (of length N) to PFILE's output buffer.
 207    Assume there is enough space. */
 208 #define CPP_PUTS_Q(PFILE, STR, N) \
 209   (memcpy ((PFILE)->limit, STR, (N)), (PFILE)->limit += (N))
 210 /* Append string STR (of length N) to PFILE's output buffer.  Make space. */
 211 #define CPP_PUTS(PFILE, STR, N) CPP_RESERVE(PFILE, N), CPP_PUTS_Q(PFILE, STR,N)
 212 /* Append character CH to PFILE's output buffer.  Assume sufficient space. */
 213 #define CPP_PUTC_Q(PFILE, CH) (*(PFILE)->limit++ = (CH))
 214 /* Append character CH to PFILE's output buffer.  Make space if need be. */
 215 #define CPP_PUTC(PFILE, CH) (CPP_RESERVE (PFILE, 1), CPP_PUTC_Q (PFILE, CH))
 216 /* Make sure PFILE->limit is followed by '\0'. */
 217 #define CPP_NUL_TERMINATE_Q(PFILE) (*(PFILE)->limit = 0)
 218 #define CPP_NUL_TERMINATE(PFILE) (CPP_RESERVE(PFILE, 1), *(PFILE)->limit = 0)
 219
 220 /* Advance the current line by one. */
 221 #define CPP_BUMP_BUFFER_LINE(PBUF) ((PBUF)->lineno++,\
 222                                     (PBUF)->line_base = (PBUF)->cur)
 223 #define CPP_BUMP_LINE(PFILE) CPP_BUMP_BUFFER_LINE(CPP_BUFFER(PFILE))
 224 #define CPP_BUMP_BUFFER_LINE_CUR(PBUF, CUR) ((PBUF)->lineno++,\
 225                                              (PBUF)->line_base = CUR)
 226 #define CPP_BUMP_LINE_CUR(PFILE, CUR) \
 227                             CPP_BUMP_BUFFER_LINE_CUR(CPP_BUFFER(PFILE), CUR)
 228 #define CPP_PREV_BUFFER(BUFFER) ((BUFFER)->prev)
 229
 230 /* Are we in column 1 right now?  Used mainly for -traditional handling
 231    of directives.  */
 232 #define CPP_IN_COLUMN_1(PFILE) \
 233 (CPP_BUFFER (PFILE)->cur - CPP_BUFFER (PFILE)->line_base == 1)
 234
 235 #define CPP_PRINT_DEPS(PFILE) CPP_OPTION (PFILE, print_deps)
 236 #define CPP_TRADITIONAL(PFILE) CPP_OPTION (PFILE, traditional)
 237 #define CPP_PEDANTIC(PFILE) \
 238   (CPP_OPTION (PFILE, pedantic) && !CPP_BUFFER (PFILE)->system_header_p)
 239 #define CPP_WTRADITIONAL(PF) \
 240   (CPP_OPTION (PF, warn_traditional) && !CPP_BUFFER (PF)->system_header_p)
 241
 242 /* CPP_IS_MACRO_BUFFER is true if the buffer contains macro expansion.
 243    (Note that it is false while we're expanding macro *arguments*.) */
 244 #define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->macro != NULL)
 245
 246 /* Remember the current position of PFILE so it may be returned to
 247    after looking ahead a bit.
 248
 249    Note that when you set a mark, you _must_ return to that mark.  You
 250    may not forget about it and continue parsing.  You may not pop a
 251    buffer with an active mark.  You may not call CPP_BUMP_LINE while a
 252    mark is active.  */
 253 #define CPP_SET_BUF_MARK(IP)   ((IP)->mark = (IP)->cur)
 254 #define CPP_GOTO_BUF_MARK(IP)  ((IP)->cur = (IP)->mark, (IP)->mark = 0)
 255 #define CPP_SET_MARK(PFILE)  CPP_SET_BUF_MARK(CPP_BUFFER(PFILE))
 256 #define CPP_GOTO_MARK(PFILE) CPP_GOTO_BUF_MARK(CPP_BUFFER(PFILE))
 257
 258 /* ACTIVE_MARK_P is true if there's a live mark in the buffer.  */
 259 #define ACTIVE_MARK_P(PFILE) (CPP_BUFFER (PFILE)->mark != 0)
 260
 261 /* Are mark and point adjacent characters?  Used mostly to deal with
 262    the somewhat annoying semantic of #define.  */
 263 #define ADJACENT_TO_MARK(PFILE) \
 264  (CPP_BUFFER(PFILE)->cur - CPP_BUFFER(PFILE)->mark == 1)
 265
 266 /* Last arg to output_line_command.  */
 267 enum file_change_code {same_file, rename_file, enter_file, leave_file};
 268
 269 /* In cpphash.c */
 270 extern HASHNODE *_cpp_make_hashnode     PARAMS ((const U_CHAR *, size_t,
 271                                                  enum node_type,
 272                                                  unsigned long));
 273 extern unsigned int _cpp_calc_hash      PARAMS ((const U_CHAR *, size_t));
 274 extern HASHNODE *_cpp_lookup            PARAMS ((cpp_reader *,
 275                                                  const U_CHAR *, int));
 276 extern HASHNODE **_cpp_lookup_slot      PARAMS ((cpp_reader *,
 277                                                  const U_CHAR *, int, int,
 278                                                  unsigned long *));
 279 extern void _cpp_free_definition        PARAMS ((DEFINITION *));
 280 extern DEFINITION *_cpp_create_definition PARAMS ((cpp_reader *, int));
 281 extern void _cpp_dump_definition        PARAMS ((cpp_reader *, const U_CHAR *,
 282                                                  long, DEFINITION *));
 283 extern int _cpp_compare_defs            PARAMS ((cpp_reader *, DEFINITION *,
 284                                                  DEFINITION *));
 285 extern void _cpp_quote_string           PARAMS ((cpp_reader *, const char *));
 286 extern void _cpp_macroexpand            PARAMS ((cpp_reader *, HASHNODE *));
 287 extern void _cpp_init_macro_hash        PARAMS ((cpp_reader *));
 288 extern void _cpp_dump_macro_hash        PARAMS ((cpp_reader *));
 289
 290 /* In cppfiles.c */
 291 extern void _cpp_simplify_pathname      PARAMS ((char *));
 292 extern void _cpp_execute_include        PARAMS ((cpp_reader *, char *,
 293                                                  unsigned int, int,
 294                                                  struct file_name_list *));
 295 extern void _cpp_init_include_hash      PARAMS ((cpp_reader *));
 296
 297 /* In cppexp.c */
 298 extern int _cpp_parse_expr              PARAMS ((cpp_reader *));
 299
 300 /* In cpplex.c */
 301 extern void _cpp_parse_name             PARAMS ((cpp_reader *, int));
 302 extern void _cpp_skip_rest_of_line      PARAMS ((cpp_reader *));
 303 extern void _cpp_skip_hspace            PARAMS ((cpp_reader *));
 304 extern int _cpp_parse_assertion         PARAMS ((cpp_reader *));
 305 extern enum cpp_ttype _cpp_lex_token    PARAMS ((cpp_reader *));
 306 extern long _cpp_read_and_prescan       PARAMS ((cpp_reader *, cpp_buffer *,
 307                                                  int, size_t));
 308 extern void _cpp_init_input_buffer      PARAMS ((cpp_reader *));
 309 extern void _cpp_grow_token_buffer      PARAMS ((cpp_reader *, long));
 310 extern enum cpp_ttype _cpp_get_directive_token
 311                                         PARAMS ((cpp_reader *));
 312 extern enum cpp_ttype _cpp_get_define_token
 313                                         PARAMS ((cpp_reader *));
 314
 315 /* In cpplib.c */
 316 extern int _cpp_handle_directive        PARAMS ((cpp_reader *));
 317 extern void _cpp_handle_eof             PARAMS ((cpp_reader *));
 318 extern void _cpp_output_line_command    PARAMS ((cpp_reader *,
 319                                                  enum file_change_code));
 320
 321
 322 #endif