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