src/Headers/cpplib.h

   1 /* Definitions for CPP library.
   2    Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
   3    Written by Per Bothner, 1994-95.
   4
   5 This program is free software; you can redistribute it and/or modify it
   6 under the terms of the GNU General Public License as published by the
   7 Free Software Foundation; either version 2, or (at your option) any
   8 later version.
   9
  10 This program 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
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19  In other words, you are welcome to use, share and improve this program.
  20  You are forbidden to forbid anyone else to use, share and improve
  21  what you give them.   Help stamp out software-hoarding!  */
  22
  23 #include <sys/types.h>
  24 #include <sys/stat.h>
  25
  26 #ifdef __cplusplus
  27 extern "C" {
  28 #endif
  29
  30 typedef enum cpp_token (*parseUnderflow) (cppReader *);
  31 typedef void (*parseCleanup) (cppBuffer *, cppReader *);
  32
  33 /* Structure returned by create_definition */
  34 typedef struct s_macrodef macroDef;
  35
  36 /* A parse_marker indicates a previous position,
  37    which we can backtrack to. */
  38
  39 struct parse_marker {
  40   /*@dependent@*/ cppBuffer *buf;
  41   /*@dependent@*/ /*@null@*/ struct parse_marker *next;
  42   int position;
  43 };
  44
  45 /* The arglist structure is built by do_define to tell
  46    collect_definition where the argument names begin.  That
  47    is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
  48    would contain pointers to the strings x, y, and z.
  49    Collect_definition would then build a DEFINITION node,
  50    with reflist nodes pointing to the places x, y, and z had
  51    appeared.  So the arglist is just convenience data passed
  52    between these two routines.  It is not kept around after
  53    the current #define has been processed and entered into the
  54    hash table.  */
  55
  56 struct arglist {
  57   /*@null@*/ struct arglist *next;
  58   /*@dependent@*/ char *name;
  59   int length;
  60   int argno;
  61   int rest_args;
  62 };
  63
  64 extern enum cpp_token cpplib_getToken (cppReader *);
  65 extern enum cpp_token cpplib_getTokenForceExpand (cppReader *);
  66 extern enum cpp_token cpplib_getTokenAux (cppReader *, bool p_forceExpand);
  67 extern int /*@alt void@*/ cppSkipHspace (cppReader *);
  68
  69 /* This frees resources used by PFILE. */
  70 extern /*@unused@*/ void cppCleanup (cppReader *p_pfile);
  71
  72 struct cppBuffer {
  73   /*@null@*/ /*@only@*/ char *buf;
  74   /*@null@*/ /*@exposed@*/ char *cur;
  75   /*@null@*/ /*@exposed@*/ char *rlimit; /* end of valid data */
  76   /*@null@*/ /*@exposed@*/ char *alimit; /* end of allocated buffer */
  77   /*@null@*/ /*@exposed@*/ char *prev;
  78
  79   /*@dependent@*/ cstring fname;
  80
  81   /* Filename specified with #line command.  */
  82   /*@exposed@*/ cstring nominal_fname;
  83
  84   /* Record where in the search path this file was found.
  85      For #include_next.  */
  86
  87   /*@dependent@*/ /*@null@*/ struct file_name_list *dir;
  88
  89   long line_base;
  90   int lineno; /* Line number at CPP_LINE_BASE. */
  91   int colno; /* Column number at CPP_LINE_BASE. */
  92   parseUnderflow underflow;
  93   parseCleanup cleanup;
  94
  95   /*@dependent@*/ hashNode hnode;
  96   /*@dependent@*/ /*@null@*/ struct parse_marker *marks;
  97   /* Value of if_stack at start of this file.
  98      Used to prohibit unmatched #endif (etc) in an include file.  */
  99   /*@null@*/ /*@exposed@*/ struct if_stack *if_stack;
 100
 101   /* True if this is a header file included using <FILENAME>.  */
 102   char system_header_p;
 103   char seen_eof;
 104
 105   /* True if buffer contains escape sequences.
 106      Currently there are three kinds:
 107      "@-" means following identifier should not be macro-expanded.
 108      "@ " means a token-separator.  This turns into " " in final output
 109           if not stringizing and needed to separate tokens; otherwise nothing.
 110      "@@" means a normal '@'.
 111      (An '@' inside a string stands for itself and is never an escape.) */
 112   bool has_escapes;
 113 };
 114
 115 struct cpp_pending;  /* Forward declaration - for C++. */
 116 struct file_name_map_list;
 117
 118 /* Maximum nesting of cppBuffers.  We use a static limit, partly for
 119    efficiency, and partly to limit runaway recursion.  */
 120
 121 /*@constant int CPP_STACK_MAX; @*/
 122 # define CPP_STACK_MAX 200
 123
 124 /* A cppReader encapsulates the "state" of a pre-processor run.
 125    Applying cppGetToken repeatedly yields a stream of pre-processor
 126    tokens.  Usually, there is only one cppReader object active. */
 127
 128 struct cppReader {
 129   parseUnderflow get_token;
 130   /*@dependent@*/ /*@null@*/ cppBuffer *buffer;
 131   cppBuffer buffer_stack[CPP_STACK_MAX];
 132
 133   int errors;                   /* Error counter for exit code */
 134   cppOptions *opts;
 135   /* void *data;  */
 136
 137   /* A buffer used for both for cppGetToken's output, and also internally. */
 138   /*@relnull@*/ char *token_buffer;
 139
 140   /* Alocated size of token_buffer.  cppReader_reserve allocates space.  */
 141   size_t token_buffer_size;
 142   /* End of the written part of token_buffer. */
 143   /*@exposed@*/ char *limit;
 144
 145   /* Line where a newline was first seen in a string constant.  */
 146   int multiline_string_line;
 147
 148   /* Current depth in #include directives that use <...>.  */
 149   int system_include_depth;
 150
 151   /* List of other included files.
 152      If ->control_macro if nonzero, the file had a #ifndef
 153      around the entire contents, and ->control_macro gives the macro name.  */
 154   /*@owned@*/ /*@null@*/ struct file_name_list *all_include_files;
 155
 156   /* Current maximum length of directory names in the search path
 157      for include files.  (Altered as we get more of them.)  */
 158   int max_include_len;
 159
 160   /*@null@*/ struct if_stack *if_stack;
 161
 162   /* Nonzero means we are inside an IF during a -pcp run.  In this mode
 163      macro expansion is done, and preconditions are output for all macro
 164      uses requiring them. */
 165   char pcp_inside_if;
 166
 167   /* Nonzero means we have printed (while error reporting) a list of
 168      containing files that matches the current status. */
 169   char input_stack_listing_current;
 170
 171   /* If non-zero, macros are not expanded. */
 172   bool no_macro_expand;
 173
 174   /* Print column number in error messages. */
 175   bool show_column;
 176
 177   /* If true, character between '<' and '>' are a single (string) token. */
 178   char parsing_include_directive;
 179
 180   /* True if escape sequences (as described for has_escapes in
 181      parse_buffer) should be emitted. */
 182   char output_escapes;
 183
 184   /* 0: Have seen non-white-space on this line.
 185      1: Only seen white space so far on this line.
 186      2: Only seen white space so far in this file. */
 187   char only_seen_white;
 188
 189   int lineno;
 190
 191   /*@null@*/ /*@observer@*/ struct tm *timebuf;
 192
 193 #ifdef __cplusplus
 194   ~cppReader () { cppCleanup (this); }
 195 #endif
 196 };
 197
 198 /*@constant int cppReader_fatalErrorLimit; @*/
 199 #define cppReader_fatalErrorLimit 1000
 200
 201 /* True if we have seen a "fatal" error. */
 202 extern bool cpplib_fatalErrors (cppReader *) /*@*/ ;
 203 #define cpplib_fatalErrors(READER) ((READER)->errors >= cppReader_fatalErrorLimit)
 204
 205 extern int cpplib_bufPeek (cppBuffer *) /*@*/ ;
 206
 207 /* Macros for manipulating the token_buffer. */
 208
 209 /*@notfunction@*/
 210 #define CPP_OUT_BUFFER(PFILE) ((PFILE)->token_buffer)
 211
 212 /* Number of characters currently in PFILE's output buffer. */
 213
 214 extern size_t cpplib_getWritten (/*@sef@*/ cppReader *) /*@*/ ;
 215 # define cpplib_getWritten(PFILE) \
 216   (size_fromInt ((PFILE)->limit - (PFILE)->token_buffer))
 217
 218 extern /*@exposed@*/ char *cpplib_getPWritten (cppReader *) /*@*/ ;
 219 # define cpplib_getPWritten(PFILE) ((PFILE)->limit)
 220
 221 extern /*@null@*/ macroDef
 222 cpplib_createDefinition (/*@dependent@*/ cstring p_def, fileloc p_loc,
 223                          bool p_predefinition, bool p_noExpand) ;
 224
 225 /* Make sure PFILE->token_buffer has space for at least N more characters. */
 226
 227 extern void cpplib_reserve (/*@sef@*/ cppReader *, /*@sef@*/ size_t);
 228 #define cpplib_reserve(PFILE, N) \
 229   (cpplib_getWritten (PFILE) + (N) > (PFILE)->token_buffer_size \
 230    && (cppReader_growBuffer (PFILE, (N)), 0))
 231
 232 /* Append string STR (of length N) to PFILE's output buffer.
 233    Assume there is enough space. */
 234
 235 extern void cppReader_putStrN (/*@sef@*/ cppReader *p_file,
 236                         /*@unique@*/ char *p_str, /*@sef@*/ size_t p_n)
 237                /*@modifies *p_file; @*/;
 238
 239 #define cppReader_putStrN(PFILE, STR, N) \
 240   (memcpy ((PFILE)->limit, STR, (N)), (PFILE)->limit += (N))
 241
 242 extern void cppReader_setWritten (/*@sef@*/ /*@special@*/ cppReader *p_file, size_t)
 243   /*@uses p_file, *p_file, p_file->token_buffer;@*/
 244   /*@sets p_file->limit;@*/
 245   /*@modifies *p_file@*/ ;
 246
 247 # define cppReader_setWritten(PFILE,N) \
 248   ((PFILE)->limit = (PFILE)->token_buffer + (N))
 249
 250 extern /*@dependent@*/ /*@exposed@*/ cppOptions *CPPOPTIONS (/*@special@*/ cppReader *p_pfile)
 251   /*@uses p_pfile->opts@*/ ;
 252 #define CPPOPTIONS(PFILE) ((PFILE)->opts)
 253
 254 /*@notfunction@*/
 255 #define CPPBUFFER(PFILE) ((PFILE)->buffer)
 256
 257 /* Checks for null */
 258 extern /*@exposed@*/ cppBuffer *
 259 cppReader_getBufferSafe (/*@special@*/ cppReader *p_pfile)
 260        /*@uses p_pfile->buffer@*/
 261        /*@modifies nothing@*/ ;
 262
 263 extern /*@exposed@*/ cppBuffer *cppBuffer_prevBuffer (cppBuffer *) /*@*/ ;
 264
 265 /* The bottom of the buffer stack. */
 266 extern /*@exposed@*/ cppBuffer *cppReader_nullBuffer (/*@special@*/ cppReader *p_pfile) /*@uses p_pfile->buffer_stack@*/ /*@*/ ;
 267 # define cppReader_nullBuffer(PFILE) (&(PFILE)->buffer_stack[CPP_STACK_MAX])
 268
 269 /* Pointed to by cppReader::data. */
 270 struct cppOptions {
 271   /*@dependent@*/ cstring in_fname;
 272
 273   /* Name of output file, for error messages.  */
 274   /*@dependent@*/ cstring out_fname;
 275
 276   struct file_name_map_list *map_list;
 277
 278   /* Non-0 means -v, so print the full set of include dirs.  */
 279   bool verbose;
 280
 281   /* Nonzero means use extra default include directories for C++.  */
 282
 283   bool cplusplus;
 284
 285   /* Nonzero means handle cplusplus style comments */
 286
 287   bool cplusplus_comments;
 288
 289   /* Nonzero means this is an assembly file, and allow
 290      unknown directives, which could be comments.  */
 291
 292   int lang_asm;
 293
 294   /* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */
 295
 296   bool for_lint;
 297
 298   /* Nonzero means handle CHILL comment syntax
 299      and output CHILL string delimiter for __DATE___ etc. */
 300
 301   bool chill;
 302
 303   /* Nonzero means copy comments into the output file.  */
 304
 305   bool put_out_comments;
 306
 307   /* Nonzero means don't process the ANSI trigraph sequences.  */
 308
 309   bool no_trigraphs;
 310
 311   /* Nonzero means print names of header files (-H).  */
 312
 313   bool print_include_names;
 314
 315   /* Nonzero means try to make failure to fit ANSI C an error.  */
 316
 317   bool pedantic_errors;
 318
 319   /* Nonzero means don't print warning messages.  -w.  */
 320   /* bool inhibit_warnings; -- removed evans 2001-07-19 */
 321
 322   /* Nonzero means warn if slash-star appears in a comment.  */
 323   bool warn_comments;
 324
 325   /* Nonzero means warn if a macro argument is (or would be)
 326      stringified with -traditional.  */
 327
 328   bool warn_stringify;
 329   bool warnings_are_errors;
 330   bool no_output;
 331
 332   /* Nonzero means don't output line number information.  */
 333
 334   bool no_line_commands;
 335
 336 /* Nonzero means output the text in failing conditionals,
 337    inside #failed ... #endfailed.  */
 338
 339   char output_conditionals;
 340
 341   bool ignore_srcdir;
 342
 343   /* Zero means dollar signs are punctuation.
 344      This used to be needed for conformance to the C Standard,
 345      before the C Standard was corrected.  */
 346   bool dollars_in_ident;
 347
 348   /* Nonzero means try to imitate old fashioned non-ANSI preprocessor.  */
 349   bool traditional;
 350
 351   /* Nonzero for the 1989 C Standard, including corrigenda and amendments.  */
 352   bool c89;
 353
 354   /* Nonzero means give all the error messages the ANSI standard requires.  */
 355   bool pedantic;
 356
 357   bool done_initializing;
 358
 359   /* First dir to search */
 360   /*@owned@*/ struct file_name_list *include;
 361   /* First dir to search for <file> */
 362   /* This is the first element to use for #include <...>.
 363      If it is 0, use the entire chain for such includes.  */
 364   /*@dependent@*/ struct file_name_list *first_bracket_include;
 365   /* This is the first element in the chain that corresponds to
 366      a directory of system header files.  */
 367   /*@dependent@*/ struct file_name_list *first_system_include;
 368   /*@exposed@*/ struct file_name_list *last_include;    /* Last in chain */
 369
 370   /* Chain of include directories to put at the end of the other chain.  */
 371   struct file_name_list *after_include;
 372   /*@exposed@*/ struct file_name_list *last_after_include;      /* Last in chain */
 373
 374   /* Chain to put at the start of the system include files.  */
 375   struct file_name_list *before_system;
 376   /*@exposed@*/ struct file_name_list *last_before_system;      /* Last in chain */
 377
 378   /* Directory prefix that should replace `/usr' in the standard
 379      include file directories.  */
 380   char *include_prefix;
 381
 382   char inhibit_predefs;
 383   char no_standard_includes;
 384   char no_standard_cplusplus_includes;
 385
 386   /*
 387   ** DUMP_NAMES means pass #define and the macro name through to output.
 388   ** DUMP_DEFINITIONS means pass the whole definition (plus #define) through
 389   */
 390
 391   /*@-enummemuse@*/
 392   enum { DUMP_NONE = 0, DUMP_NAMES, DUMP_DEFINITIONS }
 393      dump_macros;
 394   /*@=enummemuse@*/
 395
 396 /* Nonzero means pass all #define and #undef directives which we actually
 397    process through to the output stream.  This feature is used primarily
 398    to allow cc1 to record the #defines and #undefs for the sake of
 399    debuggers which understand about preprocessor macros, but it may
 400    also be useful with -E to figure out how symbols are defined, and
 401    where they are defined.  */
 402   int debug_output;
 403 };
 404
 405 extern bool cppReader_isTraditional (/*@special@*/ cppReader *p_pfile)
 406     /*@uses p_pfile->opts@*/
 407    /*@modifies nothing@*/ ;
 408
 409 #define cppReader_isTraditional(PFILE) (CPPOPTIONS(PFILE)-> traditional)
 410
 411 extern bool cppReader_isPedantic (cppReader *) /*@*/;
 412 #define cppReader_isPedantic(PFILE) (CPPOPTIONS (PFILE)->pedantic)
 413
 414 /* The structure of a node in the hash table.  The hash table
 415    has entries for all tokens defined by #define commands (type T_MACRO),
 416    plus some special tokens like __LINE__ (these each have their own
 417    type, and the appropriate code is run when that type of node is seen.
 418    It does not contain control words like "#define", which are recognized
 419    by a separate piece of code. */
 420
 421 /* different flavors of hash nodes --- also used in keyword table */
 422 enum node_type {
 423  T_NONE = 0,
 424  T_DEFINE = 1,  /* the `#define' keyword */
 425  T_INCLUDE,     /* the `#include' keyword */
 426  T_INCLUDE_NEXT, /* the `#include_next' keyword */
 427  T_IFDEF,       /* the `#ifdef' keyword */
 428  T_IFNDEF,      /* the `#ifndef' keyword */
 429  T_IF,          /* the `#if' keyword */
 430  T_ELSE,        /* `#else' */
 431  T_PRAGMA,      /* `#pragma' */
 432  T_ELIF,        /* `#elif' */
 433  T_UNDEF,       /* `#undef' */
 434  T_LINE,        /* `#line' */
 435  T_ERROR,       /* `#error' */
 436  T_WARNING,     /* `#warning' */
 437  T_ENDIF,       /* `#endif' */
 438  T_IDENT,       /* `#ident', used on system V.  */
 439  T_SPECLINE,    /* special symbol `__LINE__' */
 440  T_DATE,        /* `__DATE__' */
 441  T_FILE,        /* `__FILE__' */
 442  T_BASE_FILE,   /* `__BASE_FILE__' */
 443  T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
 444  T_VERSION,     /* `__VERSION__' */
 445  T_SIZE_TYPE,   /* `__SIZE_TYPE__' */
 446  T_PTRDIFF_TYPE,   /* `__PTRDIFF_TYPE__' */
 447  T_WCHAR_TYPE,   /* `__WCHAR_TYPE__' */
 448  T_USER_LABEL_PREFIX_TYPE, /* `__USER_LABEL_PREFIX__' */
 449  T_REGISTER_PREFIX_TYPE,   /* `__REGISTER_PREFIX__' */
 450  T_TIME,        /* `__TIME__' */
 451  T_CONST,       /* Constant value, used by `__STDC__' */
 452  T_MACRO,       /* macro defined by `#define' */
 453  T_DISABLED,    /* macro temporarily turned off for rescan */
 454  T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
 455  T_PCSTRING,    /* precompiled string (hashval is KEYDEF *) */
 456  T_UNUSED       /* Used for something not defined.  */
 457 } ;
 458
 459 struct s_macrodef
 460 {
 461   /*@null@*/ struct definition *defn;
 462   /*@exposed@*/ /*@relnull@*/ char *symnam; /* null if defn is null */
 463   int symlen;
 464 };
 465
 466 /* Structure allocated for every #define.  For a simple replacement
 467    such as
 468         #define foo bar ,
 469    nargs = -1, the `pattern' list is null, and the expansion is just
 470    the replacement text.  Nargs = 0 means a functionlike macro with no args,
 471    e.g.,
 472        #define getchar() getc (stdin) .
 473    When there are args, the expansion is the replacement text with the
 474    args squashed out, and the reflist is a list describing how to
 475    build the output from the input: e.g., "3 chars, then the 1st arg,
 476    then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
 477    The chars here come from the expansion.  Whatever is left of the
 478    expansion after the last arg-occurrence is copied after that arg.
 479    Note that the reflist can be arbitrarily long---
 480    its length depends on the number of times the arguments appear in
 481    the replacement text, not how many args there are.  Example:
 482    #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
 483    pattern list
 484      { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
 485    where (x, y) means (nchars, argno). */
 486
 487 typedef struct definition DEFINITION;
 488
 489 struct definition {
 490   int nargs;
 491   size_t length;                        /* length of expansion string */
 492   bool predefined;              /* True if the macro was builtin or */
 493                                 /* came from the command line */
 494   /*@dependent@*/ char *expansion;
 495   long line;                    /* Line number of definition */
 496   /*@exposed@*/ cstring file;   /* File of definition */
 497
 498   bool noExpand;                /* True if macro should not be expanded in code. */
 499   bool rest_args;               /* Nonzero if last arg. absorbs the rest */
 500
 501   /*@null@*/ struct reflist {
 502     /*@null@*/ /*@dependent@*/ struct reflist *next;
 503     bool stringify;             /* nonzero if this arg was preceded by a
 504                                    # operator. */
 505     bool raw_before;            /* Nonzero if a ## operator before arg. */
 506     bool raw_after;             /* Nonzero if a ## operator after arg. */
 507     bool rest_args;             /* Nonzero if this arg. absorbs the rest */
 508     int nchars;                 /* Number of literal chars to copy before
 509                                    this arg occurrence.  */
 510     int argno;                  /* Number of arg to substitute (origin-0) */
 511   } *pattern;
 512
 513   union {
 514     /* Names of macro args, concatenated in reverse order
 515        with comma-space between them.
 516        The only use of this is that we warn on redefinition
 517        if this differs between the old and new definitions.  */
 518     /*@null@*/ char *argnames;
 519   } args;
 520 };
 521
 522 /* Stack of conditionals currently in progress
 523    (including both successful and failing conditionals).  */
 524
 525 struct if_stack {
 526   /*@null@*/ struct if_stack *next;  /* for chaining to the next stack frame */
 527   /*@observer@*/ cstring fname;     /* copied from input when frame is made */
 528   int lineno;                   /* similarly */
 529   int if_succeeded;             /* true if a leg of this if-group
 530                                     has been passed through rescan */
 531
 532   /* For #ifndef at start of file, this is the macro name tested.  */
 533   /*@null@*/ /*@dependent@*/ char *control_macro;
 534
 535
 536   enum node_type type;          /* type of last directive seen in this group */
 537 };
 538 typedef struct if_stack cppIfStackFrame;
 539
 540 extern void cppBuffer_lineAndColumn (/*@null@*/ cppBuffer *, /*@out@*/ int *,
 541                                      /*@out@*/ /*@null@*/ int *);
 542 extern /*@exposed@*/ /*@null@*/ cppBuffer *cppReader_fileBuffer (cppReader *);
 543
 544 extern void cppReader_growBuffer (cppReader *, size_t);
 545 extern int cppReader_parseEscape (cppReader *, char **);
 546
 547 extern /*@exposed@*/ cppBuffer *cppReader_popBuffer (cppReader *p_pfile)
 548     /*@modifies p_pfile@*/ ;
 549
 550 #ifdef __cplusplus
 551 }
 552 #endif
 553
 554 extern void cppReader_skipRestOfLine (cppReader *p_pfile);
 555
 556 # include <stdlib.h>
 557
 558 /*@constant observer char *GCC_INCLUDE_DIR;@*/
 559 /* This is defined by config.h now. */
 560
 561 /*@constant observer char *GCC_INCLUDE_DIR2@*/
 562 /* This is defined by config.h now. */
 563
 564 struct file_name_list
 565 {
 566   /*@owned@*/ /*@null@*/ struct file_name_list *next;
 567   /*@dependent@*/ cstring fname;
 568
 569   /* If the following is nonzero, it is a macro name.
 570      Don't include the file again if that macro is defined.  */
 571
 572   /*@dependent@*/ /*@null@*/ char *control_macro;
 573   /* If the following is nonzero, it is a C-language system include
 574      directory.  */
 575
 576   bool c_system_include_path;
 577
 578   /* Mapping of file names for this directory.  */
 579   /*@exposed@*/ /*@relnull@*/ /*@reldef@*/ struct file_name_map *name_map;
 580
 581   /* Non-zero if name_map is valid.  */
 582   bool got_name_map;
 583 };
 584
 585 extern void cppReader_addIncludeChain (/*@special@*/ cppReader *p_pfile,
 586                                        /*@keep@*/ struct file_name_list *p_dir)
 587      /*@uses p_pfile->opts, p_pfile->max_include_len@*/
 588      /*@modifies p_pfile, p_dir@*/ ;
 589
 590 extern void cppReader_define (cppReader *p_pfile, char *p_str);
 591 extern void cppReader_finish (cppReader *p_pfile);
 592 extern void cpplib_init (/*@out@*/ cppReader *p_pfile) ;
 593 extern void cppOptions_init (/*@out@*/ cppOptions *p_opts);
 594 extern void cpplib_initializeReader (cppReader *p_pfile) /*@modifies p_pfile@*/ ;
 595
 596 extern int cppReader_startProcess (cppReader *p_pfile, cstring p_fname);
 597
 598 extern bool isIdentifierChar (char) /*@*/ ;
 599
 600 /* Find the largest host integer type and set its size and type.  */
 601
 602 #ifndef HOST_BITS_PER_WIDE_INT
 603
 604 #if HOST_BITS_PER_LONG > HOST_BITS_PER_INT
 605 /*@notfunction@*/
 606 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
 607 /*@notfunction@*/
 608 #define HOST_WIDE_INT long
 609 #else
 610 /*@notfunction@*/
 611 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT
 612 /*@notfunction@*/
 613 #define HOST_WIDE_INT long
 614 /* was int */
 615 #endif
 616
 617 #endif
 618
 619 #ifndef S_ISREG
 620 /*@-macrounrecog@*/
 621 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
 622 /*@=macrounrecog@*/
 623 #endif
 624
 625 #ifndef S_ISDIR
 626 /*@-macrounrecog@*/
 627 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
 628 /*@=macrounrecog@*/
 629 #endif
 630
 631 #ifndef INCLUDE_LEN_FUDGE
 632 /*@constant int INCLUDE_LEN_FUDGE@*/
 633 #define INCLUDE_LEN_FUDGE 0
 634 #endif
 635
 636 extern int cppReader_checkMacroName (cppReader *p_pfile, char *p_symname,
 637                                      cstring p_usage);
 638
 639 extern struct operation cppReader_parseNumber (cppReader *, char *, int);
 640