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