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       if (pfile->cb.line_change)
1168         (*pfile->cb.line_change) (pfile, pfile->cur_token, false);
1169
1170     }
1171   else if (pfile->cb.def_pragma)
1172     {
1173       _cpp_backup_tokens (pfile, count);
1174       pfile->cb.def_pragma (pfile, pfile->directive_line);
1175     }
1176
1177   pfile->state.prevent_expansion--;
1178 }
1179
1180 /* Handle #pragma once.  */
1181 static void
1182 do_pragma_once (cpp_reader *pfile)
1183 {
1184   if (pfile->buffer->prev == NULL)
1185     cpp_error (pfile, CPP_DL_WARNING, "#pragma once in main file");
1186
1187   check_eol (pfile);
1188   _cpp_mark_file_once_only (pfile, pfile->buffer->file);
1189 }
1190
1191 /* Handle #pragma GCC poison, to poison one or more identifiers so
1192    that the lexer produces a hard error for each subsequent usage.  */
1193 static void
1194 do_pragma_poison (cpp_reader *pfile)
1195 {
1196   const cpp_token *tok;
1197   cpp_hashnode *hp;
1198
1199   pfile->state.poisoned_ok = 1;
1200   for (;;)
1201     {
1202       tok = _cpp_lex_token (pfile);
1203       if (tok->type == CPP_EOF)
1204         break;
1205       if (tok->type != CPP_NAME)
1206         {
1207           cpp_error (pfile, CPP_DL_ERROR,
1208                      "invalid #pragma GCC poison directive");
1209           break;
1210         }
1211
1212       hp = tok->val.node;
1213       if (hp->flags & NODE_POISONED)
1214         continue;
1215
1216       if (hp->type == NT_MACRO)
1217         cpp_error (pfile, CPP_DL_WARNING, "poisoning existing macro \"%s\"",
1218                    NODE_NAME (hp));
1219       _cpp_free_definition (hp);
1220       hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1221     }
1222   pfile->state.poisoned_ok = 0;
1223 }
1224
1225 /* Mark the current header as a system header.  This will suppress
1226    some categories of warnings (notably those from -pedantic).  It is
1227    intended for use in system libraries that cannot be implemented in
1228    conforming C, but cannot be certain that their headers appear in a
1229    system include directory.  To prevent abuse, it is rejected in the
1230    primary source file.  */
1231 static void
1232 do_pragma_system_header (cpp_reader *pfile)
1233 {
1234   cpp_buffer *buffer = pfile->buffer;
1235
1236   if (buffer->prev == 0)
1237     cpp_error (pfile, CPP_DL_WARNING,
1238                "#pragma system_header ignored outside include file");
1239   else
1240     {
1241       check_eol (pfile);
1242       skip_rest_of_line (pfile);
1243       cpp_make_system_header (pfile, 1, 0);
1244     }
1245 }
1246
1247 /* Check the modified date of the current include file against a specified
1248    file. Issue a diagnostic, if the specified file is newer. We use this to
1249    determine if a fixed header should be refixed.  */
1250 static void
1251 do_pragma_dependency (cpp_reader *pfile)
1252 {
1253   const char *fname;
1254   int angle_brackets, ordering;
1255
1256   fname = parse_include (pfile, &angle_brackets);
1257   if (!fname)
1258     return;
1259
1260   ordering = _cpp_compare_file_date (pfile, fname, angle_brackets);
1261   if (ordering < 0)
1262     cpp_error (pfile, CPP_DL_WARNING, "cannot find source file %s", fname);
1263   else if (ordering > 0)
1264     {
1265       cpp_error (pfile, CPP_DL_WARNING,
1266                  "current file is older than %s", fname);
1267       if (cpp_get_token (pfile)->type != CPP_EOF)
1268         {
1269           _cpp_backup_tokens (pfile, 1);
1270           do_diagnostic (pfile, CPP_DL_WARNING, 0);
1271         }
1272     }
1273
1274   free ((void *) fname);
1275 }
1276
1277 /* Get a token but skip padding.  */
1278 static const cpp_token *
1279 get_token_no_padding (cpp_reader *pfile)
1280 {
1281   for (;;)
1282     {
1283       const cpp_token *result = cpp_get_token (pfile);
1284       if (result->type != CPP_PADDING)
1285         return result;
1286     }
1287 }
1288
1289 /* Check syntax is "(string-literal)".  Returns the string on success,
1290    or NULL on failure.  */
1291 static const cpp_token *
1292 get__Pragma_string (cpp_reader *pfile)
1293 {
1294   const cpp_token *string;
1295
1296   if (get_token_no_padding (pfile)->type != CPP_OPEN_PAREN)
1297     return NULL;
1298
1299   string = get_token_no_padding (pfile);
1300   if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1301     return NULL;
1302
1303   if (get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN)
1304     return NULL;
1305
1306   return string;
1307 }
1308
1309 /* Destringize IN into a temporary buffer, by removing the first \ of
1310    \" and \\ sequences, and process the result as a #pragma directive.  */
1311 static void
1312 destringize_and_run (cpp_reader *pfile, const cpp_string *in)
1313 {
1314   const unsigned char *src, *limit;
1315   char *dest, *result;
1316
1317   dest = result = alloca (in->len - 1);
1318   src = in->text + 1 + (in->text[0] == 'L');
1319   limit = in->text + in->len - 1;
1320   while (src < limit)
1321     {
1322       /* We know there is a character following the backslash.  */
1323       if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1324         src++;
1325       *dest++ = *src++;
1326     }
1327   *dest = '\n';
1328
1329   /* Ugh; an awful kludge.  We are really not set up to be lexing
1330      tokens when in the middle of a macro expansion.  Use a new
1331      context to force cpp_get_token to lex, and so skip_rest_of_line
1332      doesn't go beyond the end of the text.  Also, remember the
1333      current lexing position so we can return to it later.
1334
1335      Something like line-at-a-time lexing should remove the need for
1336      this.  */
1337   {
1338     cpp_context *saved_context = pfile->context;
1339     cpp_token *saved_cur_token = pfile->cur_token;
1340     tokenrun *saved_cur_run = pfile->cur_run;
1341
1342     pfile->context = xnew (cpp_context);
1343     pfile->context->macro = 0;
1344     pfile->context->prev = 0;
1345     run_directive (pfile, T_PRAGMA, result, dest - result);
1346     free (pfile->context);
1347     pfile->context = saved_context;
1348     pfile->cur_token = saved_cur_token;
1349     pfile->cur_run = saved_cur_run;
1350   }
1351
1352   /* See above comment.  For the moment, we'd like
1353
1354      token1 _Pragma ("foo") token2
1355
1356      to be output as
1357
1358                 token1
1359                 # 7 "file.c"
1360                 #pragma foo
1361                 # 7 "file.c"
1362                                token2
1363
1364       Getting the line markers is a little tricky.  */
1365   if (pfile->cb.line_change)
1366     pfile->cb.line_change (pfile, pfile->cur_token, false);
1367 }
1368
1369 /* Handle the _Pragma operator.  */
1370 void
1371 _cpp_do__Pragma (cpp_reader *pfile)
1372 {
1373   const cpp_token *string = get__Pragma_string (pfile);
1374
1375   if (string)
1376     destringize_and_run (pfile, &string->val.str);
1377   else
1378     cpp_error (pfile, CPP_DL_ERROR,
1379                "_Pragma takes a parenthesized string literal");
1380 }
1381
1382 /* Ignore #sccs on all systems.  */
1383 static void
1384 do_sccs (cpp_reader *pfile ATTRIBUTE_UNUSED)
1385 {
1386 }
1387
1388 /* Handle #ifdef.  */
1389 static void
1390 do_ifdef (cpp_reader *pfile)
1391 {
1392   int skip = 1;
1393
1394   if (! pfile->state.skipping)
1395     {
1396       const cpp_hashnode *node = lex_macro_node (pfile);
1397
1398       if (node)
1399         {
1400           skip = node->type != NT_MACRO;
1401           _cpp_mark_macro_used (node);
1402           check_eol (pfile);
1403         }
1404     }
1405
1406   push_conditional (pfile, skip, T_IFDEF, 0);
1407 }
1408
1409 /* Handle #ifndef.  */
1410 static void
1411 do_ifndef (cpp_reader *pfile)
1412 {
1413   int skip = 1;
1414   const cpp_hashnode *node = 0;
1415
1416   if (! pfile->state.skipping)
1417     {
1418       node = lex_macro_node (pfile);
1419
1420       if (node)
1421         {
1422           skip = node->type == NT_MACRO;
1423           _cpp_mark_macro_used (node);
1424           check_eol (pfile);
1425         }
1426     }
1427
1428   push_conditional (pfile, skip, T_IFNDEF, node);
1429 }
1430
1431 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1432    pfile->mi_ind_cmacro so we can handle multiple-include
1433    optimizations.  If macro expansion occurs in the expression, we
1434    cannot treat it as a controlling conditional, since the expansion
1435    could change in the future.  That is handled by cpp_get_token.  */
1436 static void
1437 do_if (cpp_reader *pfile)
1438 {
1439   int skip = 1;
1440
1441   if (! pfile->state.skipping)
1442     skip = _cpp_parse_expr (pfile) == false;
1443
1444   push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
1445 }
1446
1447 /* Flip skipping state if appropriate and continue without changing
1448    if_stack; this is so that the error message for missing #endif's
1449    etc. will point to the original #if.  */
1450 static void
1451 do_else (cpp_reader *pfile)
1452 {
1453   cpp_buffer *buffer = pfile->buffer;
1454   struct if_stack *ifs = buffer->if_stack;
1455
1456   if (ifs == NULL)
1457     cpp_error (pfile, CPP_DL_ERROR, "#else without #if");
1458   else
1459     {
1460       if (ifs->type == T_ELSE)
1461         {
1462           cpp_error (pfile, CPP_DL_ERROR, "#else after #else");
1463           cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
1464                                "the conditional began here");
1465         }
1466       ifs->type = T_ELSE;
1467
1468       /* Skip any future (erroneous) #elses or #elifs.  */
1469       pfile->state.skipping = ifs->skip_elses;
1470       ifs->skip_elses = true;
1471
1472       /* Invalidate any controlling macro.  */
1473       ifs->mi_cmacro = 0;
1474
1475       /* Only check EOL if was not originally skipping.  */
1476       if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
1477         check_eol (pfile);
1478     }
1479 }
1480
1481 /* Handle a #elif directive by not changing if_stack either.  See the
1482    comment above do_else.  */
1483 static void
1484 do_elif (cpp_reader *pfile)
1485 {
1486   cpp_buffer *buffer = pfile->buffer;
1487   struct if_stack *ifs = buffer->if_stack;
1488
1489   if (ifs == NULL)
1490     cpp_error (pfile, CPP_DL_ERROR, "#elif without #if");
1491   else
1492     {
1493       if (ifs->type == T_ELSE)
1494         {
1495           cpp_error (pfile, CPP_DL_ERROR, "#elif after #else");
1496           cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
1497                                "the conditional began here");
1498         }
1499       ifs->type = T_ELIF;
1500
1501       /* Only evaluate this if we aren't skipping elses.  During
1502          evaluation, set skipping to false to get lexer warnings.  */
1503       if (ifs->skip_elses)
1504         pfile->state.skipping = 1;
1505       else
1506         {
1507           pfile->state.skipping = 0;
1508           pfile->state.skipping = ! _cpp_parse_expr (pfile);
1509           ifs->skip_elses = ! pfile->state.skipping;
1510         }
1511
1512       /* Invalidate any controlling macro.  */
1513       ifs->mi_cmacro = 0;
1514     }
1515 }
1516
1517 /* #endif pops the if stack and resets pfile->state.skipping.  */
1518 static void
1519 do_endif (cpp_reader *pfile)
1520 {
1521   cpp_buffer *buffer = pfile->buffer;
1522   struct if_stack *ifs = buffer->if_stack;
1523
1524   if (ifs == NULL)
1525     cpp_error (pfile, CPP_DL_ERROR, "#endif without #if");
1526   else
1527     {
1528       /* Only check EOL if was not originally skipping.  */
1529       if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
1530         check_eol (pfile);
1531
1532       /* If potential control macro, we go back outside again.  */
1533       if (ifs->next == 0 && ifs->mi_cmacro)
1534         {
1535           pfile->mi_valid = true;
1536           pfile->mi_cmacro = ifs->mi_cmacro;
1537         }
1538
1539       buffer->if_stack = ifs->next;
1540       pfile->state.skipping = ifs->was_skipping;
1541       obstack_free (&pfile->buffer_ob, ifs);
1542     }
1543 }
1544
1545 /* Push an if_stack entry for a preprocessor conditional, and set
1546    pfile->state.skipping to SKIP.  If TYPE indicates the conditional
1547    is #if or #ifndef, CMACRO is a potentially controlling macro, and
1548    we need to check here that we are at the top of the file.  */
1549 static void
1550 push_conditional (cpp_reader *pfile, int skip, int type,
1551                   const cpp_hashnode *cmacro)
1552 {
1553   struct if_stack *ifs;
1554   cpp_buffer *buffer = pfile->buffer;
1555
1556   ifs = xobnew (&pfile->buffer_ob, struct if_stack);
1557   ifs->line = pfile->directive_line;
1558   ifs->next = buffer->if_stack;
1559   ifs->skip_elses = pfile->state.skipping || !skip;
1560   ifs->was_skipping = pfile->state.skipping;
1561   ifs->type = type;
1562   /* This condition is effectively a test for top-of-file.  */
1563   if (pfile->mi_valid && pfile->mi_cmacro == 0)
1564     ifs->mi_cmacro = cmacro;
1565   else
1566     ifs->mi_cmacro = 0;
1567
1568   pfile->state.skipping = skip;
1569   buffer->if_stack = ifs;
1570 }
1571
1572 /* Read the tokens of the answer into the macro pool, in a directive
1573    of type TYPE.  Only commit the memory if we intend it as permanent
1574    storage, i.e. the #assert case.  Returns 0 on success, and sets
1575    ANSWERP to point to the answer.  */
1576 static int
1577 parse_answer (cpp_reader *pfile, struct answer **answerp, int type)
1578 {
1579   const cpp_token *paren;
1580   struct answer *answer;
1581   unsigned int acount;
1582
1583   /* In a conditional, it is legal to not have an open paren.  We
1584      should save the following token in this case.  */
1585   paren = cpp_get_token (pfile);
1586
1587   /* If not a paren, see if we're OK.  */
1588   if (paren->type != CPP_OPEN_PAREN)
1589     {
1590       /* In a conditional no answer is a test for any answer.  It
1591          could be followed by any token.  */
1592       if (type == T_IF)
1593         {
1594           _cpp_backup_tokens (pfile, 1);
1595           return 0;
1596         }
1597
1598       /* #unassert with no answer is valid - it removes all answers.  */
1599       if (type == T_UNASSERT && paren->type == CPP_EOF)
1600         return 0;
1601
1602       cpp_error (pfile, CPP_DL_ERROR, "missing '(' after predicate");
1603       return 1;
1604     }
1605
1606   for (acount = 0;; acount++)
1607     {
1608       size_t room_needed;
1609       const cpp_token *token = cpp_get_token (pfile);
1610       cpp_token *dest;
1611
1612       if (token->type == CPP_CLOSE_PAREN)
1613         break;
1614
1615       if (token->type == CPP_EOF)
1616         {
1617           cpp_error (pfile, CPP_DL_ERROR, "missing ')' to complete answer");
1618           return 1;
1619         }
1620
1621       /* struct answer includes the space for one token.  */
1622       room_needed = (sizeof (struct answer) + acount * sizeof (cpp_token));
1623
1624       if (BUFF_ROOM (pfile->a_buff) < room_needed)
1625         _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (struct answer));
1626
1627       dest = &((struct answer *) BUFF_FRONT (pfile->a_buff))->first[acount];
1628       *dest = *token;
1629
1630       /* Drop whitespace at start, for answer equivalence purposes.  */
1631       if (acount == 0)
1632         dest->flags &= ~PREV_WHITE;
1633     }
1634
1635   if (acount == 0)
1636     {
1637       cpp_error (pfile, CPP_DL_ERROR, "predicate's answer is empty");
1638       return 1;
1639     }
1640
1641   answer = (struct answer *) BUFF_FRONT (pfile->a_buff);
1642   answer->count = acount;
1643   answer->next = NULL;
1644   *answerp = answer;
1645
1646   return 0;
1647 }
1648
1649 /* Parses an assertion directive of type TYPE, returning a pointer to
1650    the hash node of the predicate, or 0 on error.  If an answer was
1651    supplied, it is placed in ANSWERP, otherwise it is set to 0.  */
1652 static cpp_hashnode *
1653 parse_assertion (cpp_reader *pfile, struct answer **answerp, int type)
1654 {
1655   cpp_hashnode *result = 0;
1656   const cpp_token *predicate;
1657
1658   /* We don't expand predicates or answers.  */
1659   pfile->state.prevent_expansion++;
1660
1661   *answerp = 0;
1662   predicate = cpp_get_token (pfile);
1663   if (predicate->type == CPP_EOF)
1664     cpp_error (pfile, CPP_DL_ERROR, "assertion without predicate");
1665   else if (predicate->type != CPP_NAME)
1666     cpp_error (pfile, CPP_DL_ERROR, "predicate must be an identifier");
1667   else if (parse_answer (pfile, answerp, type) == 0)
1668     {
1669       unsigned int len = NODE_LEN (predicate->val.node);
1670       unsigned char *sym = alloca (len + 1);
1671
1672       /* Prefix '#' to get it out of macro namespace.  */
1673       sym[0] = '#';
1674       memcpy (sym + 1, NODE_NAME (predicate->val.node), len);
1675       result = cpp_lookup (pfile, sym, len + 1);
1676     }
1677
1678   pfile->state.prevent_expansion--;
1679   return result;
1680 }
1681
1682 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
1683    or a pointer to NULL if the answer is not in the chain.  */
1684 static struct answer **
1685 find_answer (cpp_hashnode *node, const struct answer *candidate)
1686 {
1687   unsigned int i;
1688   struct answer **result;
1689
1690   for (result = &node->value.answers; *result; result = &(*result)->next)
1691     {
1692       struct answer *answer = *result;
1693
1694       if (answer->count == candidate->count)
1695         {
1696           for (i = 0; i < answer->count; i++)
1697             if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1698               break;
1699
1700           if (i == answer->count)
1701             break;
1702         }
1703     }
1704
1705   return result;
1706 }
1707
1708 /* Test an assertion within a preprocessor conditional.  Returns
1709    nonzero on failure, zero on success.  On success, the result of
1710    the test is written into VALUE, otherwise the value 0.  */
1711 int
1712 _cpp_test_assertion (cpp_reader *pfile, unsigned int *value)
1713 {
1714   struct answer *answer;
1715   cpp_hashnode *node;
1716
1717   node = parse_assertion (pfile, &answer, T_IF);
1718
1719   /* For recovery, an erroneous assertion expression is handled as a
1720      failing assertion.  */
1721   *value = 0;
1722
1723   if (node)
1724     *value = (node->type == NT_ASSERTION &&
1725               (answer == 0 || *find_answer (node, answer) != 0));
1726   else if (pfile->cur_token[-1].type == CPP_EOF)
1727     _cpp_backup_tokens (pfile, 1);
1728
1729   /* We don't commit the memory for the answer - it's temporary only.  */
1730   return node == 0;
1731 }
1732
1733 /* Handle #assert.  */
1734 static void
1735 do_assert (cpp_reader *pfile)
1736 {
1737   struct answer *new_answer;
1738   cpp_hashnode *node;
1739
1740   node = parse_assertion (pfile, &new_answer, T_ASSERT);
1741   if (node)
1742     {
1743       /* Place the new answer in the answer list.  First check there
1744          is not a duplicate.  */
1745       new_answer->next = 0;
1746       if (node->type == NT_ASSERTION)
1747         {
1748           if (*find_answer (node, new_answer))
1749             {
1750               cpp_error (pfile, CPP_DL_WARNING, "\"%s\" re-asserted",
1751                          NODE_NAME (node) + 1);
1752               return;
1753             }
1754           new_answer->next = node->value.answers;
1755         }
1756
1757       node->type = NT_ASSERTION;
1758       node->value.answers = new_answer;
1759       BUFF_FRONT (pfile->a_buff) += (sizeof (struct answer)
1760                                      + (new_answer->count - 1)
1761                                      * sizeof (cpp_token));
1762       check_eol (pfile);
1763     }
1764 }
1765
1766 /* Handle #unassert.  */
1767 static void
1768 do_unassert (cpp_reader *pfile)
1769 {
1770   cpp_hashnode *node;
1771   struct answer *answer;
1772
1773   node = parse_assertion (pfile, &answer, T_UNASSERT);
1774   /* It isn't an error to #unassert something that isn't asserted.  */
1775   if (node && node->type == NT_ASSERTION)
1776     {
1777       if (answer)
1778         {
1779           struct answer **p = find_answer (node, answer), *temp;
1780
1781           /* Remove the answer from the list.  */
1782           temp = *p;
1783           if (temp)
1784             *p = temp->next;
1785
1786           /* Did we free the last answer?  */
1787           if (node->value.answers == 0)
1788             node->type = NT_VOID;
1789
1790           check_eol (pfile);
1791         }
1792       else
1793         _cpp_free_definition (node);
1794     }
1795
1796   /* We don't commit the memory for the answer - it's temporary only.  */
1797 }
1798
1799 /* These are for -D, -U, -A.  */
1800
1801 /* Process the string STR as if it appeared as the body of a #define.
1802    If STR is just an identifier, define it with value 1.
1803    If STR has anything after the identifier, then it should
1804    be identifier=definition.  */
1805 void
1806 cpp_define (cpp_reader *pfile, const char *str)
1807 {
1808   char *buf, *p;
1809   size_t count;
1810
1811   /* Copy the entire option so we can modify it.
1812      Change the first "=" in the string to a space.  If there is none,
1813      tack " 1" on the end.  */
1814
1815   count = strlen (str);
1816   buf = alloca (count + 3);
1817   memcpy (buf, str, count);
1818
1819   p = strchr (str, '=');
1820   if (p)
1821     buf[p - str] = ' ';
1822   else
1823     {
1824       buf[count++] = ' ';
1825       buf[count++] = '1';
1826     }
1827   buf[count] = '\n';
1828
1829   run_directive (pfile, T_DEFINE, buf, count);
1830 }
1831
1832 /* Slight variant of the above for use by initialize_builtins.  */
1833 void
1834 _cpp_define_builtin (cpp_reader *pfile, const char *str)
1835 {
1836   size_t len = strlen (str);
1837   char *buf = alloca (len + 1);
1838   memcpy (buf, str, len);
1839   buf[len] = '\n';
1840   run_directive (pfile, T_DEFINE, buf, len);
1841 }
1842
1843 /* Process MACRO as if it appeared as the body of an #undef.  */
1844 void
1845 cpp_undef (cpp_reader *pfile, const char *macro)
1846 {
1847   size_t len = strlen (macro);
1848   char *buf = alloca (len + 1);
1849   memcpy (buf, macro, len);
1850   buf[len] = '\n';
1851   run_directive (pfile, T_UNDEF, buf, len);
1852 }
1853
1854 /* Process the string STR as if it appeared as the body of a #assert.  */
1855 void
1856 cpp_assert (cpp_reader *pfile, const char *str)
1857 {
1858   handle_assertion (pfile, str, T_ASSERT);
1859 }
1860
1861 /* Process STR as if it appeared as the body of an #unassert.  */
1862 void
1863 cpp_unassert (cpp_reader *pfile, const char *str)
1864 {
1865   handle_assertion (pfile, str, T_UNASSERT);
1866 }
1867
1868 /* Common code for cpp_assert (-A) and cpp_unassert (-A-).  */
1869 static void
1870 handle_assertion (cpp_reader *pfile, const char *str, int type)
1871 {
1872   size_t count = strlen (str);
1873   const char *p = strchr (str, '=');
1874
1875   /* Copy the entire option so we can modify it.  Change the first
1876      "=" in the string to a '(', and tack a ')' on the end.  */
1877   char *buf = alloca (count + 2);
1878
1879   memcpy (buf, str, count);
1880   if (p)
1881     {
1882       buf[p - str] = '(';
1883       buf[count++] = ')';
1884     }
1885   buf[count] = '\n';
1886   str = buf;
1887
1888   run_directive (pfile, type, str, count);
1889 }
1890
1891 /* The number of errors for a given reader.  */
1892 unsigned int
1893 cpp_errors (cpp_reader *pfile)
1894 {
1895   return pfile->errors;
1896 }
1897
1898 /* The options structure.  */
1899 cpp_options *
1900 cpp_get_options (cpp_reader *pfile)
1901 {
1902   return &pfile->opts;
1903 }
1904
1905 /* The callbacks structure.  */
1906 cpp_callbacks *
1907 cpp_get_callbacks (cpp_reader *pfile)
1908 {
1909   return &pfile->cb;
1910 }
1911
1912 /* Copy the given callbacks structure to our own.  */
1913 void
1914 cpp_set_callbacks (cpp_reader *pfile, cpp_callbacks *cb)
1915 {
1916   pfile->cb = *cb;
1917 }
1918
1919 /* Push a new buffer on the buffer stack.  Returns the new buffer; it
1920    doesn't fail.  It does not generate a file change call back; that
1921    is the responsibility of the caller.  */
1922 cpp_buffer *
1923 cpp_push_buffer (cpp_reader *pfile, const uchar *buffer, size_t len,
1924                  int from_stage3)
1925 {
1926   cpp_buffer *new = xobnew (&pfile->buffer_ob, cpp_buffer);
1927
1928   /* Clears, amongst other things, if_stack and mi_cmacro.  */
1929   memset (new, 0, sizeof (cpp_buffer));
1930
1931   new->next_line = new->buf = buffer;
1932   new->rlimit = buffer + len;
1933   new->from_stage3 = from_stage3;
1934   new->prev = pfile->buffer;
1935   new->need_line = true;
1936
1937   pfile->buffer = new;
1938
1939   return new;
1940 }
1941
1942 /* Pops a single buffer, with a file change call-back if appropriate.
1943    Then pushes the next -include file, if any remain.  */
1944 void
1945 _cpp_pop_buffer (cpp_reader *pfile)
1946 {
1947   cpp_buffer *buffer = pfile->buffer;
1948   struct _cpp_file *inc = buffer->file;
1949   struct if_stack *ifs;
1950
1951   /* Walk back up the conditional stack till we reach its level at
1952      entry to this file, issuing error messages.  */
1953   for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
1954     cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
1955                          "unterminated #%s", dtable[ifs->type].name);
1956
1957   /* In case of a missing #endif.  */
1958   pfile->state.skipping = 0;
1959
1960   /* _cpp_do_file_change expects pfile->buffer to be the new one.  */
1961   pfile->buffer = buffer->prev;
1962
1963   free (buffer->notes);
1964
1965   /* Free the buffer object now; we may want to push a new buffer
1966      in _cpp_push_next_include_file.  */
1967   obstack_free (&pfile->buffer_ob, buffer);
1968
1969   if (inc)
1970     {
1971       _cpp_pop_file_buffer (pfile, inc);
1972
1973       _cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
1974     }
1975 }
1976
1977 /* Enter all recognized directives in the hash table.  */
1978 void
1979 _cpp_init_directives (cpp_reader *pfile)
1980 {
1981   unsigned int i;
1982   cpp_hashnode *node;
1983
1984   for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
1985     {
1986       node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
1987       node->is_directive = 1;
1988       node->directive_index = i;
1989     }
1990 }