libcpp/internal.h

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