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