libcpp/internal.h

   1 /* Part of CPP library.
   2    Copyright (C) 1997-2020 Free Software Foundation, Inc.
   3
   4 This program is free software; you can redistribute it and/or modify it
   5 under the terms of the GNU General Public License as published by the
   6 Free Software Foundation; either version 3, or (at your option) any
   7 later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; see the file COPYING3.  If not see
  16 <http://www.gnu.org/licenses/>.  */
  17
  18 /* This header defines all the internal data structures and functions
  19    that need to be visible across files.  It should not be used outside
  20    cpplib.  */
  21
  22 #ifndef LIBCPP_INTERNAL_H
  23 #define LIBCPP_INTERNAL_H
  24
  25 #include "symtab.h"
  26 #include "cpplib.h"
  27
  28 #if HAVE_ICONV
  29 #include <iconv.h>
  30 #else
  31 #define HAVE_ICONV 0
  32 typedef int iconv_t;  /* dummy */
  33 #endif
  34
  35 #ifdef __cplusplus
  36 extern "C" {
  37 #endif
  38
  39 struct directive;               /* Deliberately incomplete.  */
  40 struct pending_option;
  41 struct op;
  42 struct _cpp_strbuf;
  43
  44 typedef bool (*convert_f) (iconv_t, const unsigned char *, size_t,
  45                            struct _cpp_strbuf *);
  46 struct cset_converter
  47 {
  48   convert_f func;
  49   iconv_t cd;
  50   int width;
  51 };
  52
  53 #define BITS_PER_CPPCHAR_T (CHAR_BIT * sizeof (cppchar_t))
  54
  55 /* Test if a sign is valid within a preprocessing number.  */
  56 #define VALID_SIGN(c, prevc) \
  57   (((c) == '+' || (c) == '-') && \
  58    ((prevc) == 'e' || (prevc) == 'E' \
  59     || (((prevc) == 'p' || (prevc) == 'P') \
  60         && CPP_OPTION (pfile, extended_numbers))))
  61
  62 #define DIGIT_SEP(c) ((c) == '\'' && CPP_OPTION (pfile, digit_separators))
  63
  64 #define CPP_OPTION(PFILE, OPTION) ((PFILE)->opts.OPTION)
  65 #define CPP_BUFFER(PFILE) ((PFILE)->buffer)
  66 #define CPP_BUF_COLUMN(BUF, CUR) ((CUR) - (BUF)->line_base)
  67 #define CPP_BUF_COL(BUF) CPP_BUF_COLUMN(BUF, (BUF)->cur)
  68
  69 #define CPP_INCREMENT_LINE(PFILE, COLS_HINT) do { \
  70     const class line_maps *line_table = PFILE->line_table; \
  71     const struct line_map_ordinary *map = \
  72       LINEMAPS_LAST_ORDINARY_MAP (line_table); \
  73     linenum_type line = SOURCE_LINE (map, line_table->highest_line); \
  74     linemap_line_start (PFILE->line_table, line + 1, COLS_HINT); \
  75   } while (0)
  76
  77 /* Host alignment handling.  */
  78 struct dummy
  79 {
  80   char c;
  81   union
  82   {
  83     double d;
  84     int *p;
  85   } u;
  86 };
  87
  88 #define DEFAULT_ALIGNMENT offsetof (struct dummy, u)
  89 #define CPP_ALIGN2(size, align) (((size) + ((align) - 1)) & ~((align) - 1))
  90 #define CPP_ALIGN(size) CPP_ALIGN2 (size, DEFAULT_ALIGNMENT)
  91
  92 #define _cpp_mark_macro_used(NODE)                                      \
  93   (cpp_user_macro_p (NODE) ? (NODE)->value.macro->used = 1 : 0)
  94
  95 /* A generic memory buffer, and operations on it.  */
  96 typedef struct _cpp_buff _cpp_buff;
  97 struct _cpp_buff
  98 {
  99   struct _cpp_buff *next;
 100   unsigned char *base, *cur, *limit;
 101 };
 102
 103 extern _cpp_buff *_cpp_get_buff (cpp_reader *, size_t);
 104 extern void _cpp_release_buff (cpp_reader *, _cpp_buff *);
 105 extern void _cpp_extend_buff (cpp_reader *, _cpp_buff **, size_t);
 106 extern _cpp_buff *_cpp_append_extend_buff (cpp_reader *, _cpp_buff *, size_t);
 107 extern void _cpp_free_buff (_cpp_buff *);
 108 extern unsigned char *_cpp_aligned_alloc (cpp_reader *, size_t);
 109 extern unsigned char *_cpp_unaligned_alloc (cpp_reader *, size_t);
 110
 111 #define BUFF_ROOM(BUFF) (size_t) ((BUFF)->limit - (BUFF)->cur)
 112 #define BUFF_FRONT(BUFF) ((BUFF)->cur)
 113 #define BUFF_LIMIT(BUFF) ((BUFF)->limit)
 114
 115 /* #include types.  */
 116 enum include_type
 117   {
 118    /* Directive-based including mechanisms.  */
 119    IT_INCLUDE,  /* #include */
 120    IT_INCLUDE_NEXT,  /* #include_next */
 121    IT_IMPORT,   /* #import  */
 122
 123    /* Non-directive including mechanisms.  */
 124    IT_CMDLINE,  /* -include */
 125    IT_DEFAULT,  /* forced header  */
 126    IT_MAIN,     /* main  */
 127
 128    IT_DIRECTIVE_HWM = IT_IMPORT + 1,  /* Directives below this.  */
 129    IT_HEADER_HWM = IT_DEFAULT + 1     /* Header files below this.  */
 130   };
 131
 132 union utoken
 133 {
 134   const cpp_token *token;
 135   const cpp_token **ptoken;
 136 };
 137
 138 /* A "run" of tokens; part of a chain of runs.  */
 139 typedef struct tokenrun tokenrun;
 140 struct tokenrun
 141 {
 142   tokenrun *next, *prev;
 143   cpp_token *base, *limit;
 144 };
 145
 146 /* Accessor macros for struct cpp_context.  */
 147 #define FIRST(c) ((c)->u.iso.first)
 148 #define LAST(c) ((c)->u.iso.last)
 149 #define CUR(c) ((c)->u.trad.cur)
 150 #define RLIMIT(c) ((c)->u.trad.rlimit)
 151
 152 /* This describes some additional data that is added to the macro
 153    token context of type cpp_context, when -ftrack-macro-expansion is
 154    on.  */
 155 typedef struct
 156 {
 157   /* The node of the macro we are referring to.  */
 158   cpp_hashnode *macro_node;
 159   /* This buffer contains an array of virtual locations.  The virtual
 160      location at index 0 is the virtual location of the token at index
 161      0 in the current instance of cpp_context; similarly for all the
 162      other virtual locations.  */
 163   location_t *virt_locs;
 164   /* This is a pointer to the current virtual location.  This is used
 165      to iterate over the virtual locations while we iterate over the
 166      tokens they belong to.  */
 167   location_t *cur_virt_loc;
 168 } macro_context;
 169
 170 /* The kind of tokens carried by a cpp_context.  */
 171 enum context_tokens_kind {
 172   /* This is the value of cpp_context::tokens_kind if u.iso.first
 173      contains an instance of cpp_token **.  */
 174   TOKENS_KIND_INDIRECT,
 175   /* This is the value of cpp_context::tokens_kind if u.iso.first
 176      contains an instance of cpp_token *.  */
 177   TOKENS_KIND_DIRECT,
 178   /* This is the value of cpp_context::tokens_kind when the token
 179      context contains tokens resulting from macro expansion.  In that
 180      case struct cpp_context::macro points to an instance of struct
 181      macro_context.  This is used only when the
 182      -ftrack-macro-expansion flag is on.  */
 183   TOKENS_KIND_EXTENDED
 184 };
 185
 186 typedef struct cpp_context cpp_context;
 187 struct cpp_context
 188 {
 189   /* Doubly-linked list.  */
 190   cpp_context *next, *prev;
 191
 192   union
 193   {
 194     /* For ISO macro expansion.  Contexts other than the base context
 195        are contiguous tokens.  e.g. macro expansions, expanded
 196        argument tokens.  */
 197     struct
 198     {
 199       union utoken first;
 200       union utoken last;
 201     } iso;
 202
 203     /* For traditional macro expansion.  */
 204     struct
 205     {
 206       const unsigned char *cur;
 207       const unsigned char *rlimit;
 208     } trad;
 209   } u;
 210
 211   /* If non-NULL, a buffer used for storage related to this context.
 212      When the context is popped, the buffer is released.  */
 213   _cpp_buff *buff;
 214
 215   /* If tokens_kind is TOKEN_KIND_EXTENDED, then (as we thus are in a
 216      macro context) this is a pointer to an instance of macro_context.
 217      Otherwise if tokens_kind is *not* TOKEN_KIND_EXTENDED, then, if
 218      we are in a macro context, this is a pointer to an instance of
 219      cpp_hashnode, representing the name of the macro this context is
 220      for.  If we are not in a macro context, then this is just NULL.
 221      Note that when tokens_kind is TOKEN_KIND_EXTENDED, the memory
 222      used by the instance of macro_context pointed to by this member
 223      is de-allocated upon de-allocation of the instance of struct
 224      cpp_context.  */
 225   union
 226   {
 227     macro_context *mc;
 228     cpp_hashnode *macro;
 229   } c;
 230
 231   /* This determines the type of tokens held by this context.  */
 232   enum context_tokens_kind tokens_kind;
 233 };
 234
 235 struct lexer_state
 236 {
 237   /* 1 if we're handling a directive.  2 if it's an include-like
 238      directive.  */
 239   unsigned char in_directive;
 240
 241   /* Nonzero if in a directive that will handle padding tokens itself.
 242      #include needs this to avoid problems with computed include and
 243      spacing between tokens.  */
 244   unsigned char directive_wants_padding;
 245
 246   /* True if we are skipping a failed conditional group.  */
 247   unsigned char skipping;
 248
 249   /* Nonzero if in a directive that takes angle-bracketed headers.  */
 250   unsigned char angled_headers;
 251
 252   /* Nonzero if in a #if or #elif directive.  */
 253   unsigned char in_expression;
 254
 255   /* Nonzero to save comments.  Turned off if discard_comments, and in
 256      all directives apart from #define.  */
 257   unsigned char save_comments;
 258
 259   /* Nonzero if lexing __VA_ARGS__ and __VA_OPT__ are valid.  */
 260   unsigned char va_args_ok;
 261
 262   /* Nonzero if lexing poisoned identifiers is valid.  */
 263   unsigned char poisoned_ok;
 264
 265   /* Nonzero to prevent macro expansion.  */
 266   unsigned char prevent_expansion;
 267
 268   /* Nonzero when parsing arguments to a function-like macro.  */
 269   unsigned char parsing_args;
 270
 271   /* Nonzero if prevent_expansion is true only because output is
 272      being discarded.  */
 273   unsigned char discarding_output;
 274
 275   /* Nonzero to skip evaluating part of an expression.  */
 276   unsigned int skip_eval;
 277
 278   /* Nonzero when handling a deferred pragma.  */
 279   unsigned char in_deferred_pragma;
 280
 281   /* Nonzero if the deferred pragma being handled allows macro expansion.  */
 282   unsigned char pragma_allow_expansion;
 283 };
 284
 285 /* Special nodes - identifiers with predefined significance.  */
 286 struct spec_nodes
 287 {
 288   cpp_hashnode *n_defined;              /* defined operator */
 289   cpp_hashnode *n_true;                 /* C++ keyword true */
 290   cpp_hashnode *n_false;                /* C++ keyword false */
 291   cpp_hashnode *n__VA_ARGS__;           /* C99 vararg macros */
 292   cpp_hashnode *n__VA_OPT__;            /* C++ vararg macros */
 293 };
 294
 295 typedef struct _cpp_line_note _cpp_line_note;
 296 struct _cpp_line_note
 297 {
 298   /* Location in the clean line the note refers to.  */
 299   const unsigned char *pos;
 300
 301   /* Type of note.  The 9 'from' trigraph characters represent those
 302      trigraphs, '\\' an escaped newline, ' ' an escaped newline with
 303      intervening space, 0 represents a note that has already been handled,
 304      and anything else is invalid.  */
 305   unsigned int type;
 306 };
 307
 308 /* Represents the contents of a file cpplib has read in.  */
 309 struct cpp_buffer
 310 {
 311   const unsigned char *cur;        /* Current location.  */
 312   const unsigned char *line_base;  /* Start of current physical line.  */
 313   const unsigned char *next_line;  /* Start of to-be-cleaned logical line.  */
 314
 315   const unsigned char *buf;        /* Entire character buffer.  */
 316   const unsigned char *rlimit;     /* Writable byte at end of file.  */
 317   const unsigned char *to_free;    /* Pointer that should be freed when
 318                                       popping the buffer.  */
 319
 320   _cpp_line_note *notes;           /* Array of notes.  */
 321   unsigned int cur_note;           /* Next note to process.  */
 322   unsigned int notes_used;         /* Number of notes.  */
 323   unsigned int notes_cap;          /* Size of allocated array.  */
 324
 325   struct cpp_buffer *prev;
 326
 327   /* Pointer into the file table; non-NULL if this is a file buffer.
 328      Used for include_next and to record control macros.  */
 329   struct _cpp_file *file;
 330
 331   /* Saved value of __TIMESTAMP__ macro - date and time of last modification
 332      of the assotiated file.  */
 333   const unsigned char *timestamp;
 334
 335   /* Value of if_stack at start of this file.
 336      Used to prohibit unmatched #endif (etc) in an include file.  */
 337   struct if_stack *if_stack;
 338
 339   /* True if we need to get the next clean line.  */
 340   bool need_line : 1;
 341
 342   /* True if we have already warned about C++ comments in this file.
 343      The warning happens only for C89 extended mode with -pedantic on,
 344      or for -Wtraditional, and only once per file (otherwise it would
 345      be far too noisy).  */
 346   bool warned_cplusplus_comments : 1;
 347
 348   /* True if we don't process trigraphs and escaped newlines.  True
 349      for preprocessed input, command line directives, and _Pragma
 350      buffers.  */
 351   bool from_stage3 : 1;
 352
 353   /* At EOF, a buffer is automatically popped.  If RETURN_AT_EOF is
 354      true, a CPP_EOF token is then returned.  Otherwise, the next
 355      token from the enclosing buffer is returned.  */
 356   bool return_at_eof : 1;
 357
 358   /* One for a system header, two for a C system header file that therefore
 359      needs to be extern "C" protected in C++, and zero otherwise.  */
 360   unsigned char sysp;
 361
 362   /* The directory of the this buffer's file.  Its NAME member is not
 363      allocated, so we don't need to worry about freeing it.  */
 364   struct cpp_dir dir;
 365
 366   /* Descriptor for converting from the input character set to the
 367      source character set.  */
 368   struct cset_converter input_cset_desc;
 369 };
 370
 371 /* The list of saved macros by push_macro pragma.  */
 372 struct def_pragma_macro {
 373   /* Chain element to previous saved macro.  */
 374   struct def_pragma_macro *next;
 375   /* Name of the macro.  */
 376   char *name;
 377   /* The stored macro content.  */
 378   unsigned char *definition;
 379
 380   /* Definition line number.  */
 381   location_t line;
 382   /* If macro defined in system header.  */
 383   unsigned int syshdr   : 1;
 384   /* Nonzero if it has been expanded or had its existence tested.  */
 385   unsigned int used     : 1;
 386
 387   /* Mark if we save an undefined macro.  */
 388   unsigned int is_undef : 1;
 389   /* Nonzero if it was a builtin macro.  */
 390   unsigned int is_builtin : 1;
 391 };
 392
 393 /* A cpp_reader encapsulates the "state" of a pre-processor run.
 394    Applying cpp_get_token repeatedly yields a stream of pre-processor
 395    tokens.  Usually, there is only one cpp_reader object active.  */
 396 struct cpp_reader
 397 {
 398   /* Top of buffer stack.  */
 399   cpp_buffer *buffer;
 400
 401   /* Overlaid buffer (can be different after processing #include).  */
 402   cpp_buffer *overlaid_buffer;
 403
 404   /* Lexer state.  */
 405   struct lexer_state state;
 406
 407   /* Source line tracking.  */
 408   class line_maps *line_table;
 409
 410   /* The line of the '#' of the current directive.  */
 411   location_t directive_line;
 412
 413   /* Memory buffers.  */
 414   _cpp_buff *a_buff;            /* Aligned permanent storage.  */
 415   _cpp_buff *u_buff;            /* Unaligned permanent storage.  */
 416   _cpp_buff *free_buffs;        /* Free buffer chain.  */
 417
 418   /* Context stack.  */
 419   struct cpp_context base_context;
 420   struct cpp_context *context;
 421
 422   /* If in_directive, the directive if known.  */
 423   const struct directive *directive;
 424
 425   /* Token generated while handling a directive, if any. */
 426   cpp_token directive_result;
 427
 428   /* When expanding a macro at top-level, this is the location of the
 429      macro invocation.  */
 430   location_t invocation_location;
 431
 432   /* This is the node representing the macro being expanded at
 433      top-level.  The value of this data member is valid iff
 434      cpp_in_macro_expansion_p() returns TRUE.  */
 435   cpp_hashnode *top_most_macro_node;
 436
 437   /* Nonzero if we are about to expand a macro.  Note that if we are
 438      really expanding a macro, the function macro_of_context returns
 439      the macro being expanded and this flag is set to false.  Client
 440      code should use the function cpp_in_macro_expansion_p to know if we
 441      are either about to expand a macro, or are actually expanding
 442      one.  */
 443   bool about_to_expand_macro_p;
 444
 445   /* Search paths for include files.  */
 446   struct cpp_dir *quote_include;        /* "" */
 447   struct cpp_dir *bracket_include;      /* <> */
 448   struct cpp_dir no_search_path;        /* No path.  */
 449
 450   /* Chain of all hashed _cpp_file instances.  */
 451   struct _cpp_file *all_files;
 452
 453   struct _cpp_file *main_file;
 454
 455   /* File and directory hash table.  */
 456   struct htab *file_hash;
 457   struct htab *dir_hash;
 458   struct file_hash_entry_pool *file_hash_entries;
 459
 460   /* Negative path lookup hash table.  */
 461   struct htab *nonexistent_file_hash;
 462   struct obstack nonexistent_file_ob;
 463
 464   /* Nonzero means don't look for #include "foo" the source-file
 465      directory.  */
 466   bool quote_ignores_source_dir;
 467
 468   /* Nonzero if any file has contained #pragma once or #import has
 469      been used.  */
 470   bool seen_once_only;
 471
 472   /* Multiple include optimization.  */
 473   const cpp_hashnode *mi_cmacro;
 474   const cpp_hashnode *mi_ind_cmacro;
 475   bool mi_valid;
 476
 477   /* Lexing.  */
 478   cpp_token *cur_token;
 479   tokenrun base_run, *cur_run;
 480   unsigned int lookaheads;
 481
 482   /* Nonzero prevents the lexer from re-using the token runs.  */
 483   unsigned int keep_tokens;
 484
 485   /* Buffer to hold macro definition string.  */
 486   unsigned char *macro_buffer;
 487   unsigned int macro_buffer_len;
 488
 489   /* Descriptor for converting from the source character set to the
 490      execution character set.  */
 491   struct cset_converter narrow_cset_desc;
 492
 493   /* Descriptor for converting from the source character set to the
 494      UTF-8 execution character set.  */
 495   struct cset_converter utf8_cset_desc;
 496
 497   /* Descriptor for converting from the source character set to the
 498      UTF-16 execution character set.  */
 499   struct cset_converter char16_cset_desc;
 500
 501   /* Descriptor for converting from the source character set to the
 502      UTF-32 execution character set.  */
 503   struct cset_converter char32_cset_desc;
 504
 505   /* Descriptor for converting from the source character set to the
 506      wide execution character set.  */
 507   struct cset_converter wide_cset_desc;
 508
 509   /* Date and time text.  Calculated together if either is requested.  */
 510   const unsigned char *date;
 511   const unsigned char *time;
 512
 513   /* Externally set timestamp to replace current date and time useful for
 514      reproducibility.  It should be initialized to -2 (not yet set) and
 515      set to -1 to disable it or to a non-negative value to enable it.  */
 516   time_t source_date_epoch;
 517
 518   /* EOF token, and a token forcing paste avoidance.  */
 519   cpp_token avoid_paste;
 520   cpp_token eof;
 521
 522   /* Opaque handle to the dependencies of mkdeps.c.  */
 523   class mkdeps *deps;
 524
 525   /* Obstack holding all macro hash nodes.  This never shrinks.
 526      See identifiers.c */
 527   struct obstack hash_ob;
 528
 529   /* Obstack holding buffer and conditional structures.  This is a
 530      real stack.  See directives.c.  */
 531   struct obstack buffer_ob;
 532
 533   /* Pragma table - dynamic, because a library user can add to the
 534      list of recognized pragmas.  */
 535   struct pragma_entry *pragmas;
 536
 537   /* Call backs to cpplib client.  */
 538   struct cpp_callbacks cb;
 539
 540   /* Identifier hash table.  */
 541   struct ht *hash_table;
 542
 543   /* Expression parser stack.  */
 544   struct op *op_stack, *op_limit;
 545
 546   /* User visible options.  */
 547   struct cpp_options opts;
 548
 549   /* Special nodes - identifiers with predefined significance to the
 550      preprocessor.  */
 551   struct spec_nodes spec_nodes;
 552
 553   /* Whether cpplib owns the hashtable.  */
 554   bool our_hashtable;
 555
 556   /* Traditional preprocessing output buffer (a logical line).  */
 557   struct
 558   {
 559     unsigned char *base;
 560     unsigned char *limit;
 561     unsigned char *cur;
 562     location_t first_line;
 563   } out;
 564
 565   /* Used for buffer overlays by traditional.c.  */
 566   const unsigned char *saved_cur, *saved_rlimit, *saved_line_base;
 567
 568   /* A saved list of the defined macros, for dependency checking
 569      of precompiled headers.  */
 570   struct cpp_savedstate *savedstate;
 571
 572   /* Next value of __COUNTER__ macro. */
 573   unsigned int counter;
 574
 575   /* Table of comments, when state.save_comments is true.  */
 576   cpp_comment_table comments;
 577
 578   /* List of saved macros by push_macro.  */
 579   struct def_pragma_macro *pushed_macros;
 580
 581   /* If non-zero, the lexer will use this location for the next token
 582      instead of getting a location from the linemap.  */
 583   location_t forced_token_location;
 584 };
 585
 586 /* Character classes.  Based on the more primitive macros in safe-ctype.h.
 587    If the definition of `numchar' looks odd to you, please look up the
 588    definition of a pp-number in the C standard [section 6.4.8 of C99].
 589
 590    In the unlikely event that characters other than \r and \n enter
 591    the set is_vspace, the macro handle_newline() in lex.c must be
 592    updated.  */
 593 #define _dollar_ok(x)   ((x) == '$' && CPP_OPTION (pfile, dollars_in_ident))
 594
 595 #define is_idchar(x)    (ISIDNUM(x) || _dollar_ok(x))
 596 #define is_numchar(x)   ISIDNUM(x)
 597 #define is_idstart(x)   (ISIDST(x) || _dollar_ok(x))
 598 #define is_numstart(x)  ISDIGIT(x)
 599 #define is_hspace(x)    ISBLANK(x)
 600 #define is_vspace(x)    IS_VSPACE(x)
 601 #define is_nvspace(x)   IS_NVSPACE(x)
 602 #define is_space(x)     IS_SPACE_OR_NUL(x)
 603
 604 #define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
 605
 606 /* This table is constant if it can be initialized at compile time,
 607    which is the case if cpp was compiled with GCC >=2.7, or another
 608    compiler that supports C99.  */
 609 #if HAVE_DESIGNATED_INITIALIZERS
 610 extern const unsigned char _cpp_trigraph_map[UCHAR_MAX + 1];
 611 #else
 612 extern unsigned char _cpp_trigraph_map[UCHAR_MAX + 1];
 613 #endif
 614
 615 #if !defined (HAVE_UCHAR) && !defined (IN_GCC)
 616 typedef unsigned char uchar;
 617 #endif
 618
 619 #define UC (const uchar *)  /* Intended use: UC"string" */
 620
 621 /* Macros.  */
 622
 623 static inline int cpp_in_system_header (cpp_reader *);
 624 static inline int
 625 cpp_in_system_header (cpp_reader *pfile)
 626 {
 627   return pfile->buffer ? pfile->buffer->sysp : 0;
 628 }
 629 #define CPP_PEDANTIC(PF) CPP_OPTION (PF, cpp_pedantic)
 630 #define CPP_WTRADITIONAL(PF) CPP_OPTION (PF, cpp_warn_traditional)
 631
 632 static inline int cpp_in_primary_file (cpp_reader *);
 633 static inline int
 634 cpp_in_primary_file (cpp_reader *pfile)
 635 {
 636   return pfile->line_table->depth == 1;
 637 }
 638
 639 /* True if NODE is a macro for the purposes of ifdef, defined etc.  */
 640 inline bool _cpp_defined_macro_p (cpp_hashnode *node)
 641 {
 642   /* Do not treat conditional macros as being defined.  This is due to
 643      the powerpc port using conditional macros for 'vector', 'bool',
 644      and 'pixel' to act as conditional keywords.  This messes up tests
 645      like #ifndef bool.  */
 646   return cpp_macro_p (node) && !(node->flags & NODE_CONDITIONAL);
 647 }
 648
 649 /* In macro.c */
 650 extern void _cpp_notify_macro_use (cpp_reader *pfile, cpp_hashnode *node);
 651 inline void _cpp_maybe_notify_macro_use (cpp_reader *pfile, cpp_hashnode *node)
 652 {
 653   if (!(node->flags & NODE_USED))
 654     _cpp_notify_macro_use (pfile, node);
 655 }
 656 extern cpp_macro *_cpp_new_macro (cpp_reader *, cpp_macro_kind, void *);
 657 extern void _cpp_free_definition (cpp_hashnode *);
 658 extern bool _cpp_create_definition (cpp_reader *, cpp_hashnode *);
 659 extern void _cpp_pop_context (cpp_reader *);
 660 extern void _cpp_push_text_context (cpp_reader *, cpp_hashnode *,
 661                                     const unsigned char *, size_t);
 662 extern bool _cpp_save_parameter (cpp_reader *, unsigned, cpp_hashnode *,
 663                                  cpp_hashnode *);
 664 extern void _cpp_unsave_parameters (cpp_reader *, unsigned);
 665 extern bool _cpp_arguments_ok (cpp_reader *, cpp_macro *, const cpp_hashnode *,
 666                                unsigned int);
 667 extern const unsigned char *_cpp_builtin_macro_text (cpp_reader *,
 668                                                      cpp_hashnode *,
 669                                                      location_t = 0);
 670 extern int _cpp_warn_if_unused_macro (cpp_reader *, cpp_hashnode *, void *);
 671 extern void _cpp_push_token_context (cpp_reader *, cpp_hashnode *,
 672                                      const cpp_token *, unsigned int);
 673 extern void _cpp_backup_tokens_direct (cpp_reader *, unsigned int);
 674
 675 /* In identifiers.c */
 676 extern void _cpp_init_hashtable (cpp_reader *, cpp_hash_table *);
 677 extern void _cpp_destroy_hashtable (cpp_reader *);
 678
 679 /* In files.c */
 680 typedef struct _cpp_file _cpp_file;
 681 extern _cpp_file *_cpp_find_file (cpp_reader *, const char *, cpp_dir *,
 682                                   int angle, bool fake, bool preinclude,
 683                                   bool has_include, location_t);
 684 extern bool _cpp_find_failed (_cpp_file *);
 685 extern void _cpp_mark_file_once_only (cpp_reader *, struct _cpp_file *);
 686 extern void _cpp_fake_include (cpp_reader *, const char *);
 687 extern bool _cpp_stack_file (cpp_reader *, _cpp_file*, include_type, location_t);
 688 extern bool _cpp_stack_include (cpp_reader *, const char *, int,
 689                                 enum include_type, location_t);
 690 extern int _cpp_compare_file_date (cpp_reader *, const char *, int);
 691 extern void _cpp_report_missing_guards (cpp_reader *);
 692 extern void _cpp_init_files (cpp_reader *);
 693 extern void _cpp_cleanup_files (cpp_reader *);
 694 extern void _cpp_pop_file_buffer (cpp_reader *, struct _cpp_file *,
 695                                   const unsigned char *);
 696 extern bool _cpp_save_file_entries (cpp_reader *pfile, FILE *f);
 697 extern bool _cpp_read_file_entries (cpp_reader *, FILE *);
 698 extern const char *_cpp_get_file_name (_cpp_file *);
 699 extern struct stat *_cpp_get_file_stat (_cpp_file *);
 700 extern bool _cpp_has_header (cpp_reader *, const char *, int,
 701                              enum include_type);
 702
 703 /* In expr.c */
 704 extern bool _cpp_parse_expr (cpp_reader *, bool);
 705 extern struct op *_cpp_expand_op_stack (cpp_reader *);
 706
 707 /* In lex.c */
 708 extern void _cpp_process_line_notes (cpp_reader *, int);
 709 extern void _cpp_clean_line (cpp_reader *);
 710 extern bool _cpp_get_fresh_line (cpp_reader *);
 711 extern bool _cpp_skip_block_comment (cpp_reader *);
 712 extern cpp_token *_cpp_temp_token (cpp_reader *);
 713 extern const cpp_token *_cpp_lex_token (cpp_reader *);
 714 extern cpp_token *_cpp_lex_direct (cpp_reader *);
 715 extern unsigned char *_cpp_spell_ident_ucns (unsigned char *, cpp_hashnode *);
 716 extern int _cpp_equiv_tokens (const cpp_token *, const cpp_token *);
 717 extern void _cpp_init_tokenrun (tokenrun *, unsigned int);
 718 extern cpp_hashnode *_cpp_lex_identifier (cpp_reader *, const char *);
 719 extern int _cpp_remaining_tokens_num_in_context (cpp_context *);
 720 extern void _cpp_init_lexer (void);
 721 static inline void *_cpp_reserve_room (cpp_reader *pfile, size_t have,
 722                                        size_t extra)
 723 {
 724   if (BUFF_ROOM (pfile->a_buff) < (have + extra))
 725     _cpp_extend_buff (pfile, &pfile->a_buff, extra);
 726   return BUFF_FRONT (pfile->a_buff);
 727 }
 728 extern void *_cpp_commit_buff (cpp_reader *pfile, size_t size);
 729
 730 /* In init.c.  */
 731 extern void _cpp_maybe_push_include_file (cpp_reader *);
 732 extern const char *cpp_named_operator2name (enum cpp_ttype type);
 733 extern void _cpp_restore_special_builtin (cpp_reader *pfile,
 734                                           struct def_pragma_macro *);
 735
 736 /* In directives.c */
 737 extern int _cpp_test_assertion (cpp_reader *, unsigned int *);
 738 extern int _cpp_handle_directive (cpp_reader *, bool);
 739 extern void _cpp_define_builtin (cpp_reader *, const char *);
 740 extern char ** _cpp_save_pragma_names (cpp_reader *);
 741 extern void _cpp_restore_pragma_names (cpp_reader *, char **);
 742 extern int _cpp_do__Pragma (cpp_reader *, location_t);
 743 extern void _cpp_init_directives (cpp_reader *);
 744 extern void _cpp_init_internal_pragmas (cpp_reader *);
 745 extern void _cpp_do_file_change (cpp_reader *, enum lc_reason, const char *,
 746                                  linenum_type, unsigned int);
 747 extern void _cpp_pop_buffer (cpp_reader *);
 748 extern char *_cpp_bracket_include (cpp_reader *);
 749
 750 /* In directives.c */
 751 struct _cpp_dir_only_callbacks
 752 {
 753   /* Called to print a block of lines. */
 754   void (*print_lines) (int, const void *, size_t);
 755   bool (*maybe_print_line) (location_t);
 756 };
 757
 758 extern void _cpp_preprocess_dir_only (cpp_reader *,
 759                                       const struct _cpp_dir_only_callbacks *);
 760
 761 /* In traditional.c.  */
 762 extern bool _cpp_scan_out_logical_line (cpp_reader *, cpp_macro *, bool);
 763 extern bool _cpp_read_logical_line_trad (cpp_reader *);
 764 extern void _cpp_overlay_buffer (cpp_reader *pfile, const unsigned char *,
 765                                  size_t);
 766 extern void _cpp_remove_overlay (cpp_reader *);
 767 extern cpp_macro *_cpp_create_trad_definition (cpp_reader *);
 768 extern bool _cpp_expansions_different_trad (const cpp_macro *,
 769                                             const cpp_macro *);
 770 extern unsigned char *_cpp_copy_replacement_text (const cpp_macro *,
 771                                                   unsigned char *);
 772 extern size_t _cpp_replacement_text_len (const cpp_macro *);
 773
 774 /* In charset.c.  */
 775
 776 /* The normalization state at this point in the sequence.
 777    It starts initialized to all zeros, and at the end
 778    'level' is the normalization level of the sequence.  */
 779
 780 struct normalize_state
 781 {
 782   /* The previous starter character.  */
 783   cppchar_t previous;
 784   /* The combining class of the previous character (whether or not a
 785      starter).  */
 786   unsigned char prev_class;
 787   /* The lowest normalization level so far.  */
 788   enum cpp_normalize_level level;
 789 };
 790 #define INITIAL_NORMALIZE_STATE { 0, 0, normalized_KC }
 791 #define NORMALIZE_STATE_RESULT(st) ((st)->level)
 792
 793 /* We saw a character C that matches ISIDNUM(), update a
 794    normalize_state appropriately.  */
 795 #define NORMALIZE_STATE_UPDATE_IDNUM(st, c)     \
 796   ((st)->previous = (c), (st)->prev_class = 0)
 797
 798 extern bool _cpp_valid_ucn (cpp_reader *, const unsigned char **,
 799                             const unsigned char *, int,
 800                             struct normalize_state *state,
 801                             cppchar_t *,
 802                             source_range *char_range,
 803                             cpp_string_location_reader *loc_reader);
 804
 805 extern bool _cpp_valid_utf8 (cpp_reader *pfile,
 806                              const uchar **pstr,
 807                              const uchar *limit,
 808                              int identifier_pos,
 809                              struct normalize_state *nst,
 810                              cppchar_t *cp);
 811
 812 extern void _cpp_destroy_iconv (cpp_reader *);
 813 extern unsigned char *_cpp_convert_input (cpp_reader *, const char *,
 814                                           unsigned char *, size_t, size_t,
 815                                           const unsigned char **, off_t *);
 816 extern const char *_cpp_default_encoding (void);
 817 extern cpp_hashnode * _cpp_interpret_identifier (cpp_reader *pfile,
 818                                                  const unsigned char *id,
 819                                                  size_t len);
 820
 821 /* Utility routines and macros.  */
 822 #define DSC(str) (const unsigned char *)str, sizeof str - 1
 823
 824 /* These are inline functions instead of macros so we can get type
 825    checking.  */
 826 static inline int ustrcmp (const unsigned char *, const unsigned char *);
 827 static inline int ustrncmp (const unsigned char *, const unsigned char *,
 828                             size_t);
 829 static inline size_t ustrlen (const unsigned char *);
 830 static inline const unsigned char *uxstrdup (const unsigned char *);
 831 static inline const unsigned char *ustrchr (const unsigned char *, int);
 832 static inline int ufputs (const unsigned char *, FILE *);
 833
 834 /* Use a const char for the second parameter since it is usually a literal.  */
 835 static inline int ustrcspn (const unsigned char *, const char *);
 836
 837 static inline int
 838 ustrcmp (const unsigned char *s1, const unsigned char *s2)
 839 {
 840   return strcmp ((const char *)s1, (const char *)s2);
 841 }
 842
 843 static inline int
 844 ustrncmp (const unsigned char *s1, const unsigned char *s2, size_t n)
 845 {
 846   return strncmp ((const char *)s1, (const char *)s2, n);
 847 }
 848
 849 static inline int
 850 ustrcspn (const unsigned char *s1, const char *s2)
 851 {
 852   return strcspn ((const char *)s1, s2);
 853 }
 854
 855 static inline size_t
 856 ustrlen (const unsigned char *s1)
 857 {
 858   return strlen ((const char *)s1);
 859 }
 860
 861 static inline const unsigned char *
 862 uxstrdup (const unsigned char *s1)
 863 {
 864   return (const unsigned char *) xstrdup ((const char *)s1);
 865 }
 866
 867 static inline const unsigned char *
 868 ustrchr (const unsigned char *s1, int c)
 869 {
 870   return (const unsigned char *) strchr ((const char *)s1, c);
 871 }
 872
 873 static inline int
 874 ufputs (const unsigned char *s, FILE *f)
 875 {
 876   return fputs ((const char *)s, f);
 877 }
 878
 879   /* In line-map.c.  */
 880
 881 /* Create a macro map.  A macro map encodes source locations of tokens
 882    that are part of a macro replacement-list, at a macro expansion
 883    point. See the extensive comments of struct line_map and struct
 884    line_map_macro, in line-map.h.
 885
 886    This map shall be created when the macro is expanded. The map
 887    encodes the source location of the expansion point of the macro as
 888    well as the "original" source location of each token that is part
 889    of the macro replacement-list. If a macro is defined but never
 890    expanded, it has no macro map.  SET is the set of maps the macro
 891    map should be part of.  MACRO_NODE is the macro which the new macro
 892    map should encode source locations for.  EXPANSION is the location
 893    of the expansion point of MACRO. For function-like macros
 894    invocations, it's best to make it point to the closing parenthesis
 895    of the macro, rather than the the location of the first character
 896    of the macro.  NUM_TOKENS is the number of tokens that are part of
 897    the replacement-list of MACRO.  */
 898 const line_map_macro *linemap_enter_macro (class line_maps *,
 899                                            struct cpp_hashnode*,
 900                                            location_t,
 901                                            unsigned int);
 902
 903 /* Create and return a virtual location for a token that is part of a
 904    macro expansion-list at a macro expansion point.  See the comment
 905    inside struct line_map_macro to see what an expansion-list exactly
 906    is.
 907
 908    A call to this function must come after a call to
 909    linemap_enter_macro.
 910
 911    MAP is the map into which the source location is created.  TOKEN_NO
 912    is the index of the token in the macro replacement-list, starting
 913    at number 0.
 914
 915    ORIG_LOC is the location of the token outside of this macro
 916    expansion.  If the token comes originally from the macro
 917    definition, it is the locus in the macro definition; otherwise it
 918    is a location in the context of the caller of this macro expansion
 919    (which is a virtual location or a source location if the caller is
 920    itself a macro expansion or not).
 921
 922    MACRO_DEFINITION_LOC is the location in the macro definition,
 923    either of the token itself or of a macro parameter that it
 924    replaces.  */
 925 location_t linemap_add_macro_token (const line_map_macro *,
 926                                     unsigned int,
 927                                     location_t,
 928                                     location_t);
 929
 930 /* Return the source line number corresponding to source location
 931    LOCATION.  SET is the line map set LOCATION comes from.  If
 932    LOCATION is the location of token that is part of the
 933    expansion-list of a macro expansion return the line number of the
 934    macro expansion point.  */
 935 int linemap_get_expansion_line (class line_maps *,
 936                                 location_t);
 937
 938 /* Return the path of the file corresponding to source code location
 939    LOCATION.
 940
 941    If LOCATION is the location of a token that is part of the
 942    replacement-list of a macro expansion return the file path of the
 943    macro expansion point.
 944
 945    SET is the line map set LOCATION comes from.  */
 946 const char* linemap_get_expansion_filename (class line_maps *,
 947                                             location_t);
 948
 949 #ifdef __cplusplus
 950 }
 951 #endif
 952
 953 #endif /* ! LIBCPP_INTERNAL_H */