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