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   cpp_hashnode *n__has_include;         /* __has_include operator */
 294   cpp_hashnode *n__has_include_next;    /* __has_include_next operator */
 295 };
 296
 297 typedef struct _cpp_line_note _cpp_line_note;
 298 struct _cpp_line_note
 299 {
 300   /* Location in the clean line the note refers to.  */
 301   const unsigned char *pos;
 302
 303   /* Type of note.  The 9 'from' trigraph characters represent those
 304      trigraphs, '\\' an escaped newline, ' ' an escaped newline with
 305      intervening space, 0 represents a note that has already been handled,
 306      and anything else is invalid.  */
 307   unsigned int type;
 308 };
 309
 310 /* Represents the contents of a file cpplib has read in.  */
 311 struct cpp_buffer
 312 {
 313   const unsigned char *cur;        /* Current location.  */
 314   const unsigned char *line_base;  /* Start of current physical line.  */
 315   const unsigned char *next_line;  /* Start of to-be-cleaned logical line.  */
 316
 317   const unsigned char *buf;        /* Entire character buffer.  */
 318   const unsigned char *rlimit;     /* Writable byte at end of file.  */
 319   const unsigned char *to_free;    /* Pointer that should be freed when
 320                                       popping the buffer.  */
 321
 322   _cpp_line_note *notes;           /* Array of notes.  */
 323   unsigned int cur_note;           /* Next note to process.  */
 324   unsigned int notes_used;         /* Number of notes.  */
 325   unsigned int notes_cap;          /* Size of allocated array.  */
 326
 327   struct cpp_buffer *prev;
 328
 329   /* Pointer into the file table; non-NULL if this is a file buffer.
 330      Used for include_next and to record control macros.  */
 331   struct _cpp_file *file;
 332
 333   /* Saved value of __TIMESTAMP__ macro - date and time of last modification
 334      of the assotiated file.  */
 335   const unsigned char *timestamp;
 336
 337   /* Value of if_stack at start of this file.
 338      Used to prohibit unmatched #endif (etc) in an include file.  */
 339   struct if_stack *if_stack;
 340
 341   /* True if we need to get the next clean line.  */
 342   bool need_line : 1;
 343
 344   /* True if we have already warned about C++ comments in this file.
 345      The warning happens only for C89 extended mode with -pedantic on,
 346      or for -Wtraditional, and only once per file (otherwise it would
 347      be far too noisy).  */
 348   bool warned_cplusplus_comments : 1;
 349
 350   /* True if we don't process trigraphs and escaped newlines.  True
 351      for preprocessed input, command line directives, and _Pragma
 352      buffers.  */
 353   bool from_stage3 : 1;
 354
 355   /* At EOF, a buffer is automatically popped.  If RETURN_AT_EOF is
 356      true, a CPP_EOF token is then returned.  Otherwise, the next
 357      token from the enclosing buffer is returned.  */
 358   bool return_at_eof : 1;
 359
 360   /* One for a system header, two for a C system header file that therefore
 361      needs to be extern "C" protected in C++, and zero otherwise.  */
 362   unsigned char sysp;
 363
 364   /* The directory of the this buffer's file.  Its NAME member is not
 365      allocated, so we don't need to worry about freeing it.  */
 366   struct cpp_dir dir;
 367
 368   /* Descriptor for converting from the input character set to the
 369      source character set.  */
 370   struct cset_converter input_cset_desc;
 371 };
 372
 373 /* The list of saved macros by push_macro pragma.  */
 374 struct def_pragma_macro {
 375   /* Chain element to previous saved macro.  */
 376   struct def_pragma_macro *next;
 377   /* Name of the macro.  */
 378   char *name;
 379   /* The stored macro content.  */
 380   unsigned char *definition;
 381
 382   /* Definition line number.  */
 383   location_t line;
 384   /* If macro defined in system header.  */
 385   unsigned int syshdr   : 1;
 386   /* Nonzero if it has been expanded or had its existence tested.  */
 387   unsigned int used     : 1;
 388
 389   /* Mark if we save an undefined macro.  */
 390   unsigned int is_undef : 1;
 391   /* Nonzero if it was a builtin macro.  */
 392   unsigned int is_builtin : 1;
 393 };
 394
 395 /* A cpp_reader encapsulates the "state" of a pre-processor run.
 396    Applying cpp_get_token repeatedly yields a stream of pre-processor
 397    tokens.  Usually, there is only one cpp_reader object active.  */
 398 struct cpp_reader
 399 {
 400   /* Top of buffer stack.  */
 401   cpp_buffer *buffer;
 402
 403   /* Overlaid buffer (can be different after processing #include).  */
 404   cpp_buffer *overlaid_buffer;
 405
 406   /* Lexer state.  */
 407   struct lexer_state state;
 408
 409   /* Source line tracking.  */
 410   class line_maps *line_table;
 411
 412   /* The line of the '#' of the current directive.  */
 413   location_t directive_line;
 414
 415   /* Memory buffers.  */
 416   _cpp_buff *a_buff;            /* Aligned permanent storage.  */
 417   _cpp_buff *u_buff;            /* Unaligned permanent storage.  */
 418   _cpp_buff *free_buffs;        /* Free buffer chain.  */
 419
 420   /* Context stack.  */
 421   struct cpp_context base_context;
 422   struct cpp_context *context;
 423
 424   /* If in_directive, the directive if known.  */
 425   const struct directive *directive;
 426
 427   /* Token generated while handling a directive, if any. */
 428   cpp_token directive_result;
 429
 430   /* When expanding a macro at top-level, this is the location of the
 431      macro invocation.  */
 432   location_t invocation_location;
 433
 434   /* This is the node representing the macro being expanded at
 435      top-level.  The value of this data member is valid iff
 436      cpp_in_macro_expansion_p() returns TRUE.  */
 437   cpp_hashnode *top_most_macro_node;
 438
 439   /* Nonzero if we are about to expand a macro.  Note that if we are
 440      really expanding a macro, the function macro_of_context returns
 441      the macro being expanded and this flag is set to false.  Client
 442      code should use the function cpp_in_macro_expansion_p to know if we
 443      are either about to expand a macro, or are actually expanding
 444      one.  */
 445   bool about_to_expand_macro_p;
 446
 447   /* Search paths for include files.  */
 448   struct cpp_dir *quote_include;        /* "" */
 449   struct cpp_dir *bracket_include;      /* <> */
 450   struct cpp_dir no_search_path;        /* No path.  */
 451
 452   /* Chain of all hashed _cpp_file instances.  */
 453   struct _cpp_file *all_files;
 454
 455   struct _cpp_file *main_file;
 456
 457   /* File and directory hash table.  */
 458   struct htab *file_hash;
 459   struct htab *dir_hash;
 460   struct file_hash_entry_pool *file_hash_entries;
 461
 462   /* Negative path lookup hash table.  */
 463   struct htab *nonexistent_file_hash;
 464   struct obstack nonexistent_file_ob;
 465
 466   /* Nonzero means don't look for #include "foo" the source-file
 467      directory.  */
 468   bool quote_ignores_source_dir;
 469
 470   /* Nonzero if any file has contained #pragma once or #import has
 471      been used.  */
 472   bool seen_once_only;
 473
 474   /* Multiple include optimization.  */
 475   const cpp_hashnode *mi_cmacro;
 476   const cpp_hashnode *mi_ind_cmacro;
 477   bool mi_valid;
 478
 479   /* Lexing.  */
 480   cpp_token *cur_token;
 481   tokenrun base_run, *cur_run;
 482   unsigned int lookaheads;
 483
 484   /* Nonzero prevents the lexer from re-using the token runs.  */
 485   unsigned int keep_tokens;
 486
 487   /* Buffer to hold macro definition string.  */
 488   unsigned char *macro_buffer;
 489   unsigned int macro_buffer_len;
 490
 491   /* Descriptor for converting from the source character set to the
 492      execution character set.  */
 493   struct cset_converter narrow_cset_desc;
 494
 495   /* Descriptor for converting from the source character set to the
 496      UTF-8 execution character set.  */
 497   struct cset_converter utf8_cset_desc;
 498
 499   /* Descriptor for converting from the source character set to the
 500      UTF-16 execution character set.  */
 501   struct cset_converter char16_cset_desc;
 502
 503   /* Descriptor for converting from the source character set to the
 504      UTF-32 execution character set.  */
 505   struct cset_converter char32_cset_desc;
 506
 507   /* Descriptor for converting from the source character set to the
 508      wide execution character set.  */
 509   struct cset_converter wide_cset_desc;
 510
 511   /* Date and time text.  Calculated together if either is requested.  */
 512   const unsigned char *date;
 513   const unsigned char *time;
 514
 515   /* Externally set timestamp to replace current date and time useful for
 516      reproducibility.  It should be initialized to -2 (not yet set) and
 517      set to -1 to disable it or to a non-negative value to enable it.  */
 518   time_t source_date_epoch;
 519
 520   /* EOF token, and a token forcing paste avoidance.  */
 521   cpp_token avoid_paste;
 522   cpp_token eof;
 523
 524   /* Opaque handle to the dependencies of mkdeps.c.  */
 525   class mkdeps *deps;
 526
 527   /* Obstack holding all macro hash nodes.  This never shrinks.
 528      See identifiers.c */
 529   struct obstack hash_ob;
 530
 531   /* Obstack holding buffer and conditional structures.  This is a
 532      real stack.  See directives.c.  */
 533   struct obstack buffer_ob;
 534
 535   /* Pragma table - dynamic, because a library user can add to the
 536      list of recognized pragmas.  */
 537   struct pragma_entry *pragmas;
 538
 539   /* Call backs to cpplib client.  */
 540   struct cpp_callbacks cb;
 541
 542   /* Identifier hash table.  */
 543   struct ht *hash_table;
 544
 545   /* Expression parser stack.  */
 546   struct op *op_stack, *op_limit;
 547
 548   /* User visible options.  */
 549   struct cpp_options opts;
 550
 551   /* Special nodes - identifiers with predefined significance to the
 552      preprocessor.  */
 553   struct spec_nodes spec_nodes;
 554
 555   /* Whether cpplib owns the hashtable.  */
 556   bool our_hashtable;
 557
 558   /* Traditional preprocessing output buffer (a logical line).  */
 559   struct
 560   {
 561     unsigned char *base;
 562     unsigned char *limit;
 563     unsigned char *cur;
 564     location_t first_line;
 565   } out;
 566
 567   /* Used for buffer overlays by traditional.c.  */
 568   const unsigned char *saved_cur, *saved_rlimit, *saved_line_base;
 569
 570   /* A saved list of the defined macros, for dependency checking
 571      of precompiled headers.  */
 572   struct cpp_savedstate *savedstate;
 573
 574   /* Next value of __COUNTER__ macro. */
 575   unsigned int counter;
 576
 577   /* Table of comments, when state.save_comments is true.  */
 578   cpp_comment_table comments;
 579
 580   /* List of saved macros by push_macro.  */
 581   struct def_pragma_macro *pushed_macros;
 582
 583   /* If non-zero, the lexer will use this location for the next token
 584      instead of getting a location from the linemap.  */
 585   location_t forced_token_location;
 586 };
 587
 588 /* Character classes.  Based on the more primitive macros in safe-ctype.h.
 589    If the definition of `numchar' looks odd to you, please look up the
 590    definition of a pp-number in the C standard [section 6.4.8 of C99].
 591
 592    In the unlikely event that characters other than \r and \n enter
 593    the set is_vspace, the macro handle_newline() in lex.c must be
 594    updated.  */
 595 #define _dollar_ok(x)   ((x) == '$' && CPP_OPTION (pfile, dollars_in_ident))
 596
 597 #define is_idchar(x)    (ISIDNUM(x) || _dollar_ok(x))
 598 #define is_numchar(x)   ISIDNUM(x)
 599 #define is_idstart(x)   (ISIDST(x) || _dollar_ok(x))
 600 #define is_numstart(x)  ISDIGIT(x)
 601 #define is_hspace(x)    ISBLANK(x)
 602 #define is_vspace(x)    IS_VSPACE(x)
 603 #define is_nvspace(x)   IS_NVSPACE(x)
 604 #define is_space(x)     IS_SPACE_OR_NUL(x)
 605
 606 #define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
 607
 608 /* This table is constant if it can be initialized at compile time,
 609    which is the case if cpp was compiled with GCC >=2.7, or another
 610    compiler that supports C99.  */
 611 #if HAVE_DESIGNATED_INITIALIZERS
 612 extern const unsigned char _cpp_trigraph_map[UCHAR_MAX + 1];
 613 #else
 614 extern unsigned char _cpp_trigraph_map[UCHAR_MAX + 1];
 615 #endif
 616
 617 #if !defined (HAVE_UCHAR) && !defined (IN_GCC)
 618 typedef unsigned char uchar;
 619 #endif
 620
 621 #define UC (const uchar *)  /* Intended use: UC"string" */
 622
 623 /* Macros.  */
 624
 625 static inline int cpp_in_system_header (cpp_reader *);
 626 static inline int
 627 cpp_in_system_header (cpp_reader *pfile)
 628 {
 629   return pfile->buffer ? pfile->buffer->sysp : 0;
 630 }
 631 #define CPP_PEDANTIC(PF) CPP_OPTION (PF, cpp_pedantic)
 632 #define CPP_WTRADITIONAL(PF) CPP_OPTION (PF, cpp_warn_traditional)
 633
 634 static inline int cpp_in_primary_file (cpp_reader *);
 635 static inline int
 636 cpp_in_primary_file (cpp_reader *pfile)
 637 {
 638   return pfile->line_table->depth == 1;
 639 }
 640
 641 /* True if NODE is a macro for the purposes of ifdef, defined etc.  */
 642 inline bool _cpp_defined_macro_p (cpp_hashnode *node)
 643 {
 644   /* Do not treat conditional macros as being defined.  This is due to
 645      the powerpc port using conditional macros for 'vector', 'bool',
 646      and 'pixel' to act as conditional keywords.  This messes up tests
 647      like #ifndef bool.  */
 648   return cpp_macro_p (node) && !(node->flags & NODE_CONDITIONAL);
 649 }
 650
 651 /* In macro.c */
 652 extern void _cpp_notify_macro_use (cpp_reader *pfile, cpp_hashnode *node);
 653 inline void _cpp_maybe_notify_macro_use (cpp_reader *pfile, cpp_hashnode *node)
 654 {
 655   if (!(node->flags & NODE_USED))
 656     _cpp_notify_macro_use (pfile, node);
 657 }
 658 extern cpp_macro *_cpp_new_macro (cpp_reader *, cpp_macro_kind, void *);
 659 extern void _cpp_free_definition (cpp_hashnode *);
 660 extern bool _cpp_create_definition (cpp_reader *, cpp_hashnode *);
 661 extern void _cpp_pop_context (cpp_reader *);
 662 extern void _cpp_push_text_context (cpp_reader *, cpp_hashnode *,
 663                                     const unsigned char *, size_t);
 664 extern bool _cpp_save_parameter (cpp_reader *, unsigned, cpp_hashnode *,
 665                                  cpp_hashnode *);
 666 extern void _cpp_unsave_parameters (cpp_reader *, unsigned);
 667 extern bool _cpp_arguments_ok (cpp_reader *, cpp_macro *, const cpp_hashnode *,
 668                                unsigned int);
 669 extern const unsigned char *_cpp_builtin_macro_text (cpp_reader *,
 670                                                      cpp_hashnode *,
 671                                                      location_t = 0);
 672 extern int _cpp_warn_if_unused_macro (cpp_reader *, cpp_hashnode *, void *);
 673 extern void _cpp_push_token_context (cpp_reader *, cpp_hashnode *,
 674                                      const cpp_token *, unsigned int);
 675 extern void _cpp_backup_tokens_direct (cpp_reader *, unsigned int);
 676
 677 /* In identifiers.c */
 678 extern void _cpp_init_hashtable (cpp_reader *, cpp_hash_table *);
 679 extern void _cpp_destroy_hashtable (cpp_reader *);
 680
 681 /* In files.c */
 682 typedef struct _cpp_file _cpp_file;
 683 extern _cpp_file *_cpp_find_file (cpp_reader *, const char *, cpp_dir *,
 684                                   int angle, bool fake, bool preinclude,
 685                                   bool has_include, location_t);
 686 extern bool _cpp_find_failed (_cpp_file *);
 687 extern void _cpp_mark_file_once_only (cpp_reader *, struct _cpp_file *);
 688 extern void _cpp_fake_include (cpp_reader *, const char *);
 689 extern bool _cpp_stack_file (cpp_reader *, _cpp_file*, include_type, location_t);
 690 extern bool _cpp_stack_include (cpp_reader *, const char *, int,
 691                                 enum include_type, location_t);
 692 extern int _cpp_compare_file_date (cpp_reader *, const char *, int);
 693 extern void _cpp_report_missing_guards (cpp_reader *);
 694 extern void _cpp_init_files (cpp_reader *);
 695 extern void _cpp_cleanup_files (cpp_reader *);
 696 extern void _cpp_pop_file_buffer (cpp_reader *, struct _cpp_file *,
 697                                   const unsigned char *);
 698 extern bool _cpp_save_file_entries (cpp_reader *pfile, FILE *f);
 699 extern bool _cpp_read_file_entries (cpp_reader *, FILE *);
 700 extern const char *_cpp_get_file_name (_cpp_file *);
 701 extern struct stat *_cpp_get_file_stat (_cpp_file *);
 702 extern bool _cpp_has_header (cpp_reader *, const char *, int,
 703                              enum include_type);
 704
 705 /* In expr.c */
 706 extern bool _cpp_parse_expr (cpp_reader *, bool);
 707 extern struct op *_cpp_expand_op_stack (cpp_reader *);
 708
 709 /* In lex.c */
 710 extern void _cpp_process_line_notes (cpp_reader *, int);
 711 extern void _cpp_clean_line (cpp_reader *);
 712 extern bool _cpp_get_fresh_line (cpp_reader *);
 713 extern bool _cpp_skip_block_comment (cpp_reader *);
 714 extern cpp_token *_cpp_temp_token (cpp_reader *);
 715 extern const cpp_token *_cpp_lex_token (cpp_reader *);
 716 extern cpp_token *_cpp_lex_direct (cpp_reader *);
 717 extern unsigned char *_cpp_spell_ident_ucns (unsigned char *, cpp_hashnode *);
 718 extern int _cpp_equiv_tokens (const cpp_token *, const cpp_token *);
 719 extern void _cpp_init_tokenrun (tokenrun *, unsigned int);
 720 extern cpp_hashnode *_cpp_lex_identifier (cpp_reader *, const char *);
 721 extern int _cpp_remaining_tokens_num_in_context (cpp_context *);
 722 extern void _cpp_init_lexer (void);
 723 static inline void *_cpp_reserve_room (cpp_reader *pfile, size_t have,
 724                                        size_t extra)
 725 {
 726   if (BUFF_ROOM (pfile->a_buff) < (have + extra))
 727     _cpp_extend_buff (pfile, &pfile->a_buff, extra);
 728   return BUFF_FRONT (pfile->a_buff);
 729 }
 730 extern void *_cpp_commit_buff (cpp_reader *pfile, size_t size);
 731
 732 /* In init.c.  */
 733 extern void _cpp_maybe_push_include_file (cpp_reader *);
 734 extern const char *cpp_named_operator2name (enum cpp_ttype type);
 735 extern void _cpp_restore_special_builtin (cpp_reader *pfile,
 736                                           struct def_pragma_macro *);
 737
 738 /* In directives.c */
 739 extern int _cpp_test_assertion (cpp_reader *, unsigned int *);
 740 extern int _cpp_handle_directive (cpp_reader *, bool);
 741 extern void _cpp_define_builtin (cpp_reader *, const char *);
 742 extern char ** _cpp_save_pragma_names (cpp_reader *);
 743 extern void _cpp_restore_pragma_names (cpp_reader *, char **);
 744 extern int _cpp_do__Pragma (cpp_reader *, location_t);
 745 extern void _cpp_init_directives (cpp_reader *);
 746 extern void _cpp_init_internal_pragmas (cpp_reader *);
 747 extern void _cpp_do_file_change (cpp_reader *, enum lc_reason, const char *,
 748                                  linenum_type, unsigned int);
 749 extern void _cpp_pop_buffer (cpp_reader *);
 750 extern char *_cpp_bracket_include (cpp_reader *);
 751
 752 /* In directives.c */
 753 struct _cpp_dir_only_callbacks
 754 {
 755   /* Called to print a block of lines. */
 756   void (*print_lines) (int, const void *, size_t);
 757   bool (*maybe_print_line) (location_t);
 758 };
 759
 760 extern void _cpp_preprocess_dir_only (cpp_reader *,
 761                                       const struct _cpp_dir_only_callbacks *);
 762
 763 /* In traditional.c.  */
 764 extern bool _cpp_scan_out_logical_line (cpp_reader *, cpp_macro *, bool);
 765 extern bool _cpp_read_logical_line_trad (cpp_reader *);
 766 extern void _cpp_overlay_buffer (cpp_reader *pfile, const unsigned char *,
 767                                  size_t);
 768 extern void _cpp_remove_overlay (cpp_reader *);
 769 extern cpp_macro *_cpp_create_trad_definition (cpp_reader *);
 770 extern bool _cpp_expansions_different_trad (const cpp_macro *,
 771                                             const cpp_macro *);
 772 extern unsigned char *_cpp_copy_replacement_text (const cpp_macro *,
 773                                                   unsigned char *);
 774 extern size_t _cpp_replacement_text_len (const cpp_macro *);
 775
 776 /* In charset.c.  */
 777
 778 /* The normalization state at this point in the sequence.
 779    It starts initialized to all zeros, and at the end
 780    'level' is the normalization level of the sequence.  */
 781
 782 struct normalize_state
 783 {
 784   /* The previous starter character.  */
 785   cppchar_t previous;
 786   /* The combining class of the previous character (whether or not a
 787      starter).  */
 788   unsigned char prev_class;
 789   /* The lowest normalization level so far.  */
 790   enum cpp_normalize_level level;
 791 };
 792 #define INITIAL_NORMALIZE_STATE { 0, 0, normalized_KC }
 793 #define NORMALIZE_STATE_RESULT(st) ((st)->level)
 794
 795 /* We saw a character C that matches ISIDNUM(), update a
 796    normalize_state appropriately.  */
 797 #define NORMALIZE_STATE_UPDATE_IDNUM(st, c)     \
 798   ((st)->previous = (c), (st)->prev_class = 0)
 799
 800 extern bool _cpp_valid_ucn (cpp_reader *, const unsigned char **,
 801                             const unsigned char *, int,
 802                             struct normalize_state *state,
 803                             cppchar_t *,
 804                             source_range *char_range,
 805                             cpp_string_location_reader *loc_reader);
 806
 807 extern bool _cpp_valid_utf8 (cpp_reader *pfile,
 808                              const uchar **pstr,
 809                              const uchar *limit,
 810                              int identifier_pos,
 811                              struct normalize_state *nst,
 812                              cppchar_t *cp);
 813
 814 extern void _cpp_destroy_iconv (cpp_reader *);
 815 extern unsigned char *_cpp_convert_input (cpp_reader *, const char *,
 816                                           unsigned char *, size_t, size_t,
 817                                           const unsigned char **, off_t *);
 818 extern const char *_cpp_default_encoding (void);
 819 extern cpp_hashnode * _cpp_interpret_identifier (cpp_reader *pfile,
 820                                                  const unsigned char *id,
 821                                                  size_t len);
 822
 823 /* Utility routines and macros.  */
 824 #define DSC(str) (const unsigned char *)str, sizeof str - 1
 825
 826 /* These are inline functions instead of macros so we can get type
 827    checking.  */
 828 static inline int ustrcmp (const unsigned char *, const unsigned char *);
 829 static inline int ustrncmp (const unsigned char *, const unsigned char *,
 830                             size_t);
 831 static inline size_t ustrlen (const unsigned char *);
 832 static inline const unsigned char *uxstrdup (const unsigned char *);
 833 static inline const unsigned char *ustrchr (const unsigned char *, int);
 834 static inline int ufputs (const unsigned char *, FILE *);
 835
 836 /* Use a const char for the second parameter since it is usually a literal.  */
 837 static inline int ustrcspn (const unsigned char *, const char *);
 838
 839 static inline int
 840 ustrcmp (const unsigned char *s1, const unsigned char *s2)
 841 {
 842   return strcmp ((const char *)s1, (const char *)s2);
 843 }
 844
 845 static inline int
 846 ustrncmp (const unsigned char *s1, const unsigned char *s2, size_t n)
 847 {
 848   return strncmp ((const char *)s1, (const char *)s2, n);
 849 }
 850
 851 static inline int
 852 ustrcspn (const unsigned char *s1, const char *s2)
 853 {
 854   return strcspn ((const char *)s1, s2);
 855 }
 856
 857 static inline size_t
 858 ustrlen (const unsigned char *s1)
 859 {
 860   return strlen ((const char *)s1);
 861 }
 862
 863 static inline const unsigned char *
 864 uxstrdup (const unsigned char *s1)
 865 {
 866   return (const unsigned char *) xstrdup ((const char *)s1);
 867 }
 868
 869 static inline const unsigned char *
 870 ustrchr (const unsigned char *s1, int c)
 871 {
 872   return (const unsigned char *) strchr ((const char *)s1, c);
 873 }
 874
 875 static inline int
 876 ufputs (const unsigned char *s, FILE *f)
 877 {
 878   return fputs ((const char *)s, f);
 879 }
 880
 881   /* In line-map.c.  */
 882
 883 /* Create a macro map.  A macro map encodes source locations of tokens
 884    that are part of a macro replacement-list, at a macro expansion
 885    point. See the extensive comments of struct line_map and struct
 886    line_map_macro, in line-map.h.
 887
 888    This map shall be created when the macro is expanded. The map
 889    encodes the source location of the expansion point of the macro as
 890    well as the "original" source location of each token that is part
 891    of the macro replacement-list. If a macro is defined but never
 892    expanded, it has no macro map.  SET is the set of maps the macro
 893    map should be part of.  MACRO_NODE is the macro which the new macro
 894    map should encode source locations for.  EXPANSION is the location
 895    of the expansion point of MACRO. For function-like macros
 896    invocations, it's best to make it point to the closing parenthesis
 897    of the macro, rather than the the location of the first character
 898    of the macro.  NUM_TOKENS is the number of tokens that are part of
 899    the replacement-list of MACRO.  */
 900 const line_map_macro *linemap_enter_macro (class line_maps *,
 901                                            struct cpp_hashnode*,
 902                                            location_t,
 903                                            unsigned int);
 904
 905 /* Create and return a virtual location for a token that is part of a
 906    macro expansion-list at a macro expansion point.  See the comment
 907    inside struct line_map_macro to see what an expansion-list exactly
 908    is.
 909
 910    A call to this function must come after a call to
 911    linemap_enter_macro.
 912
 913    MAP is the map into which the source location is created.  TOKEN_NO
 914    is the index of the token in the macro replacement-list, starting
 915    at number 0.
 916
 917    ORIG_LOC is the location of the token outside of this macro
 918    expansion.  If the token comes originally from the macro
 919    definition, it is the locus in the macro definition; otherwise it
 920    is a location in the context of the caller of this macro expansion
 921    (which is a virtual location or a source location if the caller is
 922    itself a macro expansion or not).
 923
 924    MACRO_DEFINITION_LOC is the location in the macro definition,
 925    either of the token itself or of a macro parameter that it
 926    replaces.  */
 927 location_t linemap_add_macro_token (const line_map_macro *,
 928                                     unsigned int,
 929                                     location_t,
 930                                     location_t);
 931
 932 /* Return the source line number corresponding to source location
 933    LOCATION.  SET is the line map set LOCATION comes from.  If
 934    LOCATION is the location of token that is part of the
 935    expansion-list of a macro expansion return the line number of the
 936    macro expansion point.  */
 937 int linemap_get_expansion_line (class line_maps *,
 938                                 location_t);
 939
 940 /* Return the path of the file corresponding to source code location
 941    LOCATION.
 942
 943    If LOCATION is the location of a token that is part of the
 944    replacement-list of a macro expansion return the file path of the
 945    macro expansion point.
 946
 947    SET is the line map set LOCATION comes from.  */
 948 const char* linemap_get_expansion_filename (class line_maps *,
 949                                             location_t);
 950
 951 #ifdef __cplusplus
 952 }
 953 #endif
 954
 955 #endif /* ! LIBCPP_INTERNAL_H */