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