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 /* Utility.  */
  65 #define str_match(sym, len, str) \
  66 ((len) == (sizeof (str) - 1) && !ustrncmp ((sym), U(str), sizeof (str) - 1))
  67
  68 /* This is the table of directive handlers.  It is ordered by
  69    frequency of occurrence; the numbers at the end are directive
  70    counts from all the source code I have lying around (egcs and libc
  71    CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
  72    pcmcia-cs-3.0.9).
  73
  74    The entries with a dash and a name after the count are extensions,
  75    of which all but #warning and #include_next are deprecated.  The name
  76    is where the extension appears to have come from.  */
  77
  78 /* #sccs is not always recognized.  */
  79 #ifdef SCCS_DIRECTIVE
  80 # define SCCS_ENTRY D(sccs, T_SCCS, EXTENSION, 0)
  81 #else
  82 # define SCCS_ENTRY /* nothing */
  83 #endif
  84
  85 #define DIRECTIVE_TABLE                                                 \
  86 D(define,       T_DEFINE = 0,   KANDR,     COMMENTS)       /* 270554 */ \
  87 D(include,      T_INCLUDE,      KANDR,     EXPAND | INCL)  /*  52262 */ \
  88 D(endif,        T_ENDIF,        KANDR,     COND)           /*  45855 */ \
  89 D(ifdef,        T_IFDEF,        KANDR,     COND)           /*  22000 */ \
  90 D(if,           T_IF,           KANDR,     COND | EXPAND)  /*  18162 */ \
  91 D(else,         T_ELSE,         KANDR,     COND)           /*   9863 */ \
  92 D(ifndef,       T_IFNDEF,       KANDR,     COND)           /*   9675 */ \
  93 D(undef,        T_UNDEF,        KANDR,     0)              /*   4837 */ \
  94 D(line,         T_LINE,         KANDR,     EXPAND)         /*   2465 */ \
  95 D(elif,         T_ELIF,         KANDR,     COND | EXPAND)  /*    610 */ \
  96 D(error,        T_ERROR,        STDC89,    0)              /*    475 */ \
  97 D(pragma,       T_PRAGMA,       STDC89,    0)              /*    195 */ \
  98 D(warning,      T_WARNING,      EXTENSION, 0)              /*     22 GNU   */ \
  99 D(include_next, T_INCLUDE_NEXT, EXTENSION, EXPAND | INCL)  /*     19 GNU   */ \
 100 D(ident,        T_IDENT,        EXTENSION, 0)              /*     11 SVR4  */ \
 101 D(import,       T_IMPORT,       EXTENSION, EXPAND | INCL)  /*      0 ObjC  */ \
 102 D(assert,       T_ASSERT,       EXTENSION, 0)              /*      0 SVR4  */ \
 103 D(unassert,     T_UNASSERT,     EXTENSION, 0)              /*      0 SVR4  */ \
 104 SCCS_ENTRY                                                 /*      0 SVR2? */
 105
 106 /* Use the table to generate a series of prototypes, an enum for the
 107    directive names, and an array of directive handlers.  */
 108
 109 /* The directive-processing functions are declared to return int
 110    instead of void, because some old compilers have trouble with
 111    pointers to functions returning void.  */
 112
 113 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
 114 #define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
 115 DIRECTIVE_TABLE
 116 #undef D
 117
 118 #define D(n, tag, o, f) tag,
 119 enum
 120 {
 121   DIRECTIVE_TABLE
 122   N_DIRECTIVES
 123 };
 124 #undef D
 125
 126 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
 127 #define D(name, t, origin, flags) \
 128 { CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
 129   sizeof STRINGX(name) - 1, origin, flags },
 130 static const struct directive dtable[] =
 131 {
 132 DIRECTIVE_TABLE
 133 };
 134 #undef D
 135 #undef DIRECTIVE_TABLE
 136
 137 /* Check if a token's name matches that of a known directive.  Put in
 138    this file to save exporting dtable and other unneeded information.  */
 139 const struct directive *
 140 _cpp_check_directive (pfile, token, bol)
 141      cpp_reader *pfile;
 142      const cpp_token *token;
 143      int bol;
 144 {
 145   unsigned int i;
 146
 147   /* If we are rescanning preprocessed input, don't obey any directives
 148      other than # nnn.  */
 149   if (CPP_OPTION (pfile, preprocessed))
 150     return 0;
 151
 152   for (i = 0; i < N_DIRECTIVES; i++)
 153     if (pfile->spec_nodes->dirs[i] == token->val.node)
 154       {
 155         /* In -traditional mode, a directive is ignored unless its #
 156            is in column 1.  In code intended to work with K+R compilers,
 157            therefore, directives added by C89 must have their # indented,
 158            and directives present in traditional C must not.  This is true
 159            even of directives in skipped conditional blocks.  */
 160         if (CPP_WTRADITIONAL (pfile))
 161           {
 162             if (!bol && dtable[i].origin == KANDR)
 163               cpp_warning (pfile,
 164                            "traditional C ignores #%s with the # indented",
 165                            dtable[i].name);
 166
 167             if (bol && dtable[i].origin != KANDR)
 168               cpp_warning (pfile,
 169                     "suggest hiding #%s from traditional C with an indented #",
 170                            dtable[i].name);
 171           }
 172
 173         /* If we are skipping a failed conditional group, all non-conditional
 174            directives are ignored.  */
 175         if (pfile->skipping && !(dtable[i].flags & COND))
 176           return 0;
 177
 178         /* Issue -pedantic warnings for extended directives.   */
 179         if (CPP_PEDANTIC (pfile) && dtable[i].origin == EXTENSION)
 180           cpp_pedwarn (pfile, "ISO C does not allow #%s", dtable[i].name);
 181
 182         return &dtable[i];
 183       }
 184
 185   return 0;
 186 }
 187
 188 const struct directive *
 189 _cpp_check_linemarker (pfile, token, bol)
 190      cpp_reader *pfile;
 191      const cpp_token *token ATTRIBUTE_UNUSED;
 192      int bol;
 193 {
 194   /* # followed by a number is equivalent to #line.  Do not recognize
 195      this form in assembly language source files or skipped
 196      conditional groups.  Complain about this form if we're being
 197      pedantic, but not if this is regurgitated input (preprocessed or
 198      fed back in by the C++ frontend).  */
 199   if (pfile->skipping || CPP_OPTION (pfile, lang_asm))
 200     return 0;
 201
 202   if (CPP_PEDANTIC (pfile) && CPP_BUFFER (pfile)->inc
 203       && ! CPP_OPTION (pfile, preprocessed))
 204     cpp_pedwarn (pfile, "# followed by integer");
 205
 206   /* In -traditional mode, a directive is ignored unless its #
 207      is in column 1.  */
 208   if (!bol && CPP_WTRADITIONAL (pfile))
 209     cpp_warning (pfile, "traditional C ignores #%s with the # indented",
 210                  dtable[T_LINE].name);
 211
 212   return &dtable[T_LINE];
 213 }
 214
 215 static cpp_hashnode *
 216 get_define_node (pfile)
 217      cpp_reader *pfile;
 218 {
 219   const cpp_token *token;
 220
 221   /* Skip any -C comments.  */
 222   while ((token = _cpp_get_token (pfile))->type == CPP_COMMENT)
 223     ;
 224
 225   /* The token immediately after #define must be an identifier.  That
 226      identifier is not allowed to be "defined".  See predefined macro
 227      names (6.10.8.4).  In C++, it is not allowed to be any of the
 228      <iso646.h> macro names (which are keywords in C++) either.  */
 229
 230   if (token->type != CPP_NAME)
 231     {
 232       if (token->type == CPP_DEFINED)
 233         cpp_error_with_line (pfile, token->line, token->col,
 234                              "\"defined\" cannot be used as a macro name");
 235       else if (token->flags & NAMED_OP)
 236         cpp_error_with_line (pfile, token->line, token->col,
 237                              "\"%s\" cannot be used as a macro name in C++",
 238                              token->val.node->name);
 239       else
 240         cpp_error_with_line (pfile, token->line, token->col,
 241                            "macro names must be identifiers");
 242       return 0;
 243     }
 244
 245   /* In Objective C, some keywords begin with '@', but general identifiers
 246      do not, and you're not allowed to #define them.  */
 247   if (token->val.node->name[0] == '@')
 248     {
 249       cpp_error_with_line (pfile, token->line, token->col,
 250                            "\"%s\" cannot be used as a macro name",
 251                            token->val.node->name);
 252       return 0;
 253     }
 254
 255   /* Check for poisoned identifiers now.  */
 256   if (token->val.node->type == T_POISON)
 257     {
 258       cpp_error_with_line (pfile, token->line, token->col,
 259                            "attempt to use poisoned \"%s\"",
 260                            token->val.node->name);
 261       return 0;
 262     }
 263
 264   return token->val.node;
 265 }
 266
 267 /* Process a #define command.  */
 268 static void
 269 do_define (pfile)
 270      cpp_reader *pfile;
 271 {
 272   cpp_hashnode *node;
 273
 274   if ((node = get_define_node (pfile)))
 275     if (_cpp_create_definition (pfile, node))
 276       if (pfile->cb.define)
 277         (*pfile->cb.define) (pfile, node);
 278 }
 279
 280 /* Remove the definition of a symbol from the symbol table.  */
 281 static void
 282 do_undef (pfile)
 283      cpp_reader *pfile;
 284 {
 285   cpp_hashnode *node = get_define_node (pfile);
 286
 287   if (_cpp_get_token (pfile)->type != CPP_EOF)
 288     cpp_pedwarn (pfile, "junk on line after #undef");
 289
 290   /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
 291      is not currently defined as a macro name.  */
 292   if (node && node->type != T_VOID)
 293     {
 294       if (pfile->cb.undef)
 295         (*pfile->cb.undef) (pfile, node);
 296
 297       if (node->type != T_MACRO)
 298         cpp_warning (pfile, "undefining \"%s\"", node->name);
 299
 300       _cpp_free_definition (node);
 301       node->type = T_VOID;
 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         {
 698           cpp_ice (pfile, "#pragma namespace %s already registered", space);
 699           return;
 700         }
 701       p = p->next;
 702     }
 703
 704   new = xnew (struct pragma_entry);
 705   new->name = space;
 706   new->len = len;
 707   new->isnspace = 1;
 708   new->u.space = 0;
 709
 710   new->next = pfile->pragmas;
 711   pfile->pragmas = new;
 712 }
 713
 714 static void do_pragma_once              PARAMS ((cpp_reader *));
 715 static void do_pragma_poison            PARAMS ((cpp_reader *));
 716 static void do_pragma_system_header     PARAMS ((cpp_reader *));
 717 static void do_pragma_dependency        PARAMS ((cpp_reader *));
 718
 719 void
 720 _cpp_init_internal_pragmas (pfile)
 721      cpp_reader *pfile;
 722 {
 723   /* top level */
 724   cpp_register_pragma (pfile, 0, "poison", do_pragma_poison);
 725   cpp_register_pragma (pfile, 0, "once", do_pragma_once);
 726
 727   /* GCC namespace */
 728   cpp_register_pragma_space (pfile, "GCC");
 729
 730   cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
 731   cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
 732   cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
 733 }
 734
 735 static void
 736 do_pragma (pfile)
 737      cpp_reader *pfile;
 738 {
 739   const struct pragma_entry *p;
 740   const cpp_token *tok;
 741   const cpp_hashnode *node;
 742   const U_CHAR *name;
 743   size_t len;
 744
 745   p = pfile->pragmas;
 746
 747  new_space:
 748   tok = _cpp_get_token (pfile);
 749   if (tok->type == CPP_EOF)
 750     return;
 751
 752   if (tok->type != CPP_NAME)
 753     {
 754       cpp_error (pfile, "malformed #pragma directive");
 755       return;
 756     }
 757
 758   node = tok->val.node;
 759   name = node->name;
 760   len = node->length;
 761   while (p)
 762     {
 763       if (strlen (p->name) == len && !memcmp (p->name, name, len))
 764         {
 765           if (p->isnspace)
 766             {
 767               p = p->u.space;
 768               goto new_space;
 769             }
 770           else
 771             {
 772               (*p->u.handler) (pfile);
 773               return;
 774             }
 775         }
 776       p = p->next;
 777     }
 778
 779   if (pfile->cb.def_pragma)
 780     (*pfile->cb.def_pragma) (pfile);
 781 }
 782
 783 static void
 784 do_pragma_once (pfile)
 785      cpp_reader *pfile;
 786 {
 787   cpp_buffer *ip = CPP_BUFFER (pfile);
 788
 789   /* Allow #pragma once in system headers, since that's not the user's
 790      fault.  */
 791   if (!CPP_IN_SYSTEM_HEADER (pfile))
 792     cpp_warning (pfile, "#pragma once is obsolete");
 793
 794   if (CPP_PREV_BUFFER (ip) == NULL)
 795     cpp_warning (pfile, "#pragma once outside include file");
 796   else
 797     ip->inc->cmacro = NEVER_REREAD;
 798 }
 799
 800 static void
 801 do_pragma_poison (pfile)
 802      cpp_reader *pfile;
 803 {
 804   /* Poison these symbols so that all subsequent usage produces an
 805      error message.  */
 806   const cpp_token *tok;
 807   cpp_hashnode *hp;
 808
 809   for (;;)
 810     {
 811       tok = _cpp_get_token (pfile);
 812       if (tok->type == CPP_EOF)
 813         break;
 814       if (tok->type != CPP_NAME)
 815         {
 816           cpp_error (pfile, "invalid #pragma poison directive");
 817           return;
 818         }
 819
 820       hp = tok->val.node;
 821       if (hp->type == T_POISON)
 822         ;  /* It is allowed to poison the same identifier twice.  */
 823       else
 824         {
 825           if (hp->type != T_VOID)
 826             cpp_warning (pfile, "poisoning existing macro \"%s\"", hp->name);
 827           _cpp_free_definition (hp);
 828           hp->type = T_POISON;
 829         }
 830     }
 831
 832   if (pfile->cb.poison)
 833     (*pfile->cb.poison) (pfile);
 834 }
 835
 836 /* Mark the current header as a system header.  This will suppress
 837    some categories of warnings (notably those from -pedantic).  It is
 838    intended for use in system libraries that cannot be implemented in
 839    conforming C, but cannot be certain that their headers appear in a
 840    system include directory.  To prevent abuse, it is rejected in the
 841    primary source file.  */
 842 static void
 843 do_pragma_system_header (pfile)
 844      cpp_reader *pfile;
 845 {
 846   cpp_buffer *ip = CPP_BUFFER (pfile);
 847   if (CPP_PREV_BUFFER (ip) == NULL)
 848     cpp_warning (pfile, "#pragma system_header outside include file");
 849   else
 850     cpp_make_system_header (pfile, ip, 1);
 851 }
 852
 853 /* Check the modified date of the current include file against a specified
 854    file. Issue a diagnostic, if the specified file is newer. We use this to
 855    determine if a fixed header should be refixed.  */
 856 static void
 857 do_pragma_dependency (pfile)
 858      cpp_reader *pfile;
 859 {
 860   const U_CHAR *name;
 861   unsigned int len;
 862   int ordering, ab;
 863   char left, right;
 864
 865   if (parse_include (pfile, U"pragma dependency", 1, &name, &len, &ab))
 866     return;
 867
 868   left = ab ? '<' : '"';
 869   right = ab ? '>' : '"';
 870
 871   ordering = _cpp_compare_file_date (pfile, name, len, ab);
 872   if (ordering < 0)
 873     cpp_warning (pfile, "cannot find source %c%s%c", left, name, right);
 874   else if (ordering > 0)
 875     {
 876       const cpp_token *msg = _cpp_get_token (pfile);
 877
 878       cpp_warning (pfile, "current file is older than %c%.*s%c",
 879                    left, (int)len, name, right);
 880       if (msg->type != CPP_EOF
 881           && _cpp_begin_message (pfile, WARNING, NULL, msg->line, msg->col))
 882         {
 883           cpp_output_list (pfile, stderr, &pfile->token_list, msg);
 884           putc ('\n', stderr);
 885         }
 886     }
 887 }
 888
 889 /* Just ignore #sccs, on systems where we define it at all.  */
 890 #ifdef SCCS_DIRECTIVE
 891 static void
 892 do_sccs (pfile)
 893      cpp_reader *pfile ATTRIBUTE_UNUSED;
 894 {
 895 }
 896 #endif
 897
 898 /* We've found an `#if' directive.  If the only thing before it in
 899    this file is white space, and if it is of the form
 900    `#if ! defined SYMBOL', then SYMBOL is a possible controlling macro
 901    for inclusion of this file.  (See redundant_include_p in cppfiles.c
 902    for an explanation of controlling macros.)  If so, return the
 903    hash node for SYMBOL.  Otherwise, return NULL.  */
 904
 905 static const cpp_hashnode *
 906 detect_if_not_defined (pfile)
 907      cpp_reader *pfile;
 908 {
 909   const cpp_token *token;
 910   cpp_hashnode *cmacro = 0;
 911
 912   /* We are guaranteed that tokens are consecutive and end in CPP_EOF.  */
 913   token = pfile->first_directive_token + 2;
 914
 915   if (token->type != CPP_NOT)
 916     return 0;
 917
 918   token++;
 919   if (token->type != CPP_DEFINED)
 920     return 0;
 921
 922   token++;
 923   if (token->type == CPP_OPEN_PAREN)
 924     token++;
 925
 926   if (token->type != CPP_NAME)
 927     return 0;
 928
 929   cmacro = token->val.node;
 930
 931   if (token[-1].type == CPP_OPEN_PAREN)
 932     {
 933       token++;
 934       if (token->type != CPP_CLOSE_PAREN)
 935         return 0;
 936     }
 937
 938   token++;
 939   if (token->type != CPP_EOF)
 940     return 0;
 941
 942   return cmacro;
 943 }
 944
 945 /* Parse an #ifdef or #ifndef directive.  Returns the hash node of the
 946    macro being tested, and issues various error messages.  */
 947
 948 static const cpp_hashnode *
 949 parse_ifdef (pfile, name)
 950      cpp_reader *pfile;
 951      const U_CHAR *name;
 952 {
 953   enum cpp_ttype type;
 954   const cpp_hashnode *node = 0;
 955
 956   const cpp_token *token = _cpp_get_token (pfile);
 957   type = token->type;
 958
 959   if (type == CPP_EOF)
 960     cpp_pedwarn (pfile, "#%s with no argument", name);
 961   else if (type != CPP_NAME)
 962     cpp_pedwarn (pfile, "#%s with invalid argument", name);
 963   else if (_cpp_get_token (pfile)->type != CPP_EOF)
 964     cpp_pedwarn (pfile, "garbage at end of #%s", name);
 965
 966   if (type == CPP_NAME)
 967     node = token->val.node;
 968   if (node && node->type == T_POISON)
 969     {
 970       cpp_error (pfile, "attempt to use poisoned identifier \"%s\"",
 971                  node->name);
 972       node = 0;
 973     }
 974
 975   return node;
 976 }
 977
 978 /* #ifdef is dead simple.  */
 979
 980 static void
 981 do_ifdef (pfile)
 982      cpp_reader *pfile;
 983 {
 984   const cpp_hashnode *node = 0;
 985
 986   if (! pfile->skipping)
 987     node = parse_ifdef (pfile, dtable[T_IFDEF].name);
 988
 989   push_conditional (pfile, !(node && node->type != T_VOID), T_IFDEF, 0);
 990 }
 991
 992 /* #ifndef is a tad more complex, because we need to check for a
 993    no-reinclusion wrapper.  */
 994
 995 static void
 996 do_ifndef (pfile)
 997      cpp_reader *pfile;
 998 {
 999   int start_of_file = 0;
1000   const cpp_hashnode *node = 0;
1001
1002   if (! pfile->skipping)
1003     {
1004       start_of_file = (pfile->token_list.flags & BEG_OF_FILE);
1005       node = parse_ifdef (pfile, dtable[T_IFNDEF].name);
1006     }
1007
1008   push_conditional (pfile, node && node->type != T_VOID,
1009                     T_IFNDEF, start_of_file ? node : 0);
1010 }
1011
1012 /* #if is straightforward; just call _cpp_parse_expr, then conditional_skip.
1013    Also, check for a reinclude preventer of the form #if !defined (MACRO).  */
1014
1015 static void
1016 do_if (pfile)
1017      cpp_reader *pfile;
1018 {
1019   const cpp_hashnode *cmacro = 0;
1020   int value = 0;
1021
1022   if (! pfile->skipping)
1023     {
1024       if (pfile->token_list.flags & BEG_OF_FILE)
1025         cmacro = detect_if_not_defined (pfile);
1026       value = _cpp_parse_expr (pfile);
1027     }
1028   push_conditional (pfile, value == 0, T_IF, cmacro);
1029 }
1030
1031 /* #else flips pfile->skipping and continues without changing
1032    if_stack; this is so that the error message for missing #endif's
1033    etc. will point to the original #if.  */
1034
1035 static void
1036 do_else (pfile)
1037      cpp_reader *pfile;
1038 {
1039   struct if_stack *ifs = CPP_BUFFER (pfile)->if_stack;
1040   validate_else (pfile, dtable[T_ELSE].name);
1041
1042   if (ifs == NULL)
1043     {
1044       cpp_error (pfile, "#else without #if");
1045       return;
1046     }
1047   if (ifs->type == T_ELSE)
1048     {
1049       cpp_error (pfile, "#else after #else");
1050       cpp_error_with_line (pfile, ifs->lineno, ifs->colno,
1051                            "the conditional began here");
1052     }
1053
1054   /* #ifndef can't have its special treatment for containing the whole file
1055      if it has a #else clause.  */
1056   ifs->cmacro = 0;
1057   ifs->type = T_ELSE;
1058   if (! ifs->was_skipping)
1059     {
1060       /* If pfile->skipping is 2, one of the blocks in an #if/#elif/... chain
1061          succeeded, so we mustn't do the else block.  */
1062       if (pfile->skipping < 2)
1063         pfile->skipping = ! pfile->skipping;
1064     }
1065 }
1066
1067 /*
1068  * handle a #elif directive by not changing if_stack either.
1069  * see the comment above do_else.
1070  */
1071
1072 static void
1073 do_elif (pfile)
1074      cpp_reader *pfile;
1075 {
1076   struct if_stack *ifs = CPP_BUFFER (pfile)->if_stack;
1077
1078   if (ifs == NULL)
1079     {
1080       cpp_error (pfile, "#elif without #if");
1081       return;
1082     }
1083   if (ifs->type == T_ELSE)
1084     {
1085       cpp_error (pfile, "#elif after #else");
1086       cpp_error_with_line (pfile, ifs->lineno, ifs->colno,
1087                            "the conditional began here");
1088     }
1089
1090   ifs->type = T_ELIF;
1091   if (ifs->was_skipping)
1092     return;  /* Don't evaluate a nested #if */
1093
1094   if (pfile->skipping != 1)
1095     {
1096       pfile->skipping = 2;  /* one block succeeded, so don't do any others */
1097       return;
1098     }
1099
1100   pfile->skipping = ! _cpp_parse_expr (pfile);
1101 }
1102
1103 /* #endif pops the if stack and resets pfile->skipping.  */
1104
1105 static void
1106 do_endif (pfile)
1107      cpp_reader *pfile;
1108 {
1109   struct if_stack *ifs = CPP_BUFFER (pfile)->if_stack;
1110
1111   validate_else (pfile, dtable[T_ENDIF].name);
1112
1113   if (ifs == NULL)
1114     cpp_error (pfile, "#endif without #if");
1115   else
1116     {
1117       CPP_BUFFER (pfile)->if_stack = ifs->next;
1118       pfile->skipping = ifs->was_skipping;
1119       pfile->potential_control_macro = ifs->cmacro;
1120       obstack_free (pfile->buffer_ob, ifs);
1121     }
1122 }
1123
1124
1125 /* Push an if_stack entry and set pfile->skipping accordingly.
1126    If this is a #ifndef starting at the beginning of a file,
1127    CMACRO is the macro name tested by the #ifndef.  */
1128
1129 static void
1130 push_conditional (pfile, skip, type, cmacro)
1131      cpp_reader *pfile;
1132      int skip;
1133      int type;
1134      const cpp_hashnode *cmacro;
1135 {
1136   struct if_stack *ifs;
1137
1138   ifs = xobnew (pfile->buffer_ob, struct if_stack);
1139   ifs->lineno = _cpp_get_line (pfile, &ifs->colno);
1140   ifs->next = CPP_BUFFER (pfile)->if_stack;
1141   ifs->cmacro = cmacro;
1142   ifs->was_skipping = pfile->skipping;
1143   ifs->type = type;
1144
1145   if (!pfile->skipping)
1146     pfile->skipping = skip;
1147
1148   CPP_BUFFER (pfile)->if_stack = ifs;
1149 }
1150
1151 /* Issue -pedantic warning for text which is not a comment following
1152    an #else or #endif.  */
1153
1154 static void
1155 validate_else (pfile, directive)
1156      cpp_reader *pfile;
1157      const U_CHAR *directive;
1158 {
1159   if (CPP_PEDANTIC (pfile) && _cpp_get_token (pfile)->type != CPP_EOF)
1160     cpp_pedwarn (pfile, "ISO C forbids text after #%s", directive);
1161 }
1162
1163 /* Called when we reach the end of a file.  Walk back up the
1164    conditional stack till we reach its level at entry to this file,
1165    issuing error messages.  Then force skipping off.  */
1166 static void
1167 unwind_if_stack (pfile, pbuf)
1168      cpp_reader *pfile;
1169      cpp_buffer *pbuf;
1170 {
1171   struct if_stack *ifs, *nifs;
1172
1173   for (ifs = pbuf->if_stack; ifs; ifs = nifs)
1174     {
1175       cpp_error_with_line (pfile, ifs->lineno, ifs->colno, "unterminated #%s",
1176                            dtable[ifs->type].name);
1177       nifs = ifs->next;
1178       /* No need to free - they'll all go away with the buffer.  */
1179     }
1180   pfile->skipping = 0;
1181 }
1182
1183 /* Parses an assertion, returning a pointer to the hash node of the
1184    predicate, or 0 on error.  If an answer was supplied, it is
1185    allocated and placed in ANSWERP, otherwise it is set to 0.  We use
1186    _cpp_get_raw_token, since we cannot assume tokens are consecutive
1187    in a #if statement (we may be in a macro), and we don't want to
1188    macro expand.  */
1189 cpp_hashnode *
1190 _cpp_parse_assertion (pfile, answerp)
1191      cpp_reader *pfile;
1192      struct answer **answerp;
1193 {
1194   struct answer *answer = 0;
1195   cpp_toklist *list;
1196   U_CHAR *sym;
1197   const cpp_token *token, *predicate;
1198   const struct directive *d = pfile->token_list.directive;
1199   unsigned int len = 0;
1200
1201   predicate = _cpp_get_raw_token (pfile);
1202   if (predicate->type == CPP_EOF)
1203     {
1204       cpp_error (pfile, "assertion without predicate");
1205       return 0;
1206     }
1207   else if (predicate->type != CPP_NAME)
1208     {
1209       cpp_error (pfile, "predicate must be an identifier");
1210       return 0;
1211     }
1212
1213   token = _cpp_get_raw_token (pfile);
1214   if (token->type != CPP_OPEN_PAREN)
1215     {
1216       /* #unassert and #if are OK without predicate.  */
1217       if (d == &dtable[T_UNASSERT])
1218         {
1219           if (token->type == CPP_EOF)
1220             goto lookup_node;
1221         }
1222       else if (d != &dtable[T_ASSERT])
1223         {
1224           _cpp_push_token (pfile, token);
1225           goto lookup_node;
1226         }
1227       cpp_error (pfile, "missing '(' after predicate");
1228       return 0;
1229     }
1230
1231   /* Allocate a struct answer, and copy the answer to it.  */
1232   answer = (struct answer *) xmalloc (sizeof (struct answer));
1233   list = &answer->list;
1234   _cpp_init_toklist (list, NO_DUMMY_TOKEN);
1235
1236   for (;;)
1237     {
1238       cpp_token *dest;
1239
1240       token = _cpp_get_raw_token (pfile);
1241
1242       if (token->type == CPP_EOF)
1243         {
1244           cpp_error (pfile, "missing ')' to complete answer");
1245           goto error;
1246         }
1247       if (token->type == CPP_CLOSE_PAREN)
1248         break;
1249
1250       /* Copy the token.  */
1251       _cpp_expand_token_space (list, 1);
1252       dest = &list->tokens[list->tokens_used++];
1253       *dest = *token;
1254
1255       if (TOKEN_SPELL (token) == SPELL_STRING)
1256         {
1257           _cpp_expand_name_space (list, token->val.str.len);
1258           dest->val.str.text = list->namebuf + list->name_used;
1259           memcpy (list->namebuf + list->name_used,
1260                   token->val.str.text, token->val.str.len);
1261           list->name_used += token->val.str.len;
1262         }
1263     }
1264
1265   if (list->tokens_used == 0)
1266     {
1267       cpp_error (pfile, "predicate's answer is empty");
1268       goto error;
1269     }
1270
1271   /* Drop whitespace at start.  */
1272   list->tokens[0].flags &= ~PREV_WHITE;
1273
1274   if ((d == &dtable[T_ASSERT] || d == &dtable[T_UNASSERT])
1275       && token[1].type != CPP_EOF)
1276     {
1277       cpp_error (pfile, "junk at end of assertion");
1278       goto error;
1279     }
1280
1281  lookup_node:
1282   *answerp = answer;
1283   len = predicate->val.node->length;
1284   sym = alloca (len + 1);
1285
1286   /* Prefix '#' to get it out of macro namespace.  */
1287   sym[0] = '#';
1288   memcpy (sym + 1, predicate->val.node->name, len);
1289   return cpp_lookup (pfile, sym, len + 1);
1290
1291  error:
1292   FREE_ANSWER (answer);
1293   return 0;
1294 }
1295
1296 /* Returns a pointer to the pointer to the answer in the answer chain,
1297    or a pointer to NULL if the answer is not in the chain.  */
1298 struct answer **
1299 _cpp_find_answer (node, candidate)
1300      cpp_hashnode *node;
1301      const cpp_toklist *candidate;
1302 {
1303   struct answer **result;
1304
1305   for (result = &node->value.answers; *result; result = &(*result)->next)
1306     if (_cpp_equiv_toklists (&(*result)->list, candidate))
1307       break;
1308
1309   return result;
1310 }
1311
1312 #define WARNING(msgid) do { cpp_warning(pfile, msgid); goto error; } while (0)
1313 #define ERROR(msgid) do { cpp_error(pfile, msgid); goto error; } while (0)
1314 #define ICE(msgid) do { cpp_ice(pfile, msgid); goto error; } while (0)
1315 static void
1316 do_assert (pfile)
1317      cpp_reader *pfile;
1318 {
1319   struct answer *new_answer;
1320   cpp_hashnode *node;
1321
1322   node = _cpp_parse_assertion (pfile, &new_answer);
1323   if (node)
1324     {
1325       new_answer->next = 0;
1326       new_answer->list.line = pfile->token_list.line;
1327       new_answer->list.file = pfile->token_list.file;
1328
1329       if (node->type == T_ASSERTION)
1330         {
1331           if (*_cpp_find_answer (node, &new_answer->list))
1332             goto err;
1333           new_answer->next = node->value.answers;
1334         }
1335       node->type = T_ASSERTION;
1336       node->value.answers = new_answer;
1337     }
1338   return;
1339
1340  err:
1341   cpp_warning (pfile, "\"%s\" re-asserted", node->name + 1);
1342   FREE_ANSWER (new_answer);
1343 }
1344
1345 static void
1346 do_unassert (pfile)
1347      cpp_reader *pfile;
1348 {
1349   cpp_hashnode *node;
1350   struct answer *answer, *temp, *next;
1351
1352   node = _cpp_parse_assertion (pfile, &answer);
1353   if (node)
1354     {
1355       /* It isn't an error to #unassert something that isn't asserted.  */
1356       if (node->type == T_ASSERTION)
1357         {
1358           if (answer)
1359             {
1360               struct answer **p = _cpp_find_answer (node, &answer->list);
1361
1362               temp = *p;
1363               if (temp)
1364                 {
1365                   *p = temp->next;
1366                   FREE_ANSWER (temp);
1367                 }
1368               if (node->value.answers == 0)
1369                 node->type = T_VOID;
1370             }
1371           else
1372             {
1373               for (temp = node->value.answers; temp; temp = next)
1374                 {
1375                   next = temp->next;
1376                   FREE_ANSWER (temp);
1377                 }
1378               node->type = T_VOID;
1379             }
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);
1425 }
1426
1427 /* Process MACRO as if it appeared as the body of an #undef.  */
1428 void
1429 cpp_undef (pfile, macro)
1430      cpp_reader *pfile;
1431      const char *macro;
1432 {
1433   _cpp_run_directive (pfile, &dtable[T_UNDEF], macro, strlen (macro));
1434 }
1435
1436 /* Process the string STR as if it appeared as the body of a #assert. */
1437 void
1438 cpp_assert (pfile, str)
1439      cpp_reader *pfile;
1440      const char *str;
1441 {
1442   _cpp_run_directive (pfile, &dtable[T_ASSERT], str, strlen (str));
1443 }
1444
1445 /* Process STR as if it appeared as the body of an #unassert. */
1446 void
1447 cpp_unassert (pfile, str)
1448      cpp_reader *pfile;
1449      const char *str;
1450 {
1451   _cpp_run_directive (pfile, &dtable[T_UNASSERT], str, strlen (str));
1452 }
1453
1454 /* Determine whether the identifier ID, of length LEN, is a defined macro.  */
1455 int
1456 cpp_defined (pfile, id, len)
1457      cpp_reader *pfile;
1458      const U_CHAR *id;
1459      int len;
1460 {
1461   cpp_hashnode *hp = cpp_lookup (pfile, id, len);
1462   if (hp->type == T_POISON)
1463     {
1464       cpp_error (pfile, "attempt to use poisoned \"%s\"", hp->name);
1465       return 0;
1466     }
1467   return (hp->type != T_VOID);
1468 }
1469
1470 /* Allocate a new cpp_buffer for PFILE, and push it on the input buffer stack.
1471    If BUFFER != NULL, then use the LENGTH characters in BUFFER
1472    as the new input buffer.
1473    Return the new buffer, or NULL on failure.  */
1474
1475 cpp_buffer *
1476 cpp_push_buffer (pfile, buffer, length)
1477      cpp_reader *pfile;
1478      const U_CHAR *buffer;
1479      long length;
1480 {
1481   cpp_buffer *buf = CPP_BUFFER (pfile);
1482   cpp_buffer *new;
1483   if (++pfile->buffer_stack_depth == CPP_STACK_MAX)
1484     {
1485       cpp_fatal (pfile, "#include nested too deep");
1486       return NULL;
1487     }
1488   if (pfile->cur_context > 0)
1489     {
1490       cpp_ice (pfile, "buffer pushed with contexts stacked");
1491       _cpp_skip_rest_of_line (pfile);
1492     }
1493
1494   new = xobnew (pfile->buffer_ob, cpp_buffer);
1495   memset (new, 0, sizeof (cpp_buffer));
1496
1497   new->line_base = new->buf = new->cur = buffer;
1498   new->rlimit = buffer + length;
1499   new->prev = buf;
1500
1501   CPP_BUFFER (pfile) = new;
1502   return new;
1503 }
1504
1505 cpp_buffer *
1506 cpp_pop_buffer (pfile)
1507      cpp_reader *pfile;
1508 {
1509   int wfb;
1510   cpp_buffer *buf = CPP_BUFFER (pfile);
1511
1512   unwind_if_stack (pfile, buf);
1513   wfb = (buf->inc != 0);
1514   if (wfb)
1515     _cpp_pop_file_buffer (pfile, buf);
1516
1517   CPP_BUFFER (pfile) = CPP_PREV_BUFFER (buf);
1518   obstack_free (pfile->buffer_ob, buf);
1519   pfile->buffer_stack_depth--;
1520
1521   if (wfb && pfile->cb.leave_file && CPP_BUFFER (pfile))
1522     (*pfile->cb.leave_file) (pfile);
1523
1524   return CPP_BUFFER (pfile);
1525 }
1526
1527 #define obstack_chunk_alloc xmalloc
1528 #define obstack_chunk_free free
1529 #define DSC(x) U x, sizeof x - 1
1530 void
1531 _cpp_init_stacks (pfile)
1532      cpp_reader *pfile;
1533 {
1534   int i;
1535   struct spec_nodes *s;
1536
1537   pfile->buffer_ob = xnew (struct obstack);
1538   obstack_init (pfile->buffer_ob);
1539
1540   /* Perhaps not the ideal place to put this.  */
1541   pfile->spec_nodes = s = xnew (struct spec_nodes);
1542   s->n_L                = cpp_lookup (pfile, DSC("L"));
1543   s->n__STRICT_ANSI__   = cpp_lookup (pfile, DSC("__STRICT_ANSI__"));
1544   s->n__CHAR_UNSIGNED__ = cpp_lookup (pfile, DSC("__CHAR_UNSIGNED__"));
1545   s->n__VA_ARGS__       = cpp_lookup (pfile, DSC("__VA_ARGS__"));
1546   for (i = 0; i < N_DIRECTIVES; i++)
1547     s->dirs[i] = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
1548 }
1549
1550 void
1551 _cpp_cleanup_stacks (pfile)
1552      cpp_reader *pfile;
1553 {
1554   obstack_free (pfile->buffer_ob, 0);
1555   free (pfile->buffer_ob);
1556 }