gcc/cpplib.c

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