gcc/cpplib.c

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