gcc/cpplib.c

   1 /* CPP Library. (Directive handling.)
   2    Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001 Free Software Foundation, Inc.
   4    Contributed by Per Bothner, 1994-95.
   5    Based on CCCP program by Paul Rubin, June 1986
   6    Adapted to ANSI C, Richard Stallman, Jan 1987
   7
   8 This program is free software; you can redistribute it and/or modify it
   9 under the terms of the GNU General Public License as published by the
  10 Free Software Foundation; either version 2, or (at your option) any
  11 later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24
  25 #include "cpplib.h"
  26 #include "cpphash.h"
  27 #include "obstack.h"
  28
  29 /* Chained list of answers to an assertion.  */
  30 struct answer
  31 {
  32   struct answer *next;
  33   unsigned int count;
  34   cpp_token first[1];
  35 };
  36
  37 /* Stack of conditionals currently in progress
  38    (including both successful and failing conditionals).  */
  39
  40 struct if_stack
  41 {
  42   struct if_stack *next;
  43   unsigned int line;            /* Line where condition started.  */
  44   const cpp_hashnode *mi_cmacro;/* macro name for #ifndef around entire file */
  45   bool skip_elses;              /* Can future #else / #elif be skipped?  */
  46   bool was_skipping;            /* If were skipping on entry.  */
  47   int type;                     /* Most recent conditional, for diagnostics.  */
  48 };
  49
  50 /* Contains a registered pragma or pragma namespace.  */
  51 typedef void (*pragma_cb) PARAMS ((cpp_reader *));
  52 struct pragma_entry
  53 {
  54   struct pragma_entry *next;
  55   const cpp_hashnode *pragma;   /* Name and length.  */
  56   int is_nspace;
  57   union {
  58     pragma_cb handler;
  59     struct pragma_entry *space;
  60   } u;
  61 };
  62
  63 /* Values for the origin field of struct directive.  KANDR directives
  64    come from traditional (K&R) C.  STDC89 directives come from the
  65    1989 C standard.  EXTENSION directives are extensions.  */
  66 #define KANDR           0
  67 #define STDC89          1
  68 #define EXTENSION       2
  69
  70 /* Values for the flags field of struct directive.  COND indicates a
  71    conditional; IF_COND an opening conditional.  INCL means to treat
  72    "..." and <...> as q-char and h-char sequences respectively.  IN_I
  73    means this directive should be handled even if -fpreprocessed is in
  74    effect (these are the directives with callback hooks).  */
  75 #define COND            (1 << 0)
  76 #define IF_COND         (1 << 1)
  77 #define INCL            (1 << 2)
  78 #define IN_I            (1 << 3)
  79
  80 /* Defines one #-directive, including how to handle it.  */
  81 typedef void (*directive_handler) PARAMS ((cpp_reader *));
  82 typedef struct directive directive;
  83 struct directive
  84 {
  85   directive_handler handler;    /* Function to handle directive.  */
  86   const U_CHAR *name;           /* Name of directive.  */
  87   unsigned short length;        /* Length of name.  */
  88   unsigned char origin;         /* Origin of directive.  */
  89   unsigned char flags;          /* Flags describing this directive.  */
  90 };
  91
  92 /* Forward declarations.  */
  93
  94 static void skip_rest_of_line   PARAMS ((cpp_reader *));
  95 static void check_eol           PARAMS ((cpp_reader *));
  96 static void start_directive     PARAMS ((cpp_reader *));
  97 static void end_directive       PARAMS ((cpp_reader *, int));
  98 static void directive_diagnostics
  99         PARAMS ((cpp_reader *, const directive *, int));
 100 static void run_directive       PARAMS ((cpp_reader *, int,
 101                                          const char *, size_t));
 102 static const cpp_token *glue_header_name PARAMS ((cpp_reader *));
 103 static const cpp_token *parse_include PARAMS ((cpp_reader *));
 104 static void push_conditional    PARAMS ((cpp_reader *, int, int,
 105                                          const cpp_hashnode *));
 106 static unsigned int read_flag   PARAMS ((cpp_reader *, unsigned int));
 107 static int  strtoul_for_line    PARAMS ((const U_CHAR *, unsigned int,
 108                                          unsigned long *));
 109 static void do_diagnostic       PARAMS ((cpp_reader *, enum error_type, int));
 110 static cpp_hashnode *lex_macro_node     PARAMS ((cpp_reader *));
 111 static void do_include_common   PARAMS ((cpp_reader *, enum include_type));
 112 static struct pragma_entry *lookup_pragma_entry
 113   PARAMS ((struct pragma_entry *, const cpp_hashnode *pragma));
 114 static struct pragma_entry *insert_pragma_entry
 115   PARAMS ((cpp_reader *, struct pragma_entry **, const cpp_hashnode *,
 116            pragma_cb));
 117 static void do_pragma_once      PARAMS ((cpp_reader *));
 118 static void do_pragma_poison    PARAMS ((cpp_reader *));
 119 static void do_pragma_system_header     PARAMS ((cpp_reader *));
 120 static void do_pragma_dependency        PARAMS ((cpp_reader *));
 121 static const cpp_token *get_token_no_padding PARAMS ((cpp_reader *));
 122 static const cpp_token *get__Pragma_string PARAMS ((cpp_reader *));
 123 static void destringize_and_run PARAMS ((cpp_reader *, const cpp_string *));
 124 static int parse_answer PARAMS ((cpp_reader *, struct answer **, int));
 125 static cpp_hashnode *parse_assertion PARAMS ((cpp_reader *, struct answer **,
 126                                               int));
 127 static struct answer ** find_answer PARAMS ((cpp_hashnode *,
 128                                              const struct answer *));
 129 static void handle_assertion    PARAMS ((cpp_reader *, const char *, int));
 130
 131 /* This is the table of directive handlers.  It is ordered by
 132    frequency of occurrence; the numbers at the end are directive
 133    counts from all the source code I have lying around (egcs and libc
 134    CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
 135    pcmcia-cs-3.0.9).  This is no longer important as directive lookup
 136    is now O(1).  All extensions other than #warning and #include_next
 137    are deprecated.  The name is where the extension appears to have
 138    come from.  */
 139
 140 #define DIRECTIVE_TABLE                                                 \
 141 D(define,       T_DEFINE = 0,   KANDR,     IN_I)           /* 270554 */ \
 142 D(include,      T_INCLUDE,      KANDR,     INCL)           /*  52262 */ \
 143 D(endif,        T_ENDIF,        KANDR,     COND)           /*  45855 */ \
 144 D(ifdef,        T_IFDEF,        KANDR,     COND | IF_COND) /*  22000 */ \
 145 D(if,           T_IF,           KANDR,     COND | IF_COND) /*  18162 */ \
 146 D(else,         T_ELSE,         KANDR,     COND)           /*   9863 */ \
 147 D(ifndef,       T_IFNDEF,       KANDR,     COND | IF_COND) /*   9675 */ \
 148 D(undef,        T_UNDEF,        KANDR,     IN_I)           /*   4837 */ \
 149 D(line,         T_LINE,         KANDR,     IN_I)           /*   2465 */ \
 150 D(elif,         T_ELIF,         STDC89,    COND)           /*    610 */ \
 151 D(error,        T_ERROR,        STDC89,    0)              /*    475 */ \
 152 D(pragma,       T_PRAGMA,       STDC89,    IN_I)           /*    195 */ \
 153 D(warning,      T_WARNING,      EXTENSION, 0)              /*     22 */ \
 154 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL)           /*     19 */ \
 155 D(ident,        T_IDENT,        EXTENSION, IN_I)           /*     11 */ \
 156 D(import,       T_IMPORT,       EXTENSION, INCL)           /* 0 ObjC */ \
 157 D(assert,       T_ASSERT,       EXTENSION, 0)              /* 0 SVR4 */ \
 158 D(unassert,     T_UNASSERT,     EXTENSION, 0)              /* 0 SVR4 */ \
 159 SCCS_ENTRY                                                 /* 0 SVR4? */
 160
 161 /* #sccs is not always recognized.  */
 162 #ifdef SCCS_DIRECTIVE
 163 # define SCCS_ENTRY D(sccs, T_SCCS, EXTENSION, 0)
 164 #else
 165 # define SCCS_ENTRY /* nothing */
 166 #endif
 167
 168 /* Use the table to generate a series of prototypes, an enum for the
 169    directive names, and an array of directive handlers.  */
 170
 171 /* The directive-processing functions are declared to return int
 172    instead of void, because some old compilers have trouble with
 173    pointers to functions returning void.  */
 174
 175 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail.  */
 176 #define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
 177 DIRECTIVE_TABLE
 178 #undef D
 179
 180 #define D(n, tag, o, f) tag,
 181 enum
 182 {
 183   DIRECTIVE_TABLE
 184   N_DIRECTIVES
 185 };
 186 #undef D
 187
 188 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail.  */
 189 #define D(name, t, origin, flags) \
 190 { CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
 191   sizeof STRINGX(name) - 1, origin, flags },
 192 static const directive dtable[] =
 193 {
 194 DIRECTIVE_TABLE
 195 };
 196 #undef D
 197 #undef DIRECTIVE_TABLE
 198
 199 #define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
 200
 201 /* Skip any remaining tokens in a directive.  */
 202 static void
 203 skip_rest_of_line (pfile)
 204      cpp_reader *pfile;
 205 {
 206   /* Discard all stacked contexts.  */
 207   while (pfile->context != &pfile->base_context)
 208     _cpp_pop_context (pfile);
 209
 210   /* Sweep up all tokens remaining on the line.  */
 211   if (! SEEN_EOL ())
 212     while (_cpp_lex_token (pfile)->type != CPP_EOF)
 213       ;
 214 }
 215
 216 /* Ensure there are no stray tokens at the end of a directive.  */
 217 static void
 218 check_eol (pfile)
 219      cpp_reader *pfile;
 220 {
 221   if (! SEEN_EOL () && _cpp_lex_token (pfile)->type != CPP_EOF)
 222     cpp_pedwarn (pfile, "extra tokens at end of #%s directive",
 223                  pfile->directive->name);
 224 }
 225
 226 /* Called when entering a directive, _Pragma or command-line directive.  */
 227 static void
 228 start_directive (pfile)
 229      cpp_reader *pfile;
 230 {
 231   /* Setup in-directive state.  */
 232   pfile->state.in_directive = 1;
 233   pfile->state.save_comments = 0;
 234
 235   /* Some handlers need the position of the # for diagnostics.  */
 236   pfile->directive_line = pfile->line;
 237 }
 238
 239 /* Called when leaving a directive, _Pragma or command-line directive.  */
 240 static void
 241 end_directive (pfile, skip_line)
 242      cpp_reader *pfile;
 243      int skip_line;
 244 {
 245   /* We don't skip for an assembler #.  */
 246   if (skip_line)
 247     {
 248       skip_rest_of_line (pfile);
 249       if (!pfile->keep_tokens)
 250         {
 251           pfile->cur_run = &pfile->base_run;
 252           pfile->cur_token = pfile->base_run.base;
 253         }
 254     }
 255
 256   /* Restore state.  */
 257   pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
 258   pfile->state.in_directive = 0;
 259   pfile->state.angled_headers = 0;
 260   pfile->state.line_extension = 0;
 261   pfile->directive = 0;
 262 }
 263
 264 /* Output diagnostics for a directive DIR.  INDENTED is non-zero if
 265    the '#' was indented.  */
 266
 267 static void
 268 directive_diagnostics (pfile, dir, indented)
 269      cpp_reader *pfile;
 270      const directive *dir;
 271      int indented;
 272 {
 273   if (pfile->state.line_extension)
 274     {
 275       if (CPP_PEDANTIC (pfile)
 276           && ! pfile->state.skipping)
 277         cpp_pedwarn (pfile, "style of line directive is a GCC extension");
 278     }
 279   else
 280     {
 281       /* Issue -pedantic warnings for extensions.  */
 282       if (CPP_PEDANTIC (pfile)
 283           && ! pfile->state.skipping
 284           && dir->origin == EXTENSION)
 285         cpp_pedwarn (pfile, "#%s is a GCC extension", dir->name);
 286
 287       /* Traditionally, a directive is ignored unless its # is in
 288          column 1.  Therefore in code intended to work with K+R
 289          compilers, directives added by C89 must have their #
 290          indented, and directives present in traditional C must not.
 291          This is true even of directives in skipped conditional
 292          blocks.  */
 293       if (CPP_WTRADITIONAL (pfile))
 294         {
 295           if (dir == &dtable[T_ELIF])
 296             cpp_warning (pfile, "suggest not using #elif in traditional C");
 297           else if (indented && dir->origin == KANDR)
 298             cpp_warning (pfile,
 299                          "traditional C ignores #%s with the # indented",
 300                          dir->name);
 301           else if (!indented && dir->origin != KANDR)
 302             cpp_warning (pfile,
 303                  "suggest hiding #%s from traditional C with an indented #",
 304                          dir->name);
 305         }
 306     }
 307 }
 308
 309 /* Check if we have a known directive.  INDENTED is non-zero if the
 310    '#' of the directive was indented.  This function is in this file
 311    to save unnecessarily exporting dtable etc. to cpplex.c.  Returns
 312    non-zero if the line of tokens has been handled, zero if we should
 313    continue processing the line.  */
 314
 315 int
 316 _cpp_handle_directive (pfile, indented)
 317      cpp_reader *pfile;
 318      int indented;
 319 {
 320   const directive *dir = 0;
 321   const cpp_token *dname;
 322   int skip = 1;
 323
 324   start_directive (pfile);
 325   dname = _cpp_lex_token (pfile);
 326
 327   if (dname->type == CPP_NAME)
 328     {
 329       if (dname->val.node->directive_index)
 330         dir = &dtable[dname->val.node->directive_index - 1];
 331     }
 332   /* We do not recognise the # followed by a number extension in
 333      assembler code.  */
 334   else if (dname->type == CPP_NUMBER && CPP_OPTION (pfile, lang) != CLK_ASM)
 335     {
 336       dir = &dtable[T_LINE];
 337       pfile->state.line_extension = 1;
 338     }
 339
 340   if (dir)
 341     {
 342       /* If we have a directive that is not an opening conditional,
 343          invalidate any control macro.  */
 344       if (! (dir->flags & IF_COND))
 345         pfile->mi_valid = false;
 346
 347       /* Kluge alert.  In order to be sure that code like this
 348
 349          #define HASH #
 350          HASH define foo bar
 351
 352          does not cause '#define foo bar' to get executed when
 353          compiled with -save-temps, we recognize directives in
 354          -fpreprocessed mode only if the # is in column 1.  cppmacro.c
 355          puts a space in fron of any '#' at the start of a macro.  */
 356       if (CPP_OPTION (pfile, preprocessed)
 357           && (indented || !(dir->flags & IN_I)))
 358         {
 359           skip = 0;
 360           dir = 0;
 361         }
 362       else
 363         {
 364           /* In failed conditional groups, all non-conditional
 365              directives are ignored.  Before doing that, whether
 366              skipping or not, we should lex angle-bracketed headers
 367              correctly, and maybe output some diagnostics.  */
 368           pfile->state.angled_headers = dir->flags & INCL;
 369           if (! CPP_OPTION (pfile, preprocessed))
 370             directive_diagnostics (pfile, dir, indented);
 371           if (pfile->state.skipping && !(dir->flags & COND))
 372             dir = 0;
 373         }
 374     }
 375   else if (dname->type == CPP_EOF)
 376     ;   /* CPP_EOF is the "null directive".  */
 377   else
 378     {
 379       /* An unknown directive.  Don't complain about it in assembly
 380          source: we don't know where the comments are, and # may
 381          introduce assembler pseudo-ops.  Don't complain about invalid
 382          directives in skipped conditional groups (6.10 p4).  */
 383       if (CPP_OPTION (pfile, lang) == CLK_ASM)
 384         skip = 0;
 385       else if (!pfile->state.skipping)
 386         cpp_error (pfile, "invalid preprocessing directive #%s",
 387                    cpp_token_as_text (pfile, dname));
 388     }
 389
 390   if (dir)
 391     {
 392       pfile->directive = dir;
 393       (*pfile->directive->handler) (pfile);
 394     }
 395   else if (skip == 0)
 396     _cpp_backup_tokens (pfile, 1);
 397
 398   end_directive (pfile, skip);
 399   return skip;
 400 }
 401
 402 /* Directive handler wrapper used by the command line option
 403    processor.  */
 404 static void
 405 run_directive (pfile, dir_no, buf, count)
 406      cpp_reader *pfile;
 407      int dir_no;
 408      const char *buf;
 409      size_t count;
 410 {
 411   cpp_push_buffer (pfile, (const U_CHAR *) buf, count,
 412                    /* from_stage3 */ true, 1);
 413   start_directive (pfile);
 414   /* We don't want a leading # to be interpreted as a directive.  */
 415   pfile->buffer->saved_flags = 0;
 416   pfile->directive = &dtable[dir_no];
 417   (void) (*pfile->directive->handler) (pfile);
 418   end_directive (pfile, 1);
 419   _cpp_pop_buffer (pfile);
 420 }
 421
 422 /* Checks for validity the macro name in #define, #undef, #ifdef and
 423    #ifndef directives.  */
 424 static cpp_hashnode *
 425 lex_macro_node (pfile)
 426      cpp_reader *pfile;
 427 {
 428   cpp_hashnode *node;
 429   const cpp_token *token = _cpp_lex_token (pfile);
 430
 431   /* The token immediately after #define must be an identifier.  That
 432      identifier may not be "defined", per C99 6.10.8p4.
 433      In C++, it may not be any of the "named operators" either,
 434      per C++98 [lex.digraph], [lex.key].
 435      Finally, the identifier may not have been poisoned.  (In that case
 436      the lexer has issued the error message for us.)  */
 437
 438   if (token->type != CPP_NAME)
 439     {
 440       if (token->type == CPP_EOF)
 441         cpp_error (pfile, "no macro name given in #%s directive",
 442                    pfile->directive->name);
 443       else if (token->flags & NAMED_OP)
 444         cpp_error (pfile,
 445            "\"%s\" cannot be used as a macro name as it is an operator in C++",
 446                    NODE_NAME (token->val.node));
 447       else
 448         cpp_error (pfile, "macro names must be identifiers");
 449
 450       return 0;
 451     }
 452
 453   node = token->val.node;
 454   if (node->flags & NODE_POISONED)
 455     return 0;
 456
 457   if (node == pfile->spec_nodes.n_defined)
 458     {
 459       cpp_error (pfile, "\"%s\" cannot be used as a macro name",
 460                  NODE_NAME (node));
 461       return 0;
 462     }
 463
 464   return node;
 465 }
 466
 467 /* Process a #define directive.  Most work is done in cppmacro.c.  */
 468 static void
 469 do_define (pfile)
 470      cpp_reader *pfile;
 471 {
 472   cpp_hashnode *node = lex_macro_node (pfile);
 473
 474   if (node)
 475     {
 476       if (_cpp_create_definition (pfile, node))
 477         if (pfile->cb.define)
 478           (*pfile->cb.define) (pfile, pfile->directive_line, node);
 479     }
 480 }
 481
 482 /* Handle #undef.  Marks the identifier NT_VOID in the hash table.  */
 483 static void
 484 do_undef (pfile)
 485      cpp_reader *pfile;
 486 {
 487   cpp_hashnode *node = lex_macro_node (pfile);
 488
 489   /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
 490      is not currently defined as a macro name.  */
 491   if (node && node->type == NT_MACRO)
 492     {
 493       if (pfile->cb.undef)
 494         (*pfile->cb.undef) (pfile, pfile->directive_line, node);
 495
 496       if (node->flags & NODE_WARN)
 497         cpp_warning (pfile, "undefining \"%s\"", NODE_NAME (node));
 498
 499       _cpp_free_definition (node);
 500     }
 501   check_eol (pfile);
 502 }
 503
 504 /* Helper routine used by parse_include.  Reinterpret the current line
 505    as an h-char-sequence (< ... >); we are looking at the first token
 506    after the <.  Returns the header as a token, or NULL on failure.  */
 507 static const cpp_token *
 508 glue_header_name (pfile)
 509      cpp_reader *pfile;
 510 {
 511   cpp_token *header = NULL;
 512   const cpp_token *token;
 513   unsigned char *dest;
 514   size_t len;
 515
 516   /* To avoid lexed tokens overwriting our glued name, we can only
 517      allocate from the string pool once we've lexed everything.  */
 518
 519   dest = BUFF_FRONT (pfile->u_buff);
 520   for (;;)
 521     {
 522       token = cpp_get_token (pfile);
 523
 524       if (token->type == CPP_GREATER || token->type == CPP_EOF)
 525         break;
 526
 527       /* + 1 for terminating NUL.  */
 528       len = cpp_token_len (token) + 1;
 529       if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
 530         {
 531           size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
 532           _cpp_extend_buff (pfile, &pfile->u_buff, len);
 533           dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
 534         }
 535
 536       if (token->flags & PREV_WHITE)
 537         *dest++ = ' ';
 538
 539       dest = cpp_spell_token (pfile, token, dest);
 540     }
 541
 542   if (token->type == CPP_EOF)
 543     cpp_error (pfile, "missing terminating > character");
 544   else
 545     {
 546       header = _cpp_temp_token (pfile);
 547       header->type = CPP_HEADER_NAME;
 548       header->flags = 0;
 549       header->val.str.len = dest - BUFF_FRONT (pfile->u_buff);
 550       header->val.str.text = BUFF_FRONT (pfile->u_buff);
 551       *dest++ = '\0';
 552       BUFF_FRONT (pfile->u_buff) = dest;
 553     }
 554
 555   return header;
 556 }
 557
 558 /* Returns the header string of #include, #include_next, #import and
 559    #pragma dependency.  Returns NULL on error.  */
 560 static const cpp_token *
 561 parse_include (pfile)
 562      cpp_reader *pfile;
 563 {
 564   const unsigned char *dir;
 565   const cpp_token *header;
 566
 567   if (pfile->directive == &dtable[T_PRAGMA])
 568     dir = U"pragma dependency";
 569   else
 570     dir = pfile->directive->name;
 571
 572   /* Allow macro expansion.  */
 573   header = cpp_get_token (pfile);
 574   if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME)
 575     {
 576       if (header->type != CPP_LESS)
 577         {
 578           cpp_error (pfile, "#%s expects \"FILENAME\" or <FILENAME>", dir);
 579           return NULL;
 580         }
 581
 582       header = glue_header_name (pfile);
 583       if (header == NULL)
 584         return header;
 585     }
 586
 587   if (header->val.str.len == 0)
 588     {
 589       cpp_error (pfile, "empty file name in #%s", dir);
 590       return NULL;
 591     }
 592
 593   return header;
 594 }
 595
 596 /* Handle #include, #include_next and #import.  */
 597 static void
 598 do_include_common (pfile, type)
 599      cpp_reader *pfile;
 600      enum include_type type;
 601 {
 602   const cpp_token *header;
 603
 604   /* For #include_next, if this is the primary source file, warn and
 605      use the normal search logic.  */
 606   if (type == IT_INCLUDE_NEXT && ! pfile->buffer->prev)
 607     {
 608       cpp_warning (pfile, "#include_next in primary source file");
 609       type = IT_INCLUDE;
 610     }
 611   else if (type == IT_IMPORT && CPP_OPTION (pfile, warn_import))
 612     {
 613       CPP_OPTION (pfile, warn_import) = 0;
 614       cpp_warning (pfile,
 615            "#import is obsolete, use an #ifndef wrapper in the header file");
 616     }
 617
 618   header = parse_include (pfile);
 619   if (header)
 620     {
 621       /* Prevent #include recursion.  */
 622       if (pfile->line_maps.depth >= CPP_STACK_MAX)
 623         cpp_fatal (pfile, "#include nested too deeply");
 624       else
 625         {
 626           check_eol (pfile);
 627           /* Get out of macro context, if we are.  */
 628           skip_rest_of_line (pfile);
 629           if (pfile->cb.include)
 630             (*pfile->cb.include) (pfile, pfile->directive_line,
 631                                   pfile->directive->name, header);
 632
 633           _cpp_execute_include (pfile, header, type);
 634         }
 635     }
 636 }
 637
 638 static void
 639 do_include (pfile)
 640      cpp_reader *pfile;
 641 {
 642   do_include_common (pfile, IT_INCLUDE);
 643 }
 644
 645 static void
 646 do_import (pfile)
 647      cpp_reader *pfile;
 648 {
 649   do_include_common (pfile, IT_IMPORT);
 650 }
 651
 652 static void
 653 do_include_next (pfile)
 654      cpp_reader *pfile;
 655 {
 656   do_include_common (pfile, IT_INCLUDE_NEXT);
 657 }
 658
 659 /* Subroutine of do_line.  Read possible flags after file name.  LAST
 660    is the last flag seen; 0 if this is the first flag. Return the flag
 661    if it is valid, 0 at the end of the directive. Otherwise complain.  */
 662
 663 static unsigned int
 664 read_flag (pfile, last)
 665      cpp_reader *pfile;
 666      unsigned int last;
 667 {
 668   const cpp_token *token = _cpp_lex_token (pfile);
 669
 670   if (token->type == CPP_NUMBER && token->val.str.len == 1)
 671     {
 672       unsigned int flag = token->val.str.text[0] - '0';
 673
 674       if (flag > last && flag <= 4
 675           && (flag != 4 || last == 3)
 676           && (flag != 2 || last == 0))
 677         return flag;
 678     }
 679
 680   if (token->type != CPP_EOF)
 681     cpp_error (pfile, "invalid flag \"%s\" in line directive",
 682                cpp_token_as_text (pfile, token));
 683   return 0;
 684 }
 685
 686 /* Another subroutine of do_line.  Convert a number in STR, of length
 687    LEN, to binary; store it in NUMP, and return 0 if the number was
 688    well-formed, 1 if not.  Temporary, hopefully.  */
 689 static int
 690 strtoul_for_line (str, len, nump)
 691      const U_CHAR *str;
 692      unsigned int len;
 693      unsigned long *nump;
 694 {
 695   unsigned long reg = 0;
 696   U_CHAR c;
 697   while (len--)
 698     {
 699       c = *str++;
 700       if (!ISDIGIT (c))
 701         return 1;
 702       reg *= 10;
 703       reg += c - '0';
 704     }
 705   *nump = reg;
 706   return 0;
 707 }
 708
 709 /* Interpret #line command.
 710    Note that the filename string (if any) is treated as if it were an
 711    include filename.  That means no escape handling.  */
 712
 713 static void
 714 do_line (pfile)
 715      cpp_reader *pfile;
 716 {
 717   const cpp_token *token;
 718   const char *new_file = pfile->map->to_file;
 719   unsigned long new_lineno;
 720   unsigned int cap, new_sysp = pfile->map->sysp;
 721   enum lc_reason reason = LC_RENAME;
 722
 723   /* C99 raised the minimum limit on #line numbers.  */
 724   cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
 725
 726   /* Putting this in _cpp_handle_directive risks two calls to
 727      _cpp_backup_tokens in some circumstances, which can segfault.  */
 728   if (pfile->state.line_extension)
 729     _cpp_backup_tokens (pfile, 1);
 730
 731   /* #line commands expand macros.  */
 732   token = cpp_get_token (pfile);
 733   if (token->type != CPP_NUMBER
 734       || strtoul_for_line (token->val.str.text, token->val.str.len,
 735                            &new_lineno))
 736     {
 737       cpp_error (pfile, "\"%s\" after #line is not a positive integer",
 738                  cpp_token_as_text (pfile, token));
 739       return;
 740     }
 741
 742   if (CPP_PEDANTIC (pfile) && ! pfile->state.line_extension
 743       && (new_lineno == 0 || new_lineno > cap))
 744     cpp_pedwarn (pfile, "line number out of range");
 745
 746   token = cpp_get_token (pfile);
 747   if (token->type == CPP_STRING)
 748     {
 749       new_file = (const char *) token->val.str.text;
 750
 751       /* Only accept flags for the # 55 form.  */
 752       if (pfile->state.line_extension)
 753         {
 754           int flag;
 755
 756           new_sysp = 0;
 757           flag = read_flag (pfile, 0);
 758           if (flag == 1)
 759             {
 760               reason = LC_ENTER;
 761               /* Fake an include for cpp_included ().  */
 762               _cpp_fake_include (pfile, new_file);
 763               flag = read_flag (pfile, flag);
 764             }
 765           else if (flag == 2)
 766             {
 767               reason = LC_LEAVE;
 768               flag = read_flag (pfile, flag);
 769             }
 770           if (flag == 3)
 771             {
 772               new_sysp = 1;
 773               flag = read_flag (pfile, flag);
 774               if (flag == 4)
 775                 new_sysp = 2;
 776             }
 777         }
 778       check_eol (pfile);
 779     }
 780   else if (token->type != CPP_EOF)
 781     {
 782       cpp_error (pfile, "\"%s\" is not a valid filename",
 783                  cpp_token_as_text (pfile, token));
 784       return;
 785     }
 786
 787   skip_rest_of_line (pfile);
 788   _cpp_do_file_change (pfile, reason, new_file, new_lineno, new_sysp);
 789 }
 790
 791 /* Arrange the file_change callback.  pfile->line has changed to
 792    FILE_LINE of TO_FILE, for reason REASON.  SYSP is 1 for a system
 793    header, 2 for a sytem header that needs to be extern "C" protected,
 794    and zero otherwise.  */
 795 void
 796 _cpp_do_file_change (pfile, reason, to_file, file_line, sysp)
 797      cpp_reader *pfile;
 798      enum lc_reason reason;
 799      const char *to_file;
 800      unsigned int file_line;
 801      unsigned int sysp;
 802 {
 803   pfile->map = add_line_map (&pfile->line_maps, reason, sysp,
 804                              pfile->line, to_file, file_line);
 805
 806   if (pfile->cb.file_change)
 807     (*pfile->cb.file_change) (pfile, pfile->map);
 808 }
 809
 810 /*
 811  * Report a warning or error detected by the program we are
 812  * processing.  Use the directive's tokens in the error message.
 813  */
 814
 815 static void
 816 do_diagnostic (pfile, code, print_dir)
 817      cpp_reader *pfile;
 818      enum error_type code;
 819      int print_dir;
 820 {
 821   if (_cpp_begin_message (pfile, code, 0, 0))
 822     {
 823       if (print_dir)
 824         fprintf (stderr, "#%s ", pfile->directive->name);
 825       pfile->state.prevent_expansion++;
 826       cpp_output_line (pfile, stderr);
 827       pfile->state.prevent_expansion--;
 828     }
 829 }
 830
 831 static void
 832 do_error (pfile)
 833      cpp_reader *pfile;
 834 {
 835   do_diagnostic (pfile, ERROR, 1);
 836 }
 837
 838 static void
 839 do_warning (pfile)
 840      cpp_reader *pfile;
 841 {
 842   /* We want #warning diagnostics to be emitted in system headers too.  */
 843   do_diagnostic (pfile, WARNING_SYSHDR, 1);
 844 }
 845
 846 /* Report program identification.  */
 847
 848 static void
 849 do_ident (pfile)
 850      cpp_reader *pfile;
 851 {
 852   const cpp_token *str = cpp_get_token (pfile);
 853
 854   if (str->type != CPP_STRING)
 855     cpp_error (pfile, "invalid #ident directive");
 856   else if (pfile->cb.ident)
 857     (*pfile->cb.ident) (pfile, pfile->directive_line, &str->val.str);
 858
 859   check_eol (pfile);
 860 }
 861
 862 /* Lookup a PRAGMA name in a singly-linked CHAIN.  Returns the
 863    matching entry, or NULL if none is found.  The returned entry could
 864    be the start of a namespace chain, or a pragma.  */
 865 static struct pragma_entry *
 866 lookup_pragma_entry (chain, pragma)
 867      struct pragma_entry *chain;
 868      const cpp_hashnode *pragma;
 869 {
 870   while (chain && chain->pragma != pragma)
 871     chain = chain->next;
 872
 873   return chain;
 874 }
 875
 876 /* Create and insert a pragma entry for NAME at the beginning of a
 877    singly-linked CHAIN.  If handler is NULL, it is a namespace,
 878    otherwise it is a pragma and its handler.  */
 879 static struct pragma_entry *
 880 insert_pragma_entry (pfile, chain, pragma, handler)
 881      cpp_reader *pfile;
 882      struct pragma_entry **chain;
 883      const cpp_hashnode *pragma;
 884      pragma_cb handler;
 885 {
 886   struct pragma_entry *new;
 887
 888   new = (struct pragma_entry *)
 889     _cpp_aligned_alloc (pfile, sizeof (struct pragma_entry));
 890   new->pragma = pragma;
 891   if (handler)
 892     {
 893       new->is_nspace = 0;
 894       new->u.handler = handler;
 895     }
 896   else
 897     {
 898       new->is_nspace = 1;
 899       new->u.space = NULL;
 900     }
 901
 902   new->next = *chain;
 903   *chain = new;
 904   return new;
 905 }
 906
 907 /* Register a pragma NAME in namespace SPACE.  If SPACE is null, it
 908    goes in the global namespace.  HANDLER is the handler it will call,
 909    which must be non-NULL.  */
 910 void
 911 cpp_register_pragma (pfile, space, name, handler)
 912      cpp_reader *pfile;
 913      const char *space;
 914      const char *name;
 915      pragma_cb handler;
 916 {
 917   struct pragma_entry **chain = &pfile->pragmas;
 918   struct pragma_entry *entry;
 919   const cpp_hashnode *node;
 920
 921   if (!handler)
 922     abort ();
 923
 924   if (space)
 925     {
 926       node = cpp_lookup (pfile, U space, strlen (space));
 927       entry = lookup_pragma_entry (*chain, node);
 928       if (!entry)
 929         entry = insert_pragma_entry (pfile, chain, node, NULL);
 930       else if (!entry->is_nspace)
 931         goto clash;
 932       chain = &entry->u.space;
 933     }
 934
 935   /* Check for duplicates.  */
 936   node = cpp_lookup (pfile, U name, strlen (name));
 937   entry = lookup_pragma_entry (*chain, node);
 938   if (entry)
 939     {
 940       if (entry->is_nspace)
 941         clash:
 942         cpp_ice (pfile,
 943                  "registering \"%s\" as both a pragma and a pragma namespace",
 944                  NODE_NAME (node));
 945       else if (space)
 946         cpp_ice (pfile, "#pragma %s %s is already registered", space, name);
 947       else
 948         cpp_ice (pfile, "#pragma %s is already registered", name);
 949     }
 950   else
 951     insert_pragma_entry (pfile, chain, node, handler);
 952 }
 953
 954 /* Register the pragmas the preprocessor itself handles.  */
 955 void
 956 _cpp_init_internal_pragmas (pfile)
 957      cpp_reader *pfile;
 958 {
 959   /* Pragmas in the global namespace.  */
 960   cpp_register_pragma (pfile, 0, "poison", do_pragma_poison);
 961   cpp_register_pragma (pfile, 0, "once", do_pragma_once);
 962
 963   /* New GCC-specific pragmas should be put in the GCC namespace.  */
 964   cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
 965   cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
 966   cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
 967 }
 968
 969 /* Pragmata handling.  We handle some, and pass the rest on to the
 970    front end.  C99 defines three pragmas and says that no macro
 971    expansion is to be performed on them; whether or not macro
 972    expansion happens for other pragmas is implementation defined.
 973    This implementation never macro-expands the text after #pragma.  */
 974 static void
 975 do_pragma (pfile)
 976      cpp_reader *pfile;
 977 {
 978   const struct pragma_entry *p = NULL;
 979   const cpp_token *token;
 980   unsigned int count = 1;
 981
 982   pfile->state.prevent_expansion++;
 983
 984   token = cpp_get_token (pfile);
 985   if (token->type == CPP_NAME)
 986     {
 987       p = lookup_pragma_entry (pfile->pragmas, token->val.node);
 988       if (p && p->is_nspace)
 989         {
 990           count = 2;
 991           token = cpp_get_token (pfile);
 992           if (token->type == CPP_NAME)
 993             p = lookup_pragma_entry (p->u.space, token->val.node);
 994           else
 995             p = NULL;
 996         }
 997     }
 998
 999   /* FIXME.  This is an awful kludge to get the front ends to update
1000      their notion of line number for diagnostic purposes.  The line
1001      number should be passed to the handler and they should do it
1002      themselves.  Stand-alone CPP must ignore us, otherwise it will
1003      prefix the directive with spaces, hence the 1.  Ugh.  */
1004   if (pfile->cb.line_change)
1005     (*pfile->cb.line_change)(pfile, token, 1);
1006
1007   if (p)
1008     (*p->u.handler) (pfile);
1009   else if (pfile->cb.def_pragma)
1010     {
1011       _cpp_backup_tokens (pfile, count);
1012       (*pfile->cb.def_pragma) (pfile, pfile->directive_line);
1013     }
1014
1015   pfile->state.prevent_expansion--;
1016 }
1017
1018 static void
1019 do_pragma_once (pfile)
1020      cpp_reader *pfile;
1021 {
1022   cpp_warning (pfile, "#pragma once is obsolete");
1023
1024   if (pfile->buffer->prev == NULL)
1025     cpp_warning (pfile, "#pragma once in main file");
1026   else
1027     _cpp_never_reread (pfile->buffer->inc);
1028
1029   check_eol (pfile);
1030 }
1031
1032 static void
1033 do_pragma_poison (pfile)
1034      cpp_reader *pfile;
1035 {
1036   /* Poison these symbols so that all subsequent usage produces an
1037      error message.  */
1038   const cpp_token *tok;
1039   cpp_hashnode *hp;
1040
1041   pfile->state.poisoned_ok = 1;
1042   for (;;)
1043     {
1044       tok = _cpp_lex_token (pfile);
1045       if (tok->type == CPP_EOF)
1046         break;
1047       if (tok->type != CPP_NAME)
1048         {
1049           cpp_error (pfile, "invalid #pragma GCC poison directive");
1050           break;
1051         }
1052
1053       hp = tok->val.node;
1054       if (hp->flags & NODE_POISONED)
1055         continue;
1056
1057       if (hp->type == NT_MACRO)
1058         cpp_warning (pfile, "poisoning existing macro \"%s\"", NODE_NAME (hp));
1059       _cpp_free_definition (hp);
1060       hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1061     }
1062   pfile->state.poisoned_ok = 0;
1063 }
1064
1065 /* Mark the current header as a system header.  This will suppress
1066    some categories of warnings (notably those from -pedantic).  It is
1067    intended for use in system libraries that cannot be implemented in
1068    conforming C, but cannot be certain that their headers appear in a
1069    system include directory.  To prevent abuse, it is rejected in the
1070    primary source file.  */
1071 static void
1072 do_pragma_system_header (pfile)
1073      cpp_reader *pfile;
1074 {
1075   cpp_buffer *buffer = pfile->buffer;
1076
1077   if (buffer->prev == 0)
1078     cpp_warning (pfile, "#pragma system_header ignored outside include file");
1079   else
1080     {
1081       check_eol (pfile);
1082       skip_rest_of_line (pfile);
1083       cpp_make_system_header (pfile, 1, 0);
1084     }
1085 }
1086
1087 /* Check the modified date of the current include file against a specified
1088    file. Issue a diagnostic, if the specified file is newer. We use this to
1089    determine if a fixed header should be refixed.  */
1090 static void
1091 do_pragma_dependency (pfile)
1092      cpp_reader *pfile;
1093 {
1094   const cpp_token *header;
1095   int ordering;
1096
1097   header = parse_include (pfile);
1098   if (!header)
1099     return;
1100
1101   ordering = _cpp_compare_file_date (pfile, header);
1102   if (ordering < 0)
1103     cpp_warning (pfile, "cannot find source %s",
1104                  cpp_token_as_text (pfile, header));
1105   else if (ordering > 0)
1106     {
1107       cpp_warning (pfile, "current file is older than %s",
1108                    cpp_token_as_text (pfile, header));
1109       if (cpp_get_token (pfile)->type != CPP_EOF)
1110         {
1111           _cpp_backup_tokens (pfile, 1);
1112           do_diagnostic (pfile, WARNING, 0);
1113         }
1114     }
1115 }
1116
1117 /* Get a token but skip padding.  */
1118 static const cpp_token *
1119 get_token_no_padding (pfile)
1120      cpp_reader *pfile;
1121 {
1122   for (;;)
1123     {
1124       const cpp_token *result = cpp_get_token (pfile);
1125       if (result->type != CPP_PADDING)
1126         return result;
1127     }
1128 }
1129
1130 /* Check syntax is "(string-literal)".  Returns the string on success,
1131    or NULL on failure.  */
1132 static const cpp_token *
1133 get__Pragma_string (pfile)
1134      cpp_reader *pfile;
1135 {
1136   const cpp_token *string;
1137
1138   if (get_token_no_padding (pfile)->type != CPP_OPEN_PAREN)
1139     return NULL;
1140
1141   string = get_token_no_padding (pfile);
1142   if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1143     return NULL;
1144
1145   if (get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN)
1146     return NULL;
1147
1148   return string;
1149 }
1150
1151 /* Destringize IN into a temporary buffer, by removing the first \ of
1152    \" and \\ sequences, and process the result as a #pragma directive.  */
1153 static void
1154 destringize_and_run (pfile, in)
1155      cpp_reader *pfile;
1156      const cpp_string *in;
1157 {
1158   const unsigned char *src, *limit;
1159   char *dest, *result;
1160
1161   dest = result = alloca (in->len);
1162   for (src = in->text, limit = src + in->len; src < limit;)
1163     {
1164       /* We know there is a character following the backslash.  */
1165       if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1166         src++;
1167       *dest++ = *src++;
1168     }
1169
1170   run_directive (pfile, T_PRAGMA, result, dest - result);
1171 }
1172
1173 /* Handle the _Pragma operator.  */
1174 void
1175 _cpp_do__Pragma (pfile)
1176      cpp_reader *pfile;
1177 {
1178   const cpp_token *string = get__Pragma_string (pfile);
1179
1180   if (!string)
1181     cpp_error (pfile, "_Pragma takes a parenthesized string literal");
1182   else
1183     {
1184       /* Ideally, we'd like
1185                         token1 _Pragma ("foo") token2
1186          to be output as
1187                         token1
1188                         # 7 "file.c"
1189                         #pragma foo
1190                         # 7 "file.c"
1191                                                token2
1192          Getting these correct line markers is a little tricky.  */
1193
1194       unsigned int orig_line = pfile->line;
1195       destringize_and_run (pfile, &string->val.str);
1196       pfile->line = orig_line;
1197       pfile->buffer->saved_flags = BOL;
1198     }
1199 }
1200
1201 /* Just ignore #sccs, on systems where we define it at all.  */
1202 #ifdef SCCS_DIRECTIVE
1203 static void
1204 do_sccs (pfile)
1205      cpp_reader *pfile ATTRIBUTE_UNUSED;
1206 {
1207 }
1208 #endif
1209
1210 static void
1211 do_ifdef (pfile)
1212      cpp_reader *pfile;
1213 {
1214   int skip = 1;
1215
1216   if (! pfile->state.skipping)
1217     {
1218       const cpp_hashnode *node = lex_macro_node (pfile);
1219
1220       if (node)
1221         skip = node->type != NT_MACRO;
1222
1223       if (node)
1224         check_eol (pfile);
1225     }
1226
1227   push_conditional (pfile, skip, T_IFDEF, 0);
1228 }
1229
1230 static void
1231 do_ifndef (pfile)
1232      cpp_reader *pfile;
1233 {
1234   int skip = 1;
1235   const cpp_hashnode *node = 0;
1236
1237   if (! pfile->state.skipping)
1238     {
1239       node = lex_macro_node (pfile);
1240       if (node)
1241         skip = node->type == NT_MACRO;
1242
1243       if (node)
1244         check_eol (pfile);
1245     }
1246
1247   push_conditional (pfile, skip, T_IFNDEF, node);
1248 }
1249
1250 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1251    pfile->mi_ind_cmacro so we can handle multiple-include
1252    optimisations.  If macro expansion occurs in the expression, we
1253    cannot treat it as a controlling conditional, since the expansion
1254    could change in the future.  That is handled by cpp_get_token.  */
1255
1256 static void
1257 do_if (pfile)
1258      cpp_reader *pfile;
1259 {
1260   int skip = 1;
1261
1262   if (! pfile->state.skipping)
1263     skip = _cpp_parse_expr (pfile) == 0;
1264
1265   push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
1266 }
1267
1268 /* Flip skipping state if appropriate and continue without changing
1269    if_stack; this is so that the error message for missing #endif's
1270    etc. will point to the original #if.  */
1271
1272 static void
1273 do_else (pfile)
1274      cpp_reader *pfile;
1275 {
1276   cpp_buffer *buffer = pfile->buffer;
1277   struct if_stack *ifs = buffer->if_stack;
1278
1279   if (ifs == NULL)
1280     cpp_error (pfile, "#else without #if");
1281   else
1282     {
1283       if (ifs->type == T_ELSE)
1284         {
1285           cpp_error (pfile, "#else after #else");
1286           cpp_error_with_line (pfile, ifs->line, 0,
1287                                "the conditional began here");
1288         }
1289       ifs->type = T_ELSE;
1290
1291       /* Skip any future (erroneous) #elses or #elifs.  */
1292       pfile->state.skipping = ifs->skip_elses;
1293       ifs->skip_elses = true;
1294
1295       /* Invalidate any controlling macro.  */
1296       ifs->mi_cmacro = 0;
1297
1298       /* Only check EOL if was not originally skipping.  */
1299       if (!ifs->was_skipping)
1300         check_eol (pfile);
1301     }
1302 }
1303
1304 /* handle a #elif directive by not changing if_stack either.  see the
1305    comment above do_else.  */
1306
1307 static void
1308 do_elif (pfile)
1309      cpp_reader *pfile;
1310 {
1311   cpp_buffer *buffer = pfile->buffer;
1312   struct if_stack *ifs = buffer->if_stack;
1313
1314   if (ifs == NULL)
1315     cpp_error (pfile, "#elif without #if");
1316   else
1317     {
1318       if (ifs->type == T_ELSE)
1319         {
1320           cpp_error (pfile, "#elif after #else");
1321           cpp_error_with_line (pfile, ifs->line, 0,
1322                                "the conditional began here");
1323         }
1324       ifs->type = T_ELIF;
1325
1326       /* Only evaluate this if we aren't skipping elses.  During
1327          evaluation, set skipping to false to get lexer warnings.  */
1328       if (ifs->skip_elses)
1329         pfile->state.skipping = 1;
1330       else
1331         {
1332           pfile->state.skipping = 0;
1333           pfile->state.skipping = ! _cpp_parse_expr (pfile);
1334           ifs->skip_elses = ! pfile->state.skipping;
1335         }
1336
1337       /* Invalidate any controlling macro.  */
1338       ifs->mi_cmacro = 0;
1339     }
1340 }
1341
1342 /* #endif pops the if stack and resets pfile->state.skipping.  */
1343
1344 static void
1345 do_endif (pfile)
1346      cpp_reader *pfile;
1347 {
1348   cpp_buffer *buffer = pfile->buffer;
1349   struct if_stack *ifs = buffer->if_stack;
1350
1351   if (ifs == NULL)
1352     cpp_error (pfile, "#endif without #if");
1353   else
1354     {
1355       /* Only check EOL if was not originally skipping.  */
1356       if (!ifs->was_skipping)
1357         check_eol (pfile);
1358
1359       /* If potential control macro, we go back outside again.  */
1360       if (ifs->next == 0 && ifs->mi_cmacro)
1361         {
1362           pfile->mi_valid = true;
1363           pfile->mi_cmacro = ifs->mi_cmacro;
1364         }
1365
1366       buffer->if_stack = ifs->next;
1367       pfile->state.skipping = ifs->was_skipping;
1368       obstack_free (&pfile->buffer_ob, ifs);
1369     }
1370 }
1371
1372 /* Push an if_stack entry and set pfile->state.skipping accordingly.
1373    If this is a #if or #ifndef, CMACRO is a potentially controlling
1374    macro - we need to check here that we are at the top of the file.  */
1375
1376 static void
1377 push_conditional (pfile, skip, type, cmacro)
1378      cpp_reader *pfile;
1379      int skip;
1380      int type;
1381      const cpp_hashnode *cmacro;
1382 {
1383   struct if_stack *ifs;
1384   cpp_buffer *buffer = pfile->buffer;
1385
1386   ifs = xobnew (&pfile->buffer_ob, struct if_stack);
1387   ifs->line = pfile->directive_line;
1388   ifs->next = buffer->if_stack;
1389   ifs->skip_elses = pfile->state.skipping || !skip;
1390   ifs->was_skipping = pfile->state.skipping;
1391   ifs->type = type;
1392   /* This condition is effectively a test for top-of-file.  */
1393   if (pfile->mi_valid && pfile->mi_cmacro == 0)
1394     ifs->mi_cmacro = cmacro;
1395   else
1396     ifs->mi_cmacro = 0;
1397
1398   pfile->state.skipping = skip;
1399   buffer->if_stack = ifs;
1400 }
1401
1402 /* Read the tokens of the answer into the macro pool.  Only commit the
1403    memory if we intend it as permanent storage, i.e. the #assert case.
1404    Returns 0 on success.  */
1405
1406 static int
1407 parse_answer (pfile, answerp, type)
1408      cpp_reader *pfile;
1409      struct answer **answerp;
1410      int type;
1411 {
1412   const cpp_token *paren;
1413   struct answer *answer;
1414   unsigned int acount;
1415
1416   /* In a conditional, it is legal to not have an open paren.  We
1417      should save the following token in this case.  */
1418   paren = cpp_get_token (pfile);
1419
1420   /* If not a paren, see if we're OK.  */
1421   if (paren->type != CPP_OPEN_PAREN)
1422     {
1423       /* In a conditional no answer is a test for any answer.  It
1424          could be followed by any token.  */
1425       if (type == T_IF)
1426         {
1427           _cpp_backup_tokens (pfile, 1);
1428           return 0;
1429         }
1430
1431       /* #unassert with no answer is valid - it removes all answers.  */
1432       if (type == T_UNASSERT && paren->type == CPP_EOF)
1433         return 0;
1434
1435       cpp_error (pfile, "missing '(' after predicate");
1436       return 1;
1437     }
1438
1439   for (acount = 0;; acount++)
1440     {
1441       size_t room_needed;
1442       const cpp_token *token = cpp_get_token (pfile);
1443       cpp_token *dest;
1444
1445       if (token->type == CPP_CLOSE_PAREN)
1446         break;
1447
1448       if (token->type == CPP_EOF)
1449         {
1450           cpp_error (pfile, "missing ')' to complete answer");
1451           return 1;
1452         }
1453
1454       /* struct answer includes the space for one token.  */
1455       room_needed = (sizeof (struct answer) + acount * sizeof (cpp_token));
1456
1457       if (BUFF_ROOM (pfile->a_buff) < room_needed)
1458         _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (struct answer));
1459
1460       dest = &((struct answer *) BUFF_FRONT (pfile->a_buff))->first[acount];
1461       *dest = *token;
1462
1463       /* Drop whitespace at start, for answer equivalence purposes.  */
1464       if (acount == 0)
1465         dest->flags &= ~PREV_WHITE;
1466     }
1467
1468   if (acount == 0)
1469     {
1470       cpp_error (pfile, "predicate's answer is empty");
1471       return 1;
1472     }
1473
1474   answer = (struct answer *) BUFF_FRONT (pfile->a_buff);
1475   answer->count = acount;
1476   answer->next = NULL;
1477   *answerp = answer;
1478
1479   return 0;
1480 }
1481
1482 /* Parses an assertion, returning a pointer to the hash node of the
1483    predicate, or 0 on error.  If an answer was supplied, it is placed
1484    in ANSWERP, otherwise it is set to 0.  */
1485 static cpp_hashnode *
1486 parse_assertion (pfile, answerp, type)
1487      cpp_reader *pfile;
1488      struct answer **answerp;
1489      int type;
1490 {
1491   cpp_hashnode *result = 0;
1492   const cpp_token *predicate;
1493
1494   /* We don't expand predicates or answers.  */
1495   pfile->state.prevent_expansion++;
1496
1497   *answerp = 0;
1498   predicate = cpp_get_token (pfile);
1499   if (predicate->type == CPP_EOF)
1500     cpp_error (pfile, "assertion without predicate");
1501   else if (predicate->type != CPP_NAME)
1502     cpp_error (pfile, "predicate must be an identifier");
1503   else if (parse_answer (pfile, answerp, type) == 0)
1504     {
1505       unsigned int len = NODE_LEN (predicate->val.node);
1506       unsigned char *sym = alloca (len + 1);
1507
1508       /* Prefix '#' to get it out of macro namespace.  */
1509       sym[0] = '#';
1510       memcpy (sym + 1, NODE_NAME (predicate->val.node), len);
1511       result = cpp_lookup (pfile, sym, len + 1);
1512     }
1513
1514   pfile->state.prevent_expansion--;
1515   return result;
1516 }
1517
1518 /* Returns a pointer to the pointer to the answer in the answer chain,
1519    or a pointer to NULL if the answer is not in the chain.  */
1520 static struct answer **
1521 find_answer (node, candidate)
1522      cpp_hashnode *node;
1523      const struct answer *candidate;
1524 {
1525   unsigned int i;
1526   struct answer **result;
1527
1528   for (result = &node->value.answers; *result; result = &(*result)->next)
1529     {
1530       struct answer *answer = *result;
1531
1532       if (answer->count == candidate->count)
1533         {
1534           for (i = 0; i < answer->count; i++)
1535             if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1536               break;
1537
1538           if (i == answer->count)
1539             break;
1540         }
1541     }
1542
1543   return result;
1544 }
1545
1546 /* Test an assertion within a preprocessor conditional.  Returns
1547    non-zero on failure, zero on success.  On success, the result of
1548    the test is written into VALUE.  */
1549 int
1550 _cpp_test_assertion (pfile, value)
1551      cpp_reader *pfile;
1552      int *value;
1553 {
1554   struct answer *answer;
1555   cpp_hashnode *node;
1556
1557   node = parse_assertion (pfile, &answer, T_IF);
1558   if (node)
1559     *value = (node->type == NT_ASSERTION &&
1560               (answer == 0 || *find_answer (node, answer) != 0));
1561
1562   /* We don't commit the memory for the answer - it's temporary only.  */
1563   return node == 0;
1564 }
1565
1566 static void
1567 do_assert (pfile)
1568      cpp_reader *pfile;
1569 {
1570   struct answer *new_answer;
1571   cpp_hashnode *node;
1572
1573   node = parse_assertion (pfile, &new_answer, T_ASSERT);
1574   if (node)
1575     {
1576       /* Place the new answer in the answer list.  First check there
1577          is not a duplicate.  */
1578       new_answer->next = 0;
1579       if (node->type == NT_ASSERTION)
1580         {
1581           if (*find_answer (node, new_answer))
1582             {
1583               cpp_warning (pfile, "\"%s\" re-asserted", NODE_NAME (node) + 1);
1584               return;
1585             }
1586           new_answer->next = node->value.answers;
1587         }
1588
1589       node->type = NT_ASSERTION;
1590       node->value.answers = new_answer;
1591       BUFF_FRONT (pfile->a_buff) += (sizeof (struct answer)
1592                                      + (new_answer->count - 1)
1593                                      * sizeof (cpp_token));
1594       check_eol (pfile);
1595     }
1596 }
1597
1598 static void
1599 do_unassert (pfile)
1600      cpp_reader *pfile;
1601 {
1602   cpp_hashnode *node;
1603   struct answer *answer;
1604
1605   node = parse_assertion (pfile, &answer, T_UNASSERT);
1606   /* It isn't an error to #unassert something that isn't asserted.  */
1607   if (node && node->type == NT_ASSERTION)
1608     {
1609       if (answer)
1610         {
1611           struct answer **p = find_answer (node, answer), *temp;
1612
1613           /* Remove the answer from the list.  */
1614           temp = *p;
1615           if (temp)
1616             *p = temp->next;
1617
1618           /* Did we free the last answer?  */
1619           if (node->value.answers == 0)
1620             node->type = NT_VOID;
1621
1622           check_eol (pfile);
1623         }
1624       else
1625         _cpp_free_definition (node);
1626     }
1627
1628   /* We don't commit the memory for the answer - it's temporary only.  */
1629 }
1630
1631 /* These are for -D, -U, -A.  */
1632
1633 /* Process the string STR as if it appeared as the body of a #define.
1634    If STR is just an identifier, define it with value 1.
1635    If STR has anything after the identifier, then it should
1636    be identifier=definition.  */
1637
1638 void
1639 cpp_define (pfile, str)
1640      cpp_reader *pfile;
1641      const char *str;
1642 {
1643   char *buf, *p;
1644   size_t count;
1645
1646   /* Copy the entire option so we can modify it.
1647      Change the first "=" in the string to a space.  If there is none,
1648      tack " 1" on the end.  */
1649
1650   /* Length including the null.  */
1651   count = strlen (str);
1652   buf = (char *) alloca (count + 2);
1653   memcpy (buf, str, count);
1654
1655   p = strchr (str, '=');
1656   if (p)
1657     buf[p - str] = ' ';
1658   else
1659     {
1660       buf[count++] = ' ';
1661       buf[count++] = '1';
1662     }
1663
1664   run_directive (pfile, T_DEFINE, buf, count);
1665 }
1666
1667 /* Slight variant of the above for use by initialize_builtins.  */
1668 void
1669 _cpp_define_builtin (pfile, str)
1670      cpp_reader *pfile;
1671      const char *str;
1672 {
1673   run_directive (pfile, T_DEFINE, str, strlen (str));
1674 }
1675
1676 /* Process MACRO as if it appeared as the body of an #undef.  */
1677 void
1678 cpp_undef (pfile, macro)
1679      cpp_reader *pfile;
1680      const char *macro;
1681 {
1682   run_directive (pfile, T_UNDEF, macro, strlen (macro));
1683 }
1684
1685 /* Process the string STR as if it appeared as the body of a #assert.  */
1686 void
1687 cpp_assert (pfile, str)
1688      cpp_reader *pfile;
1689      const char *str;
1690 {
1691   handle_assertion (pfile, str, T_ASSERT);
1692 }
1693
1694 /* Process STR as if it appeared as the body of an #unassert.  */
1695 void
1696 cpp_unassert (pfile, str)
1697      cpp_reader *pfile;
1698      const char *str;
1699 {
1700   handle_assertion (pfile, str, T_UNASSERT);
1701 }
1702
1703 /* Common code for cpp_assert (-A) and cpp_unassert (-A-).  */
1704 static void
1705 handle_assertion (pfile, str, type)
1706      cpp_reader *pfile;
1707      const char *str;
1708      int type;
1709 {
1710   size_t count = strlen (str);
1711   const char *p = strchr (str, '=');
1712
1713   if (p)
1714     {
1715       /* Copy the entire option so we can modify it.  Change the first
1716          "=" in the string to a '(', and tack a ')' on the end.  */
1717       char *buf = (char *) alloca (count + 1);
1718
1719       memcpy (buf, str, count);
1720       buf[p - str] = '(';
1721       buf[count++] = ')';
1722       str = buf;
1723     }
1724
1725   run_directive (pfile, type, str, count);
1726 }
1727
1728 /* The number of errors for a given reader.  */
1729 unsigned int
1730 cpp_errors (pfile)
1731      cpp_reader *pfile;
1732 {
1733   return pfile->errors;
1734 }
1735
1736 /* The options structure.  */
1737 cpp_options *
1738 cpp_get_options (pfile)
1739      cpp_reader *pfile;
1740 {
1741   return &pfile->opts;
1742 }
1743
1744 /* The callbacks structure.  */
1745 cpp_callbacks *
1746 cpp_get_callbacks (pfile)
1747      cpp_reader *pfile;
1748 {
1749   return &pfile->cb;
1750 }
1751
1752 /* The line map set.  */
1753 const struct line_maps *
1754 cpp_get_line_maps (pfile)
1755      cpp_reader *pfile;
1756 {
1757   return &pfile->line_maps;
1758 }
1759
1760 /* Copy the given callbacks structure to our own.  */
1761 void
1762 cpp_set_callbacks (pfile, cb)
1763      cpp_reader *pfile;
1764      cpp_callbacks *cb;
1765 {
1766   pfile->cb = *cb;
1767 }
1768
1769 /* Push a new buffer on the buffer stack.  Returns the new buffer; it
1770    doesn't fail.  It does not generate a file change call back; that
1771    is the responsibility of the caller.  */
1772 cpp_buffer *
1773 cpp_push_buffer (pfile, buffer, len, from_stage3, return_at_eof)
1774      cpp_reader *pfile;
1775      const U_CHAR *buffer;
1776      size_t len;
1777      int from_stage3;
1778      int return_at_eof;
1779 {
1780   cpp_buffer *new = xobnew (&pfile->buffer_ob, cpp_buffer);
1781
1782   /* Clears, amongst other things, if_stack and mi_cmacro.  */
1783   memset (new, 0, sizeof (cpp_buffer));
1784
1785   new->line_base = new->buf = new->cur = buffer;
1786   new->rlimit = buffer + len;
1787
1788   /* No read ahead or extra char initially.  */
1789   new->read_ahead = EOF;
1790   new->extra_char = EOF;
1791   new->from_stage3 = from_stage3;
1792   new->prev = pfile->buffer;
1793   new->return_at_eof = return_at_eof;
1794   new->saved_flags = BOL;
1795
1796   pfile->buffer = new;
1797
1798   return new;
1799 }
1800
1801 /* If called from do_line, pops a single buffer.  Otherwise pops all
1802    buffers until a real file is reached.  Generates appropriate
1803    call-backs.  */
1804 void
1805 _cpp_pop_buffer (pfile)
1806      cpp_reader *pfile;
1807 {
1808   cpp_buffer *buffer = pfile->buffer;
1809   struct if_stack *ifs;
1810
1811   /* Walk back up the conditional stack till we reach its level at
1812      entry to this file, issuing error messages.  */
1813   for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
1814     cpp_error_with_line (pfile, ifs->line, 0,
1815                          "unterminated #%s", dtable[ifs->type].name);
1816
1817   /* In case of a missing #endif.  */
1818   pfile->state.skipping = 0;
1819
1820   /* Update the reader's buffer before _cpp_do_file_change.  */
1821   pfile->buffer = buffer->prev;
1822
1823   if (buffer->inc)
1824     _cpp_pop_file_buffer (pfile, buffer->inc);
1825
1826   obstack_free (&pfile->buffer_ob, buffer);
1827 }
1828
1829 void
1830 _cpp_init_directives (pfile)
1831      cpp_reader *pfile;
1832 {
1833   unsigned int i;
1834   cpp_hashnode *node;
1835
1836   /* Register the directives.  */
1837   for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
1838     {
1839       node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
1840       node->directive_index = i + 1;
1841     }
1842 }