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