gcc/cpplib.c

   1 /* CPP Library.
   2    Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000 Free Software Foundation, Inc.
   4    Contributed by Per Bothner, 1994-95.
   5    Based on CCCP program by Paul Rubin, June 1986
   6    Adapted to ANSI C, Richard Stallman, Jan 1987
   7
   8 This program is free software; you can redistribute it and/or modify it
   9 under the terms of the GNU General Public License as published by the
  10 Free Software Foundation; either version 2, or (at your option) any
  11 later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24
  25 #include "cpplib.h"
  26 #include "cpphash.h"
  27 #include "intl.h"
  28 #include "obstack.h"
  29 #include "symcat.h"
  30
  31 /* Stack of conditionals currently in progress
  32    (including both successful and failing conditionals).  */
  33
  34 struct if_stack
  35 {
  36   struct if_stack *next;
  37   unsigned int lineno;          /* line number where condition started */
  38   unsigned int colno;           /* and column */
  39   int was_skipping;             /* value of pfile->skipping before this if */
  40   const cpp_hashnode *cmacro;   /* macro name for #ifndef around entire file */
  41   int type;                     /* type of last directive seen in this group */
  42 };
  43
  44 /* Forward declarations.  */
  45
  46 static void validate_else       PARAMS ((cpp_reader *, const U_CHAR *));
  47 static int  parse_include       PARAMS ((cpp_reader *, const U_CHAR *, int,
  48                                          const U_CHAR **, unsigned int *,
  49                                          int *));
  50 static void push_conditional    PARAMS ((cpp_reader *, int, int,
  51                                          const cpp_hashnode *));
  52 static int  read_line_number    PARAMS ((cpp_reader *, int *));
  53 static int  strtoul_for_line    PARAMS ((const U_CHAR *, unsigned int,
  54                                          unsigned long *));
  55 static void do_diagnostic       PARAMS ((cpp_reader *, enum error_type));
  56 static const cpp_hashnode *
  57             parse_ifdef         PARAMS ((cpp_reader *, const U_CHAR *));
  58 static const cpp_hashnode *
  59             detect_if_not_defined PARAMS ((cpp_reader *));
  60 static cpp_hashnode *
  61             get_define_node     PARAMS ((cpp_reader *));
  62 static void unwind_if_stack     PARAMS ((cpp_reader *, cpp_buffer *));
  63
  64 /* This is the table of directive handlers.  It is ordered by
  65    frequency of occurrence; the numbers at the end are directive
  66    counts from all the source code I have lying around (egcs and libc
  67    CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
  68    pcmcia-cs-3.0.9).
  69
  70    The entries with a dash and a name after the count are extensions,
  71    of which all but #warning and #include_next are deprecated.  The name
  72    is where the extension appears to have come from.  */
  73
  74 /* #sccs is not always recognized.  */
  75 #ifdef SCCS_DIRECTIVE
  76 # define SCCS_ENTRY D(sccs, T_SCCS, EXTENSION, 0)
  77 #else
  78 # define SCCS_ENTRY /* nothing */
  79 #endif
  80
  81 #define DIRECTIVE_TABLE                                                 \
  82 D(define,       T_DEFINE = 0,   KANDR,     COMMENTS | IN_I)/* 270554 */ \
  83 D(include,      T_INCLUDE,      KANDR,     EXPAND | INCL)  /*  52262 */ \
  84 D(endif,        T_ENDIF,        KANDR,     COND)           /*  45855 */ \
  85 D(ifdef,        T_IFDEF,        KANDR,     COND)           /*  22000 */ \
  86 D(if,           T_IF,           KANDR,     COND | EXPAND)  /*  18162 */ \
  87 D(else,         T_ELSE,         KANDR,     COND)           /*   9863 */ \
  88 D(ifndef,       T_IFNDEF,       KANDR,     COND)           /*   9675 */ \
  89 D(undef,        T_UNDEF,        KANDR,     IN_I)           /*   4837 */ \
  90 D(line,         T_LINE,         KANDR,     EXPAND)         /*   2465 */ \
  91 D(elif,         T_ELIF,         KANDR,     COND | EXPAND)  /*    610 */ \
  92 D(error,        T_ERROR,        STDC89,    0)              /*    475 */ \
  93 D(pragma,       T_PRAGMA,       STDC89,    IN_I)           /*    195 */ \
  94 D(warning,      T_WARNING,      EXTENSION, 0)              /*     22 GNU   */ \
  95 D(include_next, T_INCLUDE_NEXT, EXTENSION, EXPAND | INCL)  /*     19 GNU   */ \
  96 D(ident,        T_IDENT,        EXTENSION, IN_I)           /*     11 SVR4  */ \
  97 D(import,       T_IMPORT,       EXTENSION, EXPAND | INCL)  /*      0 ObjC  */ \
  98 D(assert,       T_ASSERT,       EXTENSION, 0)              /*      0 SVR4  */ \
  99 D(unassert,     T_UNASSERT,     EXTENSION, 0)              /*      0 SVR4  */ \
 100 SCCS_ENTRY                                                 /*      0 SVR2? */
 101
 102 /* Use the table to generate a series of prototypes, an enum for the
 103    directive names, and an array of directive handlers.  */
 104
 105 /* The directive-processing functions are declared to return int
 106    instead of void, because some old compilers have trouble with
 107    pointers to functions returning void.  */
 108
 109 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
 110 #define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
 111 DIRECTIVE_TABLE
 112 #undef D
 113
 114 #define D(n, tag, o, f) tag,
 115 enum
 116 {
 117   DIRECTIVE_TABLE
 118   N_DIRECTIVES
 119 };
 120 #undef D
 121
 122 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
 123 #define D(name, t, origin, flags) \
 124 { CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
 125   sizeof STRINGX(name) - 1, origin, flags },
 126 static const struct directive dtable[] =
 127 {
 128 DIRECTIVE_TABLE
 129 };
 130 #undef D
 131 #undef DIRECTIVE_TABLE
 132
 133 /* Check if a token's name matches that of a known directive.  Put in
 134    this file to save exporting dtable and other unneeded information.  */
 135 const struct directive *
 136 _cpp_check_directive (pfile, token)
 137      cpp_reader *pfile;
 138      const cpp_token *token;
 139 {
 140   unsigned int i;
 141
 142   if (token->type != CPP_NAME)
 143     {
 144       if (token->type == CPP_EOF && CPP_WTRADITIONAL (pfile)
 145           && pfile->state.indented)
 146         cpp_warning (pfile, "traditional C ignores #\\n with the # indented");
 147
 148       return 0;
 149     }
 150
 151   for (i = 0; i < N_DIRECTIVES; i++)
 152     if (pfile->spec_nodes->dirs[i] == token->val.node)
 153       break;
 154
 155   if (i == N_DIRECTIVES)
 156     return 0;
 157
 158   /* We should lex headers correctly, regardless of whether we're
 159      skipping or not.  */
 160   pfile->state.angled_headers = dtable[i].flags & INCL;
 161
 162   /* If we are rescanning preprocessed input, only directives tagged
 163      with IN_I are honored, and the warnings below are suppressed.  */
 164   if (CPP_OPTION (pfile, preprocessed))
 165     {
 166       if (!dtable[i].flags & IN_I)
 167         return 0;
 168     }
 169   else
 170     {
 171       /* Traditionally, a directive is ignored unless its # is in
 172          column 1.  Therefore in code intended to work with K+R
 173          compilers, directives added by C89 must have their #
 174          indented, and directives present in traditional C must not.
 175          This is true even of directives in skipped conditional
 176          blocks.  */
 177       if (CPP_WTRADITIONAL (pfile))
 178         {
 179           if (pfile->state.indented && dtable[i].origin == KANDR)
 180             cpp_warning (pfile,
 181                          "traditional C ignores #%s with the # indented",
 182                          dtable[i].name);
 183
 184           else if (!pfile->state.indented && dtable[i].origin != KANDR)
 185             cpp_warning (pfile,
 186                  "suggest hiding #%s from traditional C with an indented #",
 187                          dtable[i].name);
 188         }
 189
 190       /* If we are skipping a failed conditional group, all non-conditional
 191          directives are ignored.  */
 192       if (pfile->skipping && !(dtable[i].flags & COND))
 193         return 0;
 194
 195       /* Issue -pedantic warnings for extended directives.   */
 196       if (CPP_PEDANTIC (pfile) && dtable[i].origin == EXTENSION)
 197         cpp_pedwarn (pfile, "ISO C does not allow #%s", dtable[i].name);
 198     }
 199
 200   /* Only flag to save comments if we process the directive.  */
 201   pfile->state.save_comments = (! CPP_OPTION (pfile, discard_comments)
 202                                 && (dtable[i].flags & COMMENTS));
 203
 204   return &dtable[i];
 205 }
 206
 207 const struct directive *
 208 _cpp_check_linemarker (pfile, token)
 209      cpp_reader *pfile;
 210      const cpp_token *token ATTRIBUTE_UNUSED;
 211 {
 212   /* # followed by a number is equivalent to #line.  Do not recognize
 213      this form in assembly language source files or skipped
 214      conditional groups.  Complain about this form if we're being
 215      pedantic, but not if this is regurgitated input (preprocessed or
 216      fed back in by the C++ frontend).  */
 217   if (pfile->skipping || CPP_OPTION (pfile, lang_asm))
 218     return 0;
 219
 220   if (CPP_PEDANTIC (pfile) && CPP_BUFFER (pfile)->inc
 221       && ! CPP_OPTION (pfile, preprocessed))
 222     cpp_pedwarn (pfile, "# followed by integer");
 223
 224   /* In -traditional mode, a directive is ignored unless its #
 225      is in column 1.  */
 226   if (pfile->state.indented && CPP_WTRADITIONAL (pfile))
 227     cpp_warning (pfile, "traditional C ignores #%s with the # indented",
 228                  dtable[T_LINE].name);
 229
 230   return &dtable[T_LINE];
 231 }
 232
 233 static cpp_hashnode *
 234 get_define_node (pfile)
 235      cpp_reader *pfile;
 236 {
 237   const cpp_token *token;
 238
 239   /* Skip any -C comments.  */
 240   while ((token = _cpp_get_token (pfile))->type == CPP_COMMENT)
 241     ;
 242
 243   /* The token immediately after #define must be an identifier.  That
 244      identifier is not allowed to be "defined".  See predefined macro
 245      names (6.10.8.4).  In C++, it is not allowed to be any of the
 246      <iso646.h> macro names (which are keywords in C++) either.  */
 247
 248   if (token->type != CPP_NAME)
 249     {
 250       if (token->type == CPP_DEFINED)
 251         cpp_error_with_line (pfile, token->line, token->col,
 252                              "\"defined\" cannot be used as a macro name");
 253       else if (token->flags & NAMED_OP)
 254         cpp_error_with_line (pfile, token->line, token->col,
 255                              "\"%s\" cannot be used as a macro name in C++",
 256                              token->val.node->name);
 257       else
 258         cpp_error_with_line (pfile, token->line, token->col,
 259                            "macro names must be identifiers");
 260       return 0;
 261     }
 262
 263   /* In Objective C, some keywords begin with '@', but general identifiers
 264      do not, and you're not allowed to #define them.  */
 265   if (token->val.node->name[0] == '@')
 266     {
 267       cpp_error_with_line (pfile, token->line, token->col,
 268                            "\"%s\" cannot be used as a macro name",
 269                            token->val.node->name);
 270       return 0;
 271     }
 272
 273   /* Check for poisoned identifiers now.  */
 274   if (token->val.node->type == T_POISON)
 275     {
 276       cpp_error_with_line (pfile, token->line, token->col,
 277                            "attempt to use poisoned \"%s\"",
 278                            token->val.node->name);
 279       return 0;
 280     }
 281
 282   return token->val.node;
 283 }
 284
 285 /* Process a #define command.  */
 286 static void
 287 do_define (pfile)
 288      cpp_reader *pfile;
 289 {
 290   cpp_hashnode *node;
 291
 292   if ((node = get_define_node (pfile)))
 293     if (_cpp_create_definition (pfile, node))
 294       if (pfile->cb.define)
 295         (*pfile->cb.define) (pfile, node);
 296 }
 297
 298 /* Remove the definition of a symbol from the symbol table.  */
 299 static void
 300 do_undef (pfile)
 301      cpp_reader *pfile;
 302 {
 303   cpp_hashnode *node = get_define_node (pfile);
 304
 305   if (_cpp_get_token (pfile)->type != CPP_EOF)
 306     cpp_pedwarn (pfile, "junk on line after #undef");
 307
 308   /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
 309      is not currently defined as a macro name.  */
 310   if (node && node->type != T_VOID)
 311     {
 312       if (pfile->cb.undef)
 313         (*pfile->cb.undef) (pfile, node);
 314
 315       if (node->type != T_MACRO)
 316         cpp_warning (pfile, "undefining \"%s\"", node->name);
 317
 318       _cpp_free_definition (node);
 319     }
 320 }
 321
 322
 323 /* Handle #include and #import.  */
 324
 325 static int
 326 parse_include (pfile, dir, trail, strp, lenp, abp)
 327      cpp_reader *pfile;
 328      const U_CHAR *dir;
 329      int trail;
 330      const U_CHAR **strp;
 331      unsigned int *lenp;
 332      int *abp;
 333 {
 334   const cpp_token *name = _cpp_get_token (pfile);
 335
 336   if (name->type != CPP_STRING && name->type != CPP_HEADER_NAME)
 337     {
 338       if (name->type == CPP_LESS)
 339         name = _cpp_glue_header_name (pfile);
 340       else
 341         {
 342           cpp_error (pfile, "#%s expects \"FILENAME\" or <FILENAME>", dir);
 343           return 1;
 344         }
 345     }
 346   if (name->val.str.len == 0)
 347     {
 348       cpp_error (pfile, "empty file name in #%s", dir);
 349       return 1;
 350     }
 351
 352   if (!trail && _cpp_get_token (pfile)->type != CPP_EOF)
 353     cpp_error (pfile, "junk at end of #%s", dir);
 354
 355   *lenp = name->val.str.len;
 356   *strp = name->val.str.text;
 357   *abp = (name->type == CPP_HEADER_NAME);
 358
 359   if (pfile->cb.include)
 360     (*pfile->cb.include) (pfile, dir, *strp, *lenp, *abp);
 361   return 0;
 362 }
 363
 364 static void
 365 do_include (pfile)
 366      cpp_reader *pfile;
 367 {
 368   unsigned int len;
 369   const U_CHAR *str;
 370   int ab;
 371
 372   if (parse_include (pfile, dtable[T_INCLUDE].name, 0, &str, &len, &ab))
 373     return;
 374
 375   _cpp_execute_include (pfile, str, len, 0, 0, ab);
 376 }
 377
 378 static void
 379 do_import (pfile)
 380      cpp_reader *pfile;
 381 {
 382   unsigned int len;
 383   const U_CHAR *str;
 384   int ab;
 385
 386   if (!pfile->import_warning && CPP_OPTION (pfile, warn_import))
 387     {
 388       pfile->import_warning = 1;
 389       cpp_warning (pfile,
 390            "#import is obsolete, use an #ifndef wrapper in the header file");
 391     }
 392
 393   if (parse_include (pfile, dtable[T_IMPORT].name, 0, &str, &len, &ab))
 394     return;
 395
 396   _cpp_execute_include (pfile, str, len, 1, 0, ab);
 397 }
 398
 399 static void
 400 do_include_next (pfile)
 401      cpp_reader *pfile;
 402 {
 403   unsigned int len;
 404   const U_CHAR *str;
 405   struct file_name_list *search_start = 0;
 406   int ab;
 407
 408   if (parse_include (pfile, dtable[T_INCLUDE_NEXT].name, 0, &str, &len, &ab))
 409     return;
 410
 411   /* For #include_next, skip in the search path past the dir in which
 412      the current file was found.  If this is the last directory in the
 413      search path, don't include anything.  If the current file was
 414      specified with an absolute path, use the normal search logic.  If
 415      this is the primary source file, use the normal search logic and
 416      generate a warning.  */
 417   if (CPP_PREV_BUFFER (CPP_BUFFER (pfile)))
 418     {
 419       if (CPP_BUFFER (pfile)->inc->foundhere)
 420         {
 421           search_start = CPP_BUFFER (pfile)->inc->foundhere->next;
 422           if (!search_start)
 423             return;
 424         }
 425     }
 426   else
 427     cpp_warning (pfile, "#include_next in primary source file");
 428
 429   _cpp_execute_include (pfile, str, len, 0, search_start, ab);
 430 }
 431
 432 /* Subroutine of do_line.  Read next token from PFILE without adding it to
 433    the output buffer.  If it is a number between 1 and 4, store it in *NUM
 434    and return 1; otherwise, return 0 and complain if we aren't at the end
 435    of the directive.  */
 436
 437 static int
 438 read_line_number (pfile, num)
 439      cpp_reader *pfile;
 440      int *num;
 441 {
 442   const cpp_token *tok = _cpp_get_token (pfile);
 443   enum cpp_ttype type = tok->type;
 444   const U_CHAR *p = tok->val.str.text;
 445   unsigned int len = tok->val.str.len;
 446
 447   if (type == CPP_NUMBER && len == 1 && p[0] >= '1' && p[0] <= '4')
 448     {
 449       *num = p[0] - '0';
 450       return 1;
 451     }
 452   else
 453     {
 454       if (type != CPP_EOF)
 455         cpp_error (pfile, "invalid format #line");
 456       return 0;
 457     }
 458 }
 459
 460 /* Another subroutine of do_line.  Convert a number in STR, of length
 461    LEN, to binary; store it in NUMP, and return 0 if the number was
 462    well-formed, 1 if not.  Temporary, hopefully.  */
 463 static int
 464 strtoul_for_line (str, len, nump)
 465      const U_CHAR *str;
 466      unsigned int len;
 467      unsigned long *nump;
 468 {
 469   unsigned long reg = 0;
 470   U_CHAR c;
 471   while (len--)
 472     {
 473       c = *str++;
 474       if (!ISDIGIT (c))
 475         return 1;
 476       reg *= 10;
 477       reg += c - '0';
 478     }
 479   *nump = reg;
 480   return 0;
 481 }
 482
 483 /* Interpret #line command.
 484    Note that the filename string (if any) is treated as if it were an
 485    include filename.  That means no escape handling.  */
 486
 487 static void
 488 do_line (pfile)
 489      cpp_reader *pfile;
 490 {
 491   cpp_buffer *ip = CPP_BUFFER (pfile);
 492   unsigned long new_lineno, old_lineno;
 493   /* C99 raised the minimum limit on #line numbers.  */
 494   unsigned int cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
 495   int action_number = 0;
 496   int enter = 0, leave = 0, rename = 0;
 497   enum cpp_ttype type;
 498   const U_CHAR *str;
 499   char *fname;
 500   unsigned int len;
 501   const cpp_token *tok;
 502
 503   tok = _cpp_get_token (pfile);
 504   type = tok->type;
 505   str = tok->val.str.text;
 506   len = tok->val.str.len;
 507
 508   if (type != CPP_NUMBER || strtoul_for_line (str, len, &new_lineno))
 509     {
 510       cpp_error (pfile, "token after #line is not a positive integer");
 511       return;
 512     }
 513
 514   if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap))
 515     cpp_pedwarn (pfile, "line number out of range");
 516
 517   old_lineno = ip->lineno;
 518   ip->lineno = new_lineno;
 519   tok = _cpp_get_token (pfile);
 520   type = tok->type;
 521   str = tok->val.str.text;
 522   len = tok->val.str.len;
 523
 524   if (type == CPP_EOF)
 525     goto done;
 526   else if (type != CPP_STRING)
 527     {
 528       cpp_error (pfile, "second token after #line is not a string");
 529       ip->lineno = old_lineno;  /* malformed #line should have no effect */
 530       return;
 531     }
 532
 533   fname = alloca (len + 1);
 534   memcpy (fname, str, len);
 535   fname[len] = '\0';
 536
 537   if (strcmp (fname, ip->nominal_fname))
 538     {
 539       rename = 1;
 540       if (!strcmp (fname, ip->inc->name))
 541         ip->nominal_fname = ip->inc->name;
 542       else
 543         ip->nominal_fname = _cpp_fake_include (pfile, fname);
 544     }
 545
 546   if (read_line_number (pfile, &action_number) == 0)
 547     goto done;
 548
 549   if (CPP_PEDANTIC (pfile))
 550     cpp_pedwarn (pfile, "garbage at end of #line");
 551
 552   if (action_number == 1)
 553     {
 554       enter = 1;
 555       cpp_make_system_header (pfile, ip, 0);
 556       read_line_number (pfile, &action_number);
 557     }
 558   else if (action_number == 2)
 559     {
 560       leave = 1;
 561       cpp_make_system_header (pfile, ip, 0);
 562       read_line_number (pfile, &action_number);
 563     }
 564   if (action_number == 3)
 565     {
 566       cpp_make_system_header (pfile, ip, 1);
 567       read_line_number (pfile, &action_number);
 568     }
 569   if (action_number == 4)
 570     {
 571       cpp_make_system_header (pfile, ip, 2);
 572       read_line_number (pfile, &action_number);
 573     }
 574
 575  done:
 576   if (enter && pfile->cb.enter_file)
 577     (*pfile->cb.enter_file) (pfile);
 578   if (leave && pfile->cb.leave_file)
 579     (*pfile->cb.leave_file) (pfile);
 580   if (rename && pfile->cb.rename_file)
 581     (*pfile->cb.rename_file) (pfile);
 582 }
 583
 584 /*
 585  * Report a warning or error detected by the program we are
 586  * processing.  Use the directive's tokens in the error message.
 587  */
 588
 589 static void
 590 do_diagnostic (pfile, code)
 591      cpp_reader *pfile;
 592      enum error_type code;
 593 {
 594   if (_cpp_begin_message (pfile, code, NULL, 0, 0))
 595     {
 596       cpp_output_list (pfile, stderr, &pfile->token_list,
 597                        pfile->first_directive_token);
 598       putc ('\n', stderr);
 599     }
 600 }
 601
 602 static void
 603 do_error (pfile)
 604      cpp_reader *pfile;
 605 {
 606   do_diagnostic (pfile, ERROR);
 607 }
 608
 609 static void
 610 do_warning (pfile)
 611      cpp_reader *pfile;
 612 {
 613   do_diagnostic (pfile, WARNING);
 614 }
 615
 616 /* Report program identification.  */
 617
 618 static void
 619 do_ident (pfile)
 620      cpp_reader *pfile;
 621 {
 622   const cpp_token *str = _cpp_get_token (pfile);
 623
 624   if (str->type == CPP_STRING && _cpp_get_token (pfile)->type == CPP_EOF)
 625     {
 626       if (pfile->cb.ident)
 627         (*pfile->cb.ident) (pfile, str->val.str.text, str->val.str.len);
 628       return;
 629     }
 630
 631   cpp_error (pfile, "invalid #ident");
 632 }
 633
 634 /* Pragmata handling.  We handle some of these, and pass the rest on
 635    to the front end.  C99 defines three pragmas and says that no macro
 636    expansion is to be performed on them; whether or not macro
 637    expansion happens for other pragmas is implementation defined.
 638    This implementation never macro-expands the text after #pragma.
 639
 640    We currently do not support the _Pragma operator.  Support for that
 641    has to be coordinated with the front end.  Proposed implementation:
 642    both #pragma blah blah and _Pragma("blah blah") become
 643    __builtin_pragma(blah blah) and we teach the parser about that.  */
 644
 645 /* Sub-handlers for the pragmas needing treatment here.
 646    They return 1 if the token buffer is to be popped, 0 if not. */
 647 struct pragma_entry
 648 {
 649   struct pragma_entry *next;
 650   const char *name;
 651   size_t len;
 652   int isnspace;
 653   union {
 654     void (*handler) PARAMS ((cpp_reader *));
 655     struct pragma_entry *space;
 656   } u;
 657 };
 658
 659 void
 660 cpp_register_pragma (pfile, space, name, handler)
 661      cpp_reader *pfile;
 662      const char *space;
 663      const char *name;
 664      void (*handler) PARAMS ((cpp_reader *));
 665 {
 666   struct pragma_entry **x, *new;
 667   size_t len;
 668
 669   x = &pfile->pragmas;
 670   if (space)
 671     {
 672       struct pragma_entry *p = pfile->pragmas;
 673       len = strlen (space);
 674       while (p)
 675         {
 676           if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
 677             {
 678               x = &p->u.space;
 679               goto found;
 680             }
 681           p = p->next;
 682         }
 683       cpp_ice (pfile, "unknown #pragma namespace %s", space);
 684       return;
 685     }
 686
 687  found:
 688   new = xnew (struct pragma_entry);
 689   new->name = name;
 690   new->len = strlen (name);
 691   new->isnspace = 0;
 692   new->u.handler = handler;
 693
 694   new->next = *x;
 695   *x = new;
 696 }
 697
 698 void
 699 cpp_register_pragma_space (pfile, space)
 700      cpp_reader *pfile;
 701      const char *space;
 702 {
 703   struct pragma_entry *new;
 704   const struct pragma_entry *p = pfile->pragmas;
 705   size_t len = strlen (space);
 706
 707   while (p)
 708     {
 709       if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
 710         /* Multiple different callers are allowed to register the same
 711            namespace.  */
 712         return;
 713       p = p->next;
 714     }
 715
 716   new = xnew (struct pragma_entry);
 717   new->name = space;
 718   new->len = len;
 719   new->isnspace = 1;
 720   new->u.space = 0;
 721
 722   new->next = pfile->pragmas;
 723   pfile->pragmas = new;
 724 }
 725
 726 static void do_pragma_once              PARAMS ((cpp_reader *));
 727 static void do_pragma_poison            PARAMS ((cpp_reader *));
 728 static void do_pragma_system_header     PARAMS ((cpp_reader *));
 729 static void do_pragma_dependency        PARAMS ((cpp_reader *));
 730
 731 void
 732 _cpp_init_internal_pragmas (pfile)
 733      cpp_reader *pfile;
 734 {
 735   /* top level */
 736   cpp_register_pragma (pfile, 0, "poison", do_pragma_poison);
 737   cpp_register_pragma (pfile, 0, "once", do_pragma_once);
 738
 739   /* GCC namespace */
 740   cpp_register_pragma_space (pfile, "GCC");
 741
 742   cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
 743   cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
 744   cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
 745 }
 746
 747 static void
 748 do_pragma (pfile)
 749      cpp_reader *pfile;
 750 {
 751   const struct pragma_entry *p;
 752   const cpp_token *tok;
 753   const cpp_hashnode *node;
 754   const U_CHAR *name;
 755   size_t len;
 756
 757   p = pfile->pragmas;
 758
 759  new_space:
 760   tok = _cpp_get_token (pfile);
 761   if (tok->type == CPP_EOF)
 762     return;
 763
 764   if (tok->type != CPP_NAME)
 765     {
 766       cpp_error (pfile, "malformed #pragma directive");
 767       return;
 768     }
 769
 770   node = tok->val.node;
 771   name = node->name;
 772   len = node->length;
 773   while (p)
 774     {
 775       if (strlen (p->name) == len && !memcmp (p->name, name, len))
 776         {
 777           if (p->isnspace)
 778             {
 779               p = p->u.space;
 780               goto new_space;
 781             }
 782           else
 783             {
 784               (*p->u.handler) (pfile);
 785               return;
 786             }
 787         }
 788       p = p->next;
 789     }
 790
 791   if (pfile->cb.def_pragma)
 792     (*pfile->cb.def_pragma) (pfile);
 793 }
 794
 795 static void
 796 do_pragma_once (pfile)
 797      cpp_reader *pfile;
 798 {
 799   cpp_buffer *ip = CPP_BUFFER (pfile);
 800
 801   /* Allow #pragma once in system headers, since that's not the user's
 802      fault.  */
 803   cpp_warning (pfile, "#pragma once is obsolete");
 804
 805   if (CPP_PREV_BUFFER (ip) == NULL)
 806     cpp_warning (pfile, "#pragma once outside include file");
 807   else
 808     ip->inc->cmacro = NEVER_REREAD;
 809 }
 810
 811 static void
 812 do_pragma_poison (pfile)
 813      cpp_reader *pfile;
 814 {
 815   /* Poison these symbols so that all subsequent usage produces an
 816      error message.  */
 817   const cpp_token *tok;
 818   cpp_hashnode *hp;
 819
 820   for (;;)
 821     {
 822       tok = _cpp_get_token (pfile);
 823       if (tok->type == CPP_EOF)
 824         break;
 825       if (tok->type != CPP_NAME)
 826         {
 827           cpp_error (pfile, "invalid #pragma poison directive");
 828           return;
 829         }
 830
 831       hp = tok->val.node;
 832       if (hp->type == T_POISON)
 833         ;  /* It is allowed to poison the same identifier twice.  */
 834       else
 835         {
 836           if (hp->type != T_VOID)
 837             cpp_warning (pfile, "poisoning existing macro \"%s\"", hp->name);
 838           _cpp_free_definition (hp);
 839           hp->type = T_POISON;
 840         }
 841     }
 842
 843   if (pfile->cb.poison)
 844     (*pfile->cb.poison) (pfile);
 845 }
 846
 847 /* Mark the current header as a system header.  This will suppress
 848    some categories of warnings (notably those from -pedantic).  It is
 849    intended for use in system libraries that cannot be implemented in
 850    conforming C, but cannot be certain that their headers appear in a
 851    system include directory.  To prevent abuse, it is rejected in the
 852    primary source file.  */
 853 static void
 854 do_pragma_system_header (pfile)
 855      cpp_reader *pfile;
 856 {
 857   cpp_buffer *ip = CPP_BUFFER (pfile);
 858   if (CPP_PREV_BUFFER (ip) == NULL)
 859     cpp_warning (pfile, "#pragma system_header outside include file");
 860   else
 861     cpp_make_system_header (pfile, ip, 1);
 862 }
 863
 864 /* Check the modified date of the current include file against a specified
 865    file. Issue a diagnostic, if the specified file is newer. We use this to
 866    determine if a fixed header should be refixed.  */
 867 static void
 868 do_pragma_dependency (pfile)
 869      cpp_reader *pfile;
 870 {
 871   const U_CHAR *name;
 872   unsigned int len;
 873   int ordering, ab;
 874   char left, right;
 875
 876   if (parse_include (pfile, U"pragma dependency", 1, &name, &len, &ab))
 877     return;
 878
 879   left = ab ? '<' : '"';
 880   right = ab ? '>' : '"';
 881
 882   ordering = _cpp_compare_file_date (pfile, name, len, ab);
 883   if (ordering < 0)
 884     cpp_warning (pfile, "cannot find source %c%s%c", left, name, right);
 885   else if (ordering > 0)
 886     {
 887       const cpp_token *msg = _cpp_get_token (pfile);
 888
 889       cpp_warning (pfile, "current file is older than %c%.*s%c",
 890                    left, (int)len, name, right);
 891       if (msg->type != CPP_EOF
 892           && _cpp_begin_message (pfile, WARNING, NULL, msg->line, msg->col))
 893         {
 894           cpp_output_list (pfile, stderr, &pfile->token_list, msg);
 895           putc ('\n', stderr);
 896         }
 897     }
 898 }
 899
 900 /* Just ignore #sccs, on systems where we define it at all.  */
 901 #ifdef SCCS_DIRECTIVE
 902 static void
 903 do_sccs (pfile)
 904      cpp_reader *pfile ATTRIBUTE_UNUSED;
 905 {
 906 }
 907 #endif
 908
 909 /* We've found an `#if' directive.  If the only thing before it in
 910    this file is white space, and if it is of the form
 911    `#if ! defined SYMBOL', then SYMBOL is a possible controlling macro
 912    for inclusion of this file.  (See redundant_include_p in cppfiles.c
 913    for an explanation of controlling macros.)  If so, return the
 914    hash node for SYMBOL.  Otherwise, return NULL.  */
 915
 916 static const cpp_hashnode *
 917 detect_if_not_defined (pfile)
 918      cpp_reader *pfile;
 919 {
 920   const cpp_token *token;
 921   cpp_hashnode *cmacro = 0;
 922
 923   /* We are guaranteed that tokens are consecutive and end in CPP_EOF.  */
 924   token = pfile->first_directive_token + 2;
 925
 926   if (token->type != CPP_NOT)
 927     return 0;
 928
 929   token++;
 930   if (token->type != CPP_DEFINED)
 931     return 0;
 932
 933   token++;
 934   if (token->type == CPP_OPEN_PAREN)
 935     token++;
 936
 937   if (token->type != CPP_NAME)
 938     return 0;
 939
 940   cmacro = token->val.node;
 941
 942   if (token[-1].type == CPP_OPEN_PAREN)
 943     {
 944       token++;
 945       if (token->type != CPP_CLOSE_PAREN)
 946         return 0;
 947     }
 948
 949   token++;
 950   if (token->type != CPP_EOF)
 951     return 0;
 952
 953   return cmacro;
 954 }
 955
 956 /* Parse an #ifdef or #ifndef directive.  Returns the hash node of the
 957    macro being tested, and issues various error messages.  */
 958
 959 static const cpp_hashnode *
 960 parse_ifdef (pfile, name)
 961      cpp_reader *pfile;
 962      const U_CHAR *name;
 963 {
 964   enum cpp_ttype type;
 965   const cpp_hashnode *node = 0;
 966
 967   const cpp_token *token = _cpp_get_token (pfile);
 968   type = token->type;
 969
 970   if (type == CPP_EOF)
 971     cpp_pedwarn (pfile, "#%s with no argument", name);
 972   else if (type != CPP_NAME)
 973     cpp_pedwarn (pfile, "#%s with invalid argument", name);
 974   else if (_cpp_get_token (pfile)->type != CPP_EOF)
 975     cpp_pedwarn (pfile, "garbage at end of #%s", name);
 976
 977   if (type == CPP_NAME)
 978     node = token->val.node;
 979   if (node && node->type == T_POISON)
 980     {
 981       cpp_error (pfile, "attempt to use poisoned identifier \"%s\"",
 982                  node->name);
 983       node = 0;
 984     }
 985
 986   return node;
 987 }
 988
 989 /* #ifdef is dead simple.  */
 990
 991 static void
 992 do_ifdef (pfile)
 993      cpp_reader *pfile;
 994 {
 995   const cpp_hashnode *node = 0;
 996
 997   if (! pfile->skipping)
 998     node = parse_ifdef (pfile, dtable[T_IFDEF].name);
 999
1000   push_conditional (pfile, !(node && node->type != T_VOID), T_IFDEF, 0);
1001 }
1002
1003 /* #ifndef is a tad more complex, because we need to check for a
1004    no-reinclusion wrapper.  */
1005
1006 static void
1007 do_ifndef (pfile)
1008      cpp_reader *pfile;
1009 {
1010   int start_of_file = 0;
1011   const cpp_hashnode *node = 0;
1012
1013   if (! pfile->skipping)
1014     {
1015       start_of_file = (pfile->token_list.flags & BEG_OF_FILE);
1016       node = parse_ifdef (pfile, dtable[T_IFNDEF].name);
1017     }
1018
1019   push_conditional (pfile, node && node->type != T_VOID,
1020                     T_IFNDEF, start_of_file ? node : 0);
1021 }
1022
1023 /* #if is straightforward; just call _cpp_parse_expr, then conditional_skip.
1024    Also, check for a reinclude preventer of the form #if !defined (MACRO).  */
1025
1026 static void
1027 do_if (pfile)
1028      cpp_reader *pfile;
1029 {
1030   const cpp_hashnode *cmacro = 0;
1031   int value = 0;
1032
1033   if (! pfile->skipping)
1034     {
1035       if (pfile->token_list.flags & BEG_OF_FILE)
1036         cmacro = detect_if_not_defined (pfile);
1037       value = _cpp_parse_expr (pfile);
1038     }
1039   push_conditional (pfile, value == 0, T_IF, cmacro);
1040 }
1041
1042 /* #else flips pfile->skipping and continues without changing
1043    if_stack; this is so that the error message for missing #endif's
1044    etc. will point to the original #if.  */
1045
1046 static void
1047 do_else (pfile)
1048      cpp_reader *pfile;
1049 {
1050   struct if_stack *ifs = CPP_BUFFER (pfile)->if_stack;
1051   validate_else (pfile, dtable[T_ELSE].name);
1052
1053   if (ifs == NULL)
1054     {
1055       cpp_error (pfile, "#else without #if");
1056       return;
1057     }
1058   if (ifs->type == T_ELSE)
1059     {
1060       cpp_error (pfile, "#else after #else");
1061       cpp_error_with_line (pfile, ifs->lineno, ifs->colno,
1062                            "the conditional began here");
1063     }
1064
1065   /* #ifndef can't have its special treatment for containing the whole file
1066      if it has a #else clause.  */
1067   ifs->cmacro = 0;
1068   ifs->type = T_ELSE;
1069   if (! ifs->was_skipping)
1070     {
1071       /* If pfile->skipping is 2, one of the blocks in an #if/#elif/... chain
1072          succeeded, so we mustn't do the else block.  */
1073       if (pfile->skipping < 2)
1074         pfile->skipping = ! pfile->skipping;
1075     }
1076 }
1077
1078 /*
1079  * handle a #elif directive by not changing if_stack either.
1080  * see the comment above do_else.
1081  */
1082
1083 static void
1084 do_elif (pfile)
1085      cpp_reader *pfile;
1086 {
1087   struct if_stack *ifs = CPP_BUFFER (pfile)->if_stack;
1088
1089   if (ifs == NULL)
1090     {
1091       cpp_error (pfile, "#elif without #if");
1092       return;
1093     }
1094   if (ifs->type == T_ELSE)
1095     {
1096       cpp_error (pfile, "#elif after #else");
1097       cpp_error_with_line (pfile, ifs->lineno, ifs->colno,
1098                            "the conditional began here");
1099     }
1100
1101   ifs->type = T_ELIF;
1102   if (ifs->was_skipping)
1103     return;  /* Don't evaluate a nested #if */
1104
1105   if (pfile->skipping != 1)
1106     {
1107       pfile->skipping = 2;  /* one block succeeded, so don't do any others */
1108       return;
1109     }
1110
1111   pfile->skipping = ! _cpp_parse_expr (pfile);
1112 }
1113
1114 /* #endif pops the if stack and resets pfile->skipping.  */
1115
1116 static void
1117 do_endif (pfile)
1118      cpp_reader *pfile;
1119 {
1120   struct if_stack *ifs = CPP_BUFFER (pfile)->if_stack;
1121
1122   validate_else (pfile, dtable[T_ENDIF].name);
1123
1124   if (ifs == NULL)
1125     cpp_error (pfile, "#endif without #if");
1126   else
1127     {
1128       CPP_BUFFER (pfile)->if_stack = ifs->next;
1129       pfile->skipping = ifs->was_skipping;
1130       pfile->potential_control_macro = ifs->cmacro;
1131       obstack_free (pfile->buffer_ob, ifs);
1132     }
1133 }
1134
1135
1136 /* Push an if_stack entry and set pfile->skipping accordingly.
1137    If this is a #ifndef starting at the beginning of a file,
1138    CMACRO is the macro name tested by the #ifndef.  */
1139
1140 static void
1141 push_conditional (pfile, skip, type, cmacro)
1142      cpp_reader *pfile;
1143      int skip;
1144      int type;
1145      const cpp_hashnode *cmacro;
1146 {
1147   struct if_stack *ifs;
1148
1149   ifs = xobnew (pfile->buffer_ob, struct if_stack);
1150   ifs->lineno = _cpp_get_line (pfile, &ifs->colno);
1151   ifs->next = CPP_BUFFER (pfile)->if_stack;
1152   ifs->cmacro = cmacro;
1153   ifs->was_skipping = pfile->skipping;
1154   ifs->type = type;
1155
1156   if (!pfile->skipping)
1157     pfile->skipping = skip;
1158
1159   CPP_BUFFER (pfile)->if_stack = ifs;
1160 }
1161
1162 /* Issue -pedantic warning for text which is not a comment following
1163    an #else or #endif.  */
1164
1165 static void
1166 validate_else (pfile, directive)
1167      cpp_reader *pfile;
1168      const U_CHAR *directive;
1169 {
1170   if (CPP_PEDANTIC (pfile) && _cpp_get_token (pfile)->type != CPP_EOF)
1171     cpp_pedwarn (pfile, "ISO C forbids text after #%s", directive);
1172 }
1173
1174 /* Called when we reach the end of a file.  Walk back up the
1175    conditional stack till we reach its level at entry to this file,
1176    issuing error messages.  Then force skipping off.  */
1177 static void
1178 unwind_if_stack (pfile, pbuf)
1179      cpp_reader *pfile;
1180      cpp_buffer *pbuf;
1181 {
1182   struct if_stack *ifs, *nifs;
1183
1184   for (ifs = pbuf->if_stack; ifs; ifs = nifs)
1185     {
1186       cpp_error_with_line (pfile, ifs->lineno, ifs->colno, "unterminated #%s",
1187                            dtable[ifs->type].name);
1188       nifs = ifs->next;
1189       /* No need to free - they'll all go away with the buffer.  */
1190     }
1191   pfile->skipping = 0;
1192 }
1193
1194 /* Parses an assertion, returning a pointer to the hash node of the
1195    predicate, or 0 on error.  If an answer was supplied, it is
1196    allocated and placed in ANSWERP, otherwise it is set to 0.  We use
1197    _cpp_get_raw_token, since we cannot assume tokens are consecutive
1198    in a #if statement (we may be in a macro), and we don't want to
1199    macro expand.  */
1200 cpp_hashnode *
1201 _cpp_parse_assertion (pfile, answerp)
1202      cpp_reader *pfile;
1203      struct answer **answerp;
1204 {
1205   struct answer *answer = 0;
1206   cpp_toklist *list;
1207   U_CHAR *sym;
1208   const cpp_token *token, *predicate;
1209   const struct directive *d = pfile->token_list.directive;
1210   unsigned int len = 0;
1211
1212   predicate = _cpp_get_raw_token (pfile);
1213   if (predicate->type == CPP_EOF)
1214     {
1215       cpp_error (pfile, "assertion without predicate");
1216       return 0;
1217     }
1218   else if (predicate->type != CPP_NAME)
1219     {
1220       cpp_error (pfile, "predicate must be an identifier");
1221       return 0;
1222     }
1223
1224   token = _cpp_get_raw_token (pfile);
1225   if (token->type != CPP_OPEN_PAREN)
1226     {
1227       /* #unassert and #if are OK without predicate.  */
1228       if (d == &dtable[T_UNASSERT])
1229         {
1230           if (token->type == CPP_EOF)
1231             goto lookup_node;
1232         }
1233       else if (d != &dtable[T_ASSERT])
1234         {
1235           _cpp_push_token (pfile, token);
1236           goto lookup_node;
1237         }
1238       cpp_error (pfile, "missing '(' after predicate");
1239       return 0;
1240     }
1241
1242   /* Allocate a struct answer, and copy the answer to it.  */
1243   answer = (struct answer *) xmalloc (sizeof (struct answer));
1244   list = &answer->list;
1245   _cpp_init_toklist (list, 1);  /* Empty.  */
1246
1247   for (;;)
1248     {
1249       cpp_token *dest;
1250
1251       token = _cpp_get_raw_token (pfile);
1252
1253       if (token->type == CPP_EOF)
1254         {
1255           cpp_error (pfile, "missing ')' to complete answer");
1256           goto error;
1257         }
1258       if (token->type == CPP_CLOSE_PAREN)
1259         break;
1260
1261       /* Copy the token.  */
1262       _cpp_expand_token_space (list, 1);
1263       dest = &list->tokens[list->tokens_used++];
1264       *dest = *token;
1265
1266       if (TOKEN_SPELL (token) == SPELL_STRING)
1267         {
1268           _cpp_expand_name_space (list, token->val.str.len);
1269           dest->val.str.text = list->namebuf + list->name_used;
1270           memcpy (list->namebuf + list->name_used,
1271                   token->val.str.text, token->val.str.len);
1272           list->name_used += token->val.str.len;
1273         }
1274     }
1275
1276   if (list->tokens_used == 0)
1277     {
1278       cpp_error (pfile, "predicate's answer is empty");
1279       goto error;
1280     }
1281
1282   /* Drop whitespace at start.  */
1283   list->tokens[0].flags &= ~PREV_WHITE;
1284
1285   if ((d == &dtable[T_ASSERT] || d == &dtable[T_UNASSERT])
1286       && token[1].type != CPP_EOF)
1287     {
1288       cpp_error (pfile, "junk at end of assertion");
1289       goto error;
1290     }
1291
1292  lookup_node:
1293   *answerp = answer;
1294   len = predicate->val.node->length;
1295   sym = alloca (len + 1);
1296
1297   /* Prefix '#' to get it out of macro namespace.  */
1298   sym[0] = '#';
1299   memcpy (sym + 1, predicate->val.node->name, len);
1300   return cpp_lookup (pfile, sym, len + 1);
1301
1302  error:
1303   FREE_ANSWER (answer);
1304   return 0;
1305 }
1306
1307 /* Returns a pointer to the pointer to the answer in the answer chain,
1308    or a pointer to NULL if the answer is not in the chain.  */
1309 struct answer **
1310 _cpp_find_answer (node, candidate)
1311      cpp_hashnode *node;
1312      const cpp_toklist *candidate;
1313 {
1314   struct answer **result;
1315
1316   for (result = &node->value.answers; *result; result = &(*result)->next)
1317     if (_cpp_equiv_toklists (&(*result)->list, candidate))
1318       break;
1319
1320   return result;
1321 }
1322
1323 static void
1324 do_assert (pfile)
1325      cpp_reader *pfile;
1326 {
1327   struct answer *new_answer;
1328   cpp_hashnode *node;
1329
1330   node = _cpp_parse_assertion (pfile, &new_answer);
1331   if (node)
1332     {
1333       new_answer->next = 0;
1334       new_answer->list.file = pfile->token_list.file;
1335
1336       if (node->type == T_ASSERTION)
1337         {
1338           if (*_cpp_find_answer (node, &new_answer->list))
1339             goto err;
1340           new_answer->next = node->value.answers;
1341         }
1342       node->type = T_ASSERTION;
1343       node->value.answers = new_answer;
1344     }
1345   return;
1346
1347  err:
1348   cpp_warning (pfile, "\"%s\" re-asserted", node->name + 1);
1349   FREE_ANSWER (new_answer);
1350 }
1351
1352 static void
1353 do_unassert (pfile)
1354      cpp_reader *pfile;
1355 {
1356   cpp_hashnode *node;
1357   struct answer *answer, *temp;
1358
1359   node = _cpp_parse_assertion (pfile, &answer);
1360   if (node)
1361     {
1362       /* It isn't an error to #unassert something that isn't asserted.  */
1363       if (node->type == T_ASSERTION)
1364         {
1365           if (answer)
1366             {
1367               struct answer **p = _cpp_find_answer (node, &answer->list);
1368
1369               temp = *p;
1370               if (temp)
1371                 {
1372                   *p = temp->next;
1373                   FREE_ANSWER (temp);
1374                 }
1375               if (node->value.answers == 0)
1376                 node->type = T_VOID;
1377             }
1378           else
1379             _cpp_free_definition (node);
1380         }
1381
1382       if (answer)
1383         FREE_ANSWER (answer);
1384     }
1385 }
1386
1387 /* These are for -D, -U, -A.  */
1388
1389 /* Process the string STR as if it appeared as the body of a #define.
1390    If STR is just an identifier, define it with value 1.
1391    If STR has anything after the identifier, then it should
1392    be identifier=definition. */
1393
1394 void
1395 cpp_define (pfile, str)
1396      cpp_reader *pfile;
1397      const char *str;
1398 {
1399   char *buf, *p;
1400   size_t count;
1401
1402   p = strchr (str, '=');
1403   /* Copy the entire option so we can modify it.
1404      Change the first "=" in the string to a space.  If there is none,
1405      tack " 1" on the end.  Then add a newline and a NUL.  */
1406
1407   if (p)
1408     {
1409       count = strlen (str) + 2;
1410       buf = (char *) alloca (count);
1411       memcpy (buf, str, count - 2);
1412       buf[p - str] = ' ';
1413       buf[count - 2] = '\n';
1414       buf[count - 1] = '\0';
1415     }
1416   else
1417     {
1418       count = strlen (str) + 4;
1419       buf = (char *) alloca (count);
1420       memcpy (buf, str, count - 4);
1421       strcpy (&buf[count-4], " 1\n");
1422     }
1423
1424   _cpp_run_directive (pfile, &dtable[T_DEFINE], buf, count - 1, 0);
1425 }
1426
1427 /* Slight variant of the above for use by initialize_builtins, which (a)
1428    knows how to set up the buffer itself, (b) needs a different "filename"
1429    tag.  */
1430 void
1431 _cpp_define_builtin (pfile, str)
1432      cpp_reader *pfile;
1433      const char *str;
1434 {
1435   _cpp_run_directive (pfile, &dtable[T_DEFINE],
1436                       str, strlen (str),
1437                       _("<builtin>"));
1438 }
1439
1440 /* Process MACRO as if it appeared as the body of an #undef.  */
1441 void
1442 cpp_undef (pfile, macro)
1443      cpp_reader *pfile;
1444      const char *macro;
1445 {
1446   _cpp_run_directive (pfile, &dtable[T_UNDEF], macro, strlen (macro), 0);
1447 }
1448
1449 /* Process the string STR as if it appeared as the body of a #assert. */
1450 void
1451 cpp_assert (pfile, str)
1452      cpp_reader *pfile;
1453      const char *str;
1454 {
1455   _cpp_run_directive (pfile, &dtable[T_ASSERT], str, strlen (str), 0);
1456 }
1457
1458 /* Process STR as if it appeared as the body of an #unassert. */
1459 void
1460 cpp_unassert (pfile, str)
1461      cpp_reader *pfile;
1462      const char *str;
1463 {
1464   _cpp_run_directive (pfile, &dtable[T_UNASSERT], str, strlen (str), 0);
1465 }
1466
1467 /* Determine whether the identifier ID, of length LEN, is a defined macro.  */
1468 int
1469 cpp_defined (pfile, id, len)
1470      cpp_reader *pfile;
1471      const U_CHAR *id;
1472      int len;
1473 {
1474   cpp_hashnode *hp = cpp_lookup (pfile, id, len);
1475   if (hp->type == T_POISON)
1476     {
1477       cpp_error (pfile, "attempt to use poisoned \"%s\"", hp->name);
1478       return 0;
1479     }
1480   return (hp->type != T_VOID);
1481 }
1482
1483 /* Allocate a new cpp_buffer for PFILE, and push it on the input buffer stack.
1484    If BUFFER != NULL, then use the LENGTH characters in BUFFER
1485    as the new input buffer.
1486    Return the new buffer, or NULL on failure.  */
1487
1488 cpp_buffer *
1489 cpp_push_buffer (pfile, buffer, length)
1490      cpp_reader *pfile;
1491      const U_CHAR *buffer;
1492      long length;
1493 {
1494   cpp_buffer *buf = CPP_BUFFER (pfile);
1495   cpp_buffer *new;
1496   if (++pfile->buffer_stack_depth == CPP_STACK_MAX)
1497     {
1498       cpp_fatal (pfile, "#include nested too deep");
1499       return NULL;
1500     }
1501   if (pfile->cur_context > 0)
1502     {
1503       cpp_ice (pfile, "buffer pushed with contexts stacked");
1504       _cpp_skip_rest_of_line (pfile);
1505     }
1506
1507   new = xobnew (pfile->buffer_ob, cpp_buffer);
1508   memset (new, 0, sizeof (cpp_buffer));
1509
1510   new->line_base = new->buf = new->cur = buffer;
1511   new->rlimit = buffer + length;
1512   new->prev = buf;
1513   new->pfile = pfile;
1514   /* No read ahead or extra char initially.  */
1515   new->read_ahead = EOF;
1516   new->extra_char = EOF;
1517
1518   CPP_BUFFER (pfile) = new;
1519   return new;
1520 }
1521
1522 cpp_buffer *
1523 cpp_pop_buffer (pfile)
1524      cpp_reader *pfile;
1525 {
1526   int wfb;
1527   cpp_buffer *buf = CPP_BUFFER (pfile);
1528
1529   unwind_if_stack (pfile, buf);
1530   wfb = (buf->inc != 0);
1531   if (wfb)
1532     _cpp_pop_file_buffer (pfile, buf);
1533
1534   CPP_BUFFER (pfile) = CPP_PREV_BUFFER (buf);
1535   obstack_free (pfile->buffer_ob, buf);
1536   pfile->buffer_stack_depth--;
1537
1538   if (wfb && pfile->cb.leave_file && CPP_BUFFER (pfile))
1539     (*pfile->cb.leave_file) (pfile);
1540
1541   return CPP_BUFFER (pfile);
1542 }
1543
1544 #define obstack_chunk_alloc xmalloc
1545 #define obstack_chunk_free free
1546 #define DSC(x) U x, sizeof x - 1
1547 void
1548 _cpp_init_stacks (pfile)
1549      cpp_reader *pfile;
1550 {
1551   int i;
1552   struct spec_nodes *s;
1553
1554   pfile->buffer_ob = xnew (struct obstack);
1555   obstack_init (pfile->buffer_ob);
1556
1557   /* Perhaps not the ideal place to put this.  */
1558   pfile->spec_nodes = s = xnew (struct spec_nodes);
1559   s->n_L                = cpp_lookup (pfile, DSC("L"));
1560   s->n__STRICT_ANSI__   = cpp_lookup (pfile, DSC("__STRICT_ANSI__"));
1561   s->n__CHAR_UNSIGNED__ = cpp_lookup (pfile, DSC("__CHAR_UNSIGNED__"));
1562   s->n__VA_ARGS__       = cpp_lookup (pfile, DSC("__VA_ARGS__"));
1563   for (i = 0; i < N_DIRECTIVES; i++)
1564     s->dirs[i] = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
1565 }
1566
1567 void
1568 _cpp_cleanup_stacks (pfile)
1569      cpp_reader *pfile;
1570 {
1571   obstack_free (pfile->buffer_ob, 0);
1572   free (pfile->buffer_ob);
1573 }