projects / gcc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[Ada] Consistently use explicit Entity_Id type instead of alias
[gcc.git] / libcpp / include / cpplib.h
1 /* Definitions for CPP library.
2 Copyright (C) 1995-2020 Free Software Foundation, Inc.
3 Written by Per Bothner, 1994-95.
4
5 This program is free software; you can redistribute it and/or modify it
6 under the terms of the GNU General Public License as published by the
7 Free Software Foundation; either version 3, or (at your option) any
8 later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; see the file COPYING3. If not see
17 <http://www.gnu.org/licenses/>.
18
19 In other words, you are welcome to use, share and improve this program.
20 You are forbidden to forbid anyone else to use, share and improve
21 what you give them. Help stamp out software-hoarding! */
22 #ifndef LIBCPP_CPPLIB_H
23 #define LIBCPP_CPPLIB_H
24
25 #include <sys/types.h>
26 #include "symtab.h"
27 #include "line-map.h"
28
29 typedef struct cpp_reader cpp_reader;
30 typedef struct cpp_buffer cpp_buffer;
31 typedef struct cpp_options cpp_options;
32 typedef struct cpp_token cpp_token;
33 typedef struct cpp_string cpp_string;
34 typedef struct cpp_hashnode cpp_hashnode;
35 typedef struct cpp_macro cpp_macro;
36 typedef struct cpp_callbacks cpp_callbacks;
37 typedef struct cpp_dir cpp_dir;
38
39 struct _cpp_file;
40
41 /* The first three groups, apart from '=', can appear in preprocessor
42 expressions (+= and -= are used to indicate unary + and - resp.).
43 This allows a lookup table to be implemented in _cpp_parse_expr.
44
45 The first group, to CPP_LAST_EQ, can be immediately followed by an
46 '='. The lexer needs operators ending in '=', like ">>=", to be in
47 the same order as their counterparts without the '=', like ">>".
48
49 See the cpp_operator table optab in expr.c if you change the order or
50 add or remove anything in the first group. */
51
52 #define TTYPE_TABLE \
53 OP(EQ, "=") \
54 OP(NOT, "!") \
55 OP(GREATER, ">") /* compare */ \
56 OP(LESS, "<") \
57 OP(PLUS, "+") /* math */ \
58 OP(MINUS, "-") \
59 OP(MULT, "*") \
60 OP(DIV, "/") \
61 OP(MOD, "%") \
62 OP(AND, "&") /* bit ops */ \
63 OP(OR, "|") \
64 OP(XOR, "^") \
65 OP(RSHIFT, ">>") \
66 OP(LSHIFT, "<<") \
67 \
68 OP(COMPL, "~") \
69 OP(AND_AND, "&&") /* logical */ \
70 OP(OR_OR, "||") \
71 OP(QUERY, "?") \
72 OP(COLON, ":") \
73 OP(COMMA, ",") /* grouping */ \
74 OP(OPEN_PAREN, "(") \
75 OP(CLOSE_PAREN, ")") \
76 TK(EOF, NONE) \
77 OP(EQ_EQ, "==") /* compare */ \
78 OP(NOT_EQ, "!=") \
79 OP(GREATER_EQ, ">=") \
80 OP(LESS_EQ, "<=") \
81 OP(SPACESHIP, "<=>") \
82 \
83 /* These two are unary + / - in preprocessor expressions. */ \
84 OP(PLUS_EQ, "+=") /* math */ \
85 OP(MINUS_EQ, "-=") \
86 \
87 OP(MULT_EQ, "*=") \
88 OP(DIV_EQ, "/=") \
89 OP(MOD_EQ, "%=") \
90 OP(AND_EQ, "&=") /* bit ops */ \
91 OP(OR_EQ, "|=") \
92 OP(XOR_EQ, "^=") \
93 OP(RSHIFT_EQ, ">>=") \
94 OP(LSHIFT_EQ, "<<=") \
95 /* Digraphs together, beginning with CPP_FIRST_DIGRAPH. */ \
96 OP(HASH, "#") /* digraphs */ \
97 OP(PASTE, "##") \
98 OP(OPEN_SQUARE, "[") \
99 OP(CLOSE_SQUARE, "]") \
100 OP(OPEN_BRACE, "{") \
101 OP(CLOSE_BRACE, "}") \
102 /* The remainder of the punctuation. Order is not significant. */ \
103 OP(SEMICOLON, ";") /* structure */ \
104 OP(ELLIPSIS, "...") \
105 OP(PLUS_PLUS, "++") /* increment */ \
106 OP(MINUS_MINUS, "--") \
107 OP(DEREF, "->") /* accessors */ \
108 OP(DOT, ".") \
109 OP(SCOPE, "::") \
110 OP(DEREF_STAR, "->*") \
111 OP(DOT_STAR, ".*") \
112 OP(ATSIGN, "@") /* used in Objective-C */ \
113 \
114 TK(NAME, IDENT) /* word */ \
115 TK(AT_NAME, IDENT) /* @word - Objective-C */ \
116 TK(NUMBER, LITERAL) /* 34_be+ta */ \
117 \
118 TK(CHAR, LITERAL) /* 'char' */ \
119 TK(WCHAR, LITERAL) /* L'char' */ \
120 TK(CHAR16, LITERAL) /* u'char' */ \
121 TK(CHAR32, LITERAL) /* U'char' */ \
122 TK(UTF8CHAR, LITERAL) /* u8'char' */ \
123 TK(OTHER, LITERAL) /* stray punctuation */ \
124 \
125 TK(STRING, LITERAL) /* "string" */ \
126 TK(WSTRING, LITERAL) /* L"string" */ \
127 TK(STRING16, LITERAL) /* u"string" */ \
128 TK(STRING32, LITERAL) /* U"string" */ \
129 TK(UTF8STRING, LITERAL) /* u8"string" */ \
130 TK(OBJC_STRING, LITERAL) /* @"string" - Objective-C */ \
131 TK(HEADER_NAME, LITERAL) /* <stdio.h> in #include */ \
132 \
133 TK(CHAR_USERDEF, LITERAL) /* 'char'_suffix - C++-0x */ \
134 TK(WCHAR_USERDEF, LITERAL) /* L'char'_suffix - C++-0x */ \
135 TK(CHAR16_USERDEF, LITERAL) /* u'char'_suffix - C++-0x */ \
136 TK(CHAR32_USERDEF, LITERAL) /* U'char'_suffix - C++-0x */ \
137 TK(UTF8CHAR_USERDEF, LITERAL) /* u8'char'_suffix - C++-0x */ \
138 TK(STRING_USERDEF, LITERAL) /* "string"_suffix - C++-0x */ \
139 TK(WSTRING_USERDEF, LITERAL) /* L"string"_suffix - C++-0x */ \
140 TK(STRING16_USERDEF, LITERAL) /* u"string"_suffix - C++-0x */ \
141 TK(STRING32_USERDEF, LITERAL) /* U"string"_suffix - C++-0x */ \
142 TK(UTF8STRING_USERDEF,LITERAL) /* u8"string"_suffix - C++-0x */ \
143 \
144 TK(COMMENT, LITERAL) /* Only if output comments. */ \
145 /* SPELL_LITERAL happens to DTRT. */ \
146 TK(MACRO_ARG, NONE) /* Macro argument. */ \
147 TK(PRAGMA, NONE) /* Only for deferred pragmas. */ \
148 TK(PRAGMA_EOL, NONE) /* End-of-line for deferred pragmas. */ \
149 TK(PADDING, NONE) /* Whitespace for -E. */
150
151 #define OP(e, s) CPP_ ## e,
152 #define TK(e, s) CPP_ ## e,
153 enum cpp_ttype
154 {
155 TTYPE_TABLE
156 N_TTYPES,
157
158 /* A token type for keywords, as opposed to ordinary identifiers. */
159 CPP_KEYWORD,
160
161 /* Positions in the table. */
162 CPP_LAST_EQ = CPP_LSHIFT,
163 CPP_FIRST_DIGRAPH = CPP_HASH,
164 CPP_LAST_PUNCTUATOR= CPP_ATSIGN,
165 CPP_LAST_CPP_OP = CPP_LESS_EQ
166 };
167 #undef OP
168 #undef TK
169
170 /* C language kind, used when calling cpp_create_reader. */
171 enum c_lang {CLK_GNUC89 = 0, CLK_GNUC99, CLK_GNUC11, CLK_GNUC17, CLK_GNUC2X,
172 CLK_STDC89, CLK_STDC94, CLK_STDC99, CLK_STDC11, CLK_STDC17,
173 CLK_STDC2X,
174 CLK_GNUCXX, CLK_CXX98, CLK_GNUCXX11, CLK_CXX11,
175 CLK_GNUCXX14, CLK_CXX14, CLK_GNUCXX17, CLK_CXX17,
176 CLK_GNUCXX20, CLK_CXX20, CLK_ASM};
177
178 /* Payload of a NUMBER, STRING, CHAR or COMMENT token. */
179 struct GTY(()) cpp_string {
180 unsigned int len;
181 const unsigned char *text;
182 };
183
184 /* Flags for the cpp_token structure. */
185 #define PREV_WHITE (1 << 0) /* If whitespace before this token. */
186 #define DIGRAPH (1 << 1) /* If it was a digraph. */
187 #define STRINGIFY_ARG (1 << 2) /* If macro argument to be stringified. */
188 #define PASTE_LEFT (1 << 3) /* If on LHS of a ## operator. */
189 #define NAMED_OP (1 << 4) /* C++ named operators. */
190 #define PREV_FALLTHROUGH (1 << 5) /* On a token preceeded by FALLTHROUGH
191 comment. */
192 #define BOL (1 << 6) /* Token at beginning of line. */
193 #define PURE_ZERO (1 << 7) /* Single 0 digit, used by the C++ frontend,
194 set in c-lex.c. */
195 #define SP_DIGRAPH (1 << 8) /* # or ## token was a digraph. */
196 #define SP_PREV_WHITE (1 << 9) /* If whitespace before a ##
197 operator, or before this token
198 after a # operator. */
199 #define NO_EXPAND (1 << 10) /* Do not macro-expand this token. */
200
201 /* Specify which field, if any, of the cpp_token union is used. */
202
203 enum cpp_token_fld_kind {
204 CPP_TOKEN_FLD_NODE,
205 CPP_TOKEN_FLD_SOURCE,
206 CPP_TOKEN_FLD_STR,
207 CPP_TOKEN_FLD_ARG_NO,
208 CPP_TOKEN_FLD_TOKEN_NO,
209 CPP_TOKEN_FLD_PRAGMA,
210 CPP_TOKEN_FLD_NONE
211 };
212
213 /* A macro argument in the cpp_token union. */
214 struct GTY(()) cpp_macro_arg {
215 /* Argument number. */
216 unsigned int arg_no;
217 /* The original spelling of the macro argument token. */
218 cpp_hashnode *
219 GTY ((nested_ptr (union tree_node,
220 "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
221 "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
222 spelling;
223 };
224
225 /* An identifier in the cpp_token union. */
226 struct GTY(()) cpp_identifier {
227 /* The canonical (UTF-8) spelling of the identifier. */
228 cpp_hashnode *
229 GTY ((nested_ptr (union tree_node,
230 "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
231 "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
232 node;
233 /* The original spelling of the identifier. */
234 cpp_hashnode *
235 GTY ((nested_ptr (union tree_node,
236 "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
237 "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
238 spelling;
239 };
240
241 /* A preprocessing token. This has been carefully packed and should
242 occupy 16 bytes on 32-bit hosts and 24 bytes on 64-bit hosts. */
243 struct GTY(()) cpp_token {
244
245 /* Location of first char of token, together with range of full token. */
246 location_t src_loc;
247
248 ENUM_BITFIELD(cpp_ttype) type : CHAR_BIT; /* token type */
249 unsigned short flags; /* flags - see above */
250
251 union cpp_token_u
252 {
253 /* An identifier. */
254 struct cpp_identifier GTY ((tag ("CPP_TOKEN_FLD_NODE"))) node;
255
256 /* Inherit padding from this token. */
257 cpp_token * GTY ((tag ("CPP_TOKEN_FLD_SOURCE"))) source;
258
259 /* A string, or number. */
260 struct cpp_string GTY ((tag ("CPP_TOKEN_FLD_STR"))) str;
261
262 /* Argument no. (and original spelling) for a CPP_MACRO_ARG. */
263 struct cpp_macro_arg GTY ((tag ("CPP_TOKEN_FLD_ARG_NO"))) macro_arg;
264
265 /* Original token no. for a CPP_PASTE (from a sequence of
266 consecutive paste tokens in a macro expansion). */
267 unsigned int GTY ((tag ("CPP_TOKEN_FLD_TOKEN_NO"))) token_no;
268
269 /* Caller-supplied identifier for a CPP_PRAGMA. */
270 unsigned int GTY ((tag ("CPP_TOKEN_FLD_PRAGMA"))) pragma;
271 } GTY ((desc ("cpp_token_val_index (&%1)"))) val;
272 };
273
274 /* Say which field is in use. */
275 extern enum cpp_token_fld_kind cpp_token_val_index (const cpp_token *tok);
276
277 /* A type wide enough to hold any multibyte source character.
278 cpplib's character constant interpreter requires an unsigned type.
279 Also, a typedef for the signed equivalent.
280 The width of this type is capped at 32 bits; there do exist targets
281 where wchar_t is 64 bits, but only in a non-default mode, and there
282 would be no meaningful interpretation for a wchar_t value greater
283 than 2^32 anyway -- the widest wide-character encoding around is
284 ISO 10646, which stops at 2^31. */
285 #if CHAR_BIT * SIZEOF_INT >= 32
286 # define CPPCHAR_SIGNED_T int
287 #elif CHAR_BIT * SIZEOF_LONG >= 32
288 # define CPPCHAR_SIGNED_T long
289 #else
290 # error "Cannot find a least-32-bit signed integer type"
291 #endif
292 typedef unsigned CPPCHAR_SIGNED_T cppchar_t;
293 typedef CPPCHAR_SIGNED_T cppchar_signed_t;
294
295 /* Style of header dependencies to generate. */
296 enum cpp_deps_style { DEPS_NONE = 0, DEPS_USER, DEPS_SYSTEM };
297
298 /* The possible normalization levels, from most restrictive to least. */
299 enum cpp_normalize_level {
300 /* In NFKC. */
301 normalized_KC = 0,
302 /* In NFC. */
303 normalized_C,
304 /* In NFC, except for subsequences where being in NFC would make
305 the identifier invalid. */
306 normalized_identifier_C,
307 /* Not normalized at all. */
308 normalized_none
309 };
310
311 enum cpp_main_search
312 {
313 CMS_none, /* A regular source file. */
314 CMS_header, /* Is a directly-specified header file (eg PCH or
315 header-unit). */
316 CMS_user, /* Search the user INCLUDE path. */
317 CMS_system, /* Search the system INCLUDE path. */
318 };
319
320 /* This structure is nested inside struct cpp_reader, and
321 carries all the options visible to the command line. */
322 struct cpp_options
323 {
324 /* The language we're preprocessing. */
325 enum c_lang lang;
326
327 /* Nonzero means use extra default include directories for C++. */
328 unsigned char cplusplus;
329
330 /* Nonzero means handle cplusplus style comments. */
331 unsigned char cplusplus_comments;
332
333 /* Nonzero means define __OBJC__, treat @ as a special token, use
334 the OBJC[PLUS]_INCLUDE_PATH environment variable, and allow
335 "#import". */
336 unsigned char objc;
337
338 /* Nonzero means don't copy comments into the output file. */
339 unsigned char discard_comments;
340
341 /* Nonzero means don't copy comments into the output file during
342 macro expansion. */
343 unsigned char discard_comments_in_macro_exp;
344
345 /* Nonzero means process the ISO trigraph sequences. */
346 unsigned char trigraphs;
347
348 /* Nonzero means process the ISO digraph sequences. */
349 unsigned char digraphs;
350
351 /* Nonzero means to allow hexadecimal floats and LL suffixes. */
352 unsigned char extended_numbers;
353
354 /* Nonzero means process u/U prefix literals (UTF-16/32). */
355 unsigned char uliterals;
356
357 /* Nonzero means process u8 prefixed character literals (UTF-8). */
358 unsigned char utf8_char_literals;
359
360 /* Nonzero means process r/R raw strings. If this is set, uliterals
361 must be set as well. */
362 unsigned char rliterals;
363
364 /* Nonzero means print names of header files (-H). */
365 unsigned char print_include_names;
366
367 /* Nonzero means complain about deprecated features. */
368 unsigned char cpp_warn_deprecated;
369
370 /* Nonzero means warn if slash-star appears in a comment. */
371 unsigned char warn_comments;
372
373 /* Nonzero means to warn about __DATA__, __TIME__ and __TIMESTAMP__ usage. */
374 unsigned char warn_date_time;
375
376 /* Nonzero means warn if a user-supplied include directory does not
377 exist. */
378 unsigned char warn_missing_include_dirs;
379
380 /* Nonzero means warn if there are any trigraphs. */
381 unsigned char warn_trigraphs;
382
383 /* Nonzero means warn about multicharacter charconsts. */
384 unsigned char warn_multichar;
385
386 /* Nonzero means warn about various incompatibilities with
387 traditional C. */
388 unsigned char cpp_warn_traditional;
389
390 /* Nonzero means warn about long long numeric constants. */
391 unsigned char cpp_warn_long_long;
392
393 /* Nonzero means warn about text after an #endif (or #else). */
394 unsigned char warn_endif_labels;
395
396 /* Nonzero means warn about implicit sign changes owing to integer
397 promotions. */
398 unsigned char warn_num_sign_change;
399
400 /* Zero means don't warn about __VA_ARGS__ usage in c89 pedantic mode.
401 Presumably the usage is protected by the appropriate #ifdef. */
402 unsigned char warn_variadic_macros;
403
404 /* Nonzero means warn about builtin macros that are redefined or
405 explicitly undefined. */
406 unsigned char warn_builtin_macro_redefined;
407
408 /* Different -Wimplicit-fallthrough= levels. */
409 unsigned char cpp_warn_implicit_fallthrough;
410
411 /* Nonzero means we should look for header.gcc files that remap file
412 names. */
413 unsigned char remap;
414
415 /* Zero means dollar signs are punctuation. */
416 unsigned char dollars_in_ident;
417
418 /* Nonzero means UCNs are accepted in identifiers. */
419 unsigned char extended_identifiers;
420
421 /* True if we should warn about dollars in identifiers or numbers
422 for this translation unit. */
423 unsigned char warn_dollars;
424
425 /* Nonzero means warn if undefined identifiers are evaluated in an #if. */
426 unsigned char warn_undef;
427
428 /* Nonzero means warn if "defined" is encountered in a place other than
429 an #if. */
430 unsigned char warn_expansion_to_defined;
431
432 /* Nonzero means warn of unused macros from the main file. */
433 unsigned char warn_unused_macros;
434
435 /* Nonzero for the 1999 C Standard, including corrigenda and amendments. */
436 unsigned char c99;
437
438 /* Nonzero if we are conforming to a specific C or C++ standard. */
439 unsigned char std;
440
441 /* Nonzero means give all the error messages the ANSI standard requires. */
442 unsigned char cpp_pedantic;
443
444 /* Nonzero means we're looking at already preprocessed code, so don't
445 bother trying to do macro expansion and whatnot. */
446 unsigned char preprocessed;
447
448 /* Nonzero means we are going to emit debugging logs during
449 preprocessing. */
450 unsigned char debug;
451
452 /* Nonzero means we are tracking locations of tokens involved in
453 macro expansion. 1 Means we track the location in degraded mode
454 where we do not track locations of tokens resulting from the
455 expansion of arguments of function-like macro. 2 Means we do
456 track all macro expansions. This last option is the one that
457 consumes the highest amount of memory. */
458 unsigned char track_macro_expansion;
459
460 /* Nonzero means handle C++ alternate operator names. */
461 unsigned char operator_names;
462
463 /* Nonzero means warn about use of C++ alternate operator names. */
464 unsigned char warn_cxx_operator_names;
465
466 /* True for traditional preprocessing. */
467 unsigned char traditional;
468
469 /* Nonzero for C++ 2011 Standard user-defined literals. */
470 unsigned char user_literals;
471
472 /* Nonzero means warn when a string or character literal is followed by a
473 ud-suffix which does not beging with an underscore. */
474 unsigned char warn_literal_suffix;
475
476 /* Nonzero means interpret imaginary, fixed-point, or other gnu extension
477 literal number suffixes as user-defined literal number suffixes. */
478 unsigned char ext_numeric_literals;
479
480 /* Nonzero means extended identifiers allow the characters specified
481 in C11 and C++11. */
482 unsigned char c11_identifiers;
483
484 /* Nonzero for C++ 2014 Standard binary constants. */
485 unsigned char binary_constants;
486
487 /* Nonzero for C++ 2014 Standard digit separators. */
488 unsigned char digit_separators;
489
490 /* Nonzero for C2X decimal floating-point constants. */
491 unsigned char dfp_constants;
492
493 /* Nonzero for C++20 __VA_OPT__ feature. */
494 unsigned char va_opt;
495
496 /* Nonzero for the '::' token. */
497 unsigned char scope;
498
499 /* Nonzero means tokenize C++20 module directives. */
500 unsigned char module_directives;
501
502 /* Holds the name of the target (execution) character set. */
503 const char *narrow_charset;
504
505 /* Holds the name of the target wide character set. */
506 const char *wide_charset;
507
508 /* Holds the name of the input character set. */
509 const char *input_charset;
510
511 /* The minimum permitted level of normalization before a warning
512 is generated. See enum cpp_normalize_level. */
513 int warn_normalize;
514
515 /* True to warn about precompiled header files we couldn't use. */
516 bool warn_invalid_pch;
517
518 /* True if dependencies should be restored from a precompiled header. */
519 bool restore_pch_deps;
520
521 /* True if warn about differences between C90 and C99. */
522 signed char cpp_warn_c90_c99_compat;
523
524 /* True if warn about differences between C11 and C2X. */
525 signed char cpp_warn_c11_c2x_compat;
526
527 /* True if warn about differences between C++98 and C++11. */
528 bool cpp_warn_cxx11_compat;
529
530 /* Dependency generation. */
531 struct
532 {
533 /* Style of header dependencies to generate. */
534 enum cpp_deps_style style;
535
536 /* Assume missing files are generated files. */
537 bool missing_files;
538
539 /* Generate phony targets for each dependency apart from the first
540 one. */
541 bool phony_targets;
542
543 /* Generate dependency info for modules. */
544 bool modules;
545
546 /* If true, no dependency is generated on the main file. */
547 bool ignore_main_file;
548
549 /* If true, intend to use the preprocessor output (e.g., for compilation)
550 in addition to the dependency info. */
551 bool need_preprocessor_output;
552 } deps;
553
554 /* Target-specific features set by the front end or client. */
555
556 /* Precision for target CPP arithmetic, target characters, target
557 ints and target wide characters, respectively. */
558 size_t precision, char_precision, int_precision, wchar_precision;
559
560 /* True means chars (wide chars) are unsigned. */
561 bool unsigned_char, unsigned_wchar;
562
563 /* True if the most significant byte in a word has the lowest
564 address in memory. */
565 bool bytes_big_endian;
566
567 /* Nonzero means __STDC__ should have the value 0 in system headers. */
568 unsigned char stdc_0_in_system_headers;
569
570 /* True disables tokenization outside of preprocessing directives. */
571 bool directives_only;
572
573 /* True enables canonicalization of system header file paths. */
574 bool canonical_system_headers;
575
576 /* The maximum depth of the nested #include. */
577 unsigned int max_include_depth;
578
579 cpp_main_search main_search : 8;
580 };
581
582 /* Diagnostic levels. To get a diagnostic without associating a
583 position in the translation unit with it, use cpp_error_with_line
584 with a line number of zero. */
585
586 enum cpp_diagnostic_level {
587 /* Warning, an error with -Werror. */
588 CPP_DL_WARNING = 0,
589 /* Same as CPP_DL_WARNING, except it is not suppressed in system headers. */
590 CPP_DL_WARNING_SYSHDR,
591 /* Warning, an error with -pedantic-errors or -Werror. */
592 CPP_DL_PEDWARN,
593 /* An error. */
594 CPP_DL_ERROR,
595 /* An internal consistency check failed. Prints "internal error: ",
596 otherwise the same as CPP_DL_ERROR. */
597 CPP_DL_ICE,
598 /* An informative note following a warning. */
599 CPP_DL_NOTE,
600 /* A fatal error. */
601 CPP_DL_FATAL
602 };
603
604 /* Warning reason codes. Use a reason code of CPP_W_NONE for unclassified
605 warnings and diagnostics that are not warnings. */
606
607 enum cpp_warning_reason {
608 CPP_W_NONE = 0,
609 CPP_W_DEPRECATED,
610 CPP_W_COMMENTS,
611 CPP_W_MISSING_INCLUDE_DIRS,
612 CPP_W_TRIGRAPHS,
613 CPP_W_MULTICHAR,
614 CPP_W_TRADITIONAL,
615 CPP_W_LONG_LONG,
616 CPP_W_ENDIF_LABELS,
617 CPP_W_NUM_SIGN_CHANGE,
618 CPP_W_VARIADIC_MACROS,
619 CPP_W_BUILTIN_MACRO_REDEFINED,
620 CPP_W_DOLLARS,
621 CPP_W_UNDEF,
622 CPP_W_UNUSED_MACROS,
623 CPP_W_CXX_OPERATOR_NAMES,
624 CPP_W_NORMALIZE,
625 CPP_W_INVALID_PCH,
626 CPP_W_WARNING_DIRECTIVE,
627 CPP_W_LITERAL_SUFFIX,
628 CPP_W_DATE_TIME,
629 CPP_W_PEDANTIC,
630 CPP_W_C90_C99_COMPAT,
631 CPP_W_C11_C2X_COMPAT,
632 CPP_W_CXX11_COMPAT,
633 CPP_W_EXPANSION_TO_DEFINED
634 };
635
636 /* Callback for header lookup for HEADER, which is the name of a
637 source file. It is used as a method of last resort to find headers
638 that are not otherwise found during the normal include processing.
639 The return value is the malloced name of a header to try and open,
640 if any, or NULL otherwise. This callback is called only if the
641 header is otherwise unfound. */
642 typedef const char *(*missing_header_cb)(cpp_reader *, const char *header, cpp_dir **);
643
644 /* Call backs to cpplib client. */
645 struct cpp_callbacks
646 {
647 /* Called when a new line of preprocessed output is started. */
648 void (*line_change) (cpp_reader *, const cpp_token *, int);
649
650 /* Called when switching to/from a new file.
651 The line_map is for the new file. It is NULL if there is no new file.
652 (In C this happens when done with <built-in>+<command line> and also
653 when done with a main file.) This can be used for resource cleanup. */
654 void (*file_change) (cpp_reader *, const line_map_ordinary *);
655
656 void (*dir_change) (cpp_reader *, const char *);
657 void (*include) (cpp_reader *, location_t, const unsigned char *,
658 const char *, int, const cpp_token **);
659 void (*define) (cpp_reader *, location_t, cpp_hashnode *);
660 void (*undef) (cpp_reader *, location_t, cpp_hashnode *);
661 void (*ident) (cpp_reader *, location_t, const cpp_string *);
662 void (*def_pragma) (cpp_reader *, location_t);
663 int (*valid_pch) (cpp_reader *, const char *, int);
664 void (*read_pch) (cpp_reader *, const char *, int, const char *);
665 missing_header_cb missing_header;
666
667 /* Context-sensitive macro support. Returns macro (if any) that should
668 be expanded. */
669 cpp_hashnode * (*macro_to_expand) (cpp_reader *, const cpp_token *);
670
671 /* Called to emit a diagnostic. This callback receives the
672 translated message. */
673 bool (*diagnostic) (cpp_reader *,
674 enum cpp_diagnostic_level,
675 enum cpp_warning_reason,
676 rich_location *,
677 const char *, va_list *)
678 ATTRIBUTE_FPTR_PRINTF(5,0);
679
680 /* Callbacks for when a macro is expanded, or tested (whether
681 defined or not at the time) in #ifdef, #ifndef or "defined". */
682 void (*used_define) (cpp_reader *, location_t, cpp_hashnode *);
683 void (*used_undef) (cpp_reader *, location_t, cpp_hashnode *);
684 /* Called before #define and #undef or other macro definition
685 changes are processed. */
686 void (*before_define) (cpp_reader *);
687 /* Called whenever a macro is expanded or tested.
688 Second argument is the location of the start of the current expansion. */
689 void (*used) (cpp_reader *, location_t, cpp_hashnode *);
690
691 /* Callback to identify whether an attribute exists. */
692 int (*has_attribute) (cpp_reader *, bool);
693
694 /* Callback to determine whether a built-in function is recognized. */
695 int (*has_builtin) (cpp_reader *);
696
697 /* Callback that can change a user lazy into normal macro. */
698 void (*user_lazy_macro) (cpp_reader *, cpp_macro *, unsigned);
699
700 /* Callback to handle deferred cpp_macros. */
701 cpp_macro *(*user_deferred_macro) (cpp_reader *, location_t, cpp_hashnode *);
702
703 /* Callback to parse SOURCE_DATE_EPOCH from environment. */
704 time_t (*get_source_date_epoch) (cpp_reader *);
705
706 /* Callback for providing suggestions for misspelled directives. */
707 const char *(*get_suggestion) (cpp_reader *, const char *, const char *const *);
708
709 /* Callback for when a comment is encountered, giving the location
710 of the opening slash, a pointer to the content (which is not
711 necessarily 0-terminated), and the length of the content.
712 The content contains the opening slash-star (or slash-slash),
713 and for C-style comments contains the closing star-slash. For
714 C++-style comments it does not include the terminating newline. */
715 void (*comment) (cpp_reader *, location_t, const unsigned char *,
716 size_t);
717
718 /* Callback for filename remapping in __FILE__ and __BASE_FILE__ macro
719 expansions. */
720 const char *(*remap_filename) (const char*);
721
722 /* Maybe translate a #include into something else. Return a
723 cpp_buffer containing the translation if translating. */
724 char *(*translate_include) (cpp_reader *, line_maps *, location_t,
725 const char *path);
726 };
727
728 #ifdef VMS
729 #define INO_T_CPP ino_t ino[3]
730 #else
731 #define INO_T_CPP ino_t ino
732 #endif
733
734 /* Chain of directories to look for include files in. */
735 struct cpp_dir
736 {
737 /* NULL-terminated singly-linked list. */
738 struct cpp_dir *next;
739
740 /* NAME of the directory, NUL-terminated. */
741 char *name;
742 unsigned int len;
743
744 /* One if a system header, two if a system header that has extern
745 "C" guards for C++. */
746 unsigned char sysp;
747
748 /* Is this a user-supplied directory? */
749 bool user_supplied_p;
750
751 /* The canonicalized NAME as determined by lrealpath. This field
752 is only used by hosts that lack reliable inode numbers. */
753 char *canonical_name;
754
755 /* Mapping of file names for this directory for MS-DOS and related
756 platforms. A NULL-terminated array of (from, to) pairs. */
757 const char **name_map;
758
759 /* Routine to construct pathname, given the search path name and the
760 HEADER we are trying to find, return a constructed pathname to
761 try and open. If this is NULL, the constructed pathname is as
762 constructed by append_file_to_dir. */
763 char *(*construct) (const char *header, cpp_dir *dir);
764
765 /* The C front end uses these to recognize duplicated
766 directories in the search path. */
767 INO_T_CPP;
768 dev_t dev;
769 };
770
771 /* The kind of the cpp_macro. */
772 enum cpp_macro_kind {
773 cmk_macro, /* An ISO macro (token expansion). */
774 cmk_assert, /* An assertion. */
775 cmk_traditional /* A traditional macro (text expansion). */
776 };
777
778 /* Each macro definition is recorded in a cpp_macro structure.
779 Variadic macros cannot occur with traditional cpp. */
780 struct GTY(()) cpp_macro {
781 union cpp_parm_u
782 {
783 /* Parameters, if any. If parameter names use extended identifiers,
784 the original spelling of those identifiers, not the canonical
785 UTF-8 spelling, goes here. */
786 cpp_hashnode ** GTY ((tag ("false"),
787 nested_ptr (union tree_node,
788 "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
789 "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL"),
790 length ("%1.paramc"))) params;
791
792 /* If this is an assertion, the next one in the chain. */
793 cpp_macro *GTY ((tag ("true"))) next;
794 } GTY ((desc ("%1.kind == cmk_assert"))) parm;
795
796 /* Definition line number. */
797 location_t line;
798
799 /* Number of tokens in body, or bytes for traditional macros. */
800 /* Do we really need 2^32-1 range here? */
801 unsigned int count;
802
803 /* Number of parameters. */
804 unsigned short paramc;
805
806 /* Non-zero if this is a user-lazy macro, value provided by user. */
807 unsigned char lazy;
808
809 /* The kind of this macro (ISO, trad or assert) */
810 unsigned kind : 2;
811
812 /* If a function-like macro. */
813 unsigned int fun_like : 1;
814
815 /* If a variadic macro. */
816 unsigned int variadic : 1;
817
818 /* If macro defined in system header. */
819 unsigned int syshdr : 1;
820
821 /* Nonzero if it has been expanded or had its existence tested. */
822 unsigned int used : 1;
823
824 /* Indicate whether the tokens include extra CPP_PASTE tokens at the
825 end to track invalid redefinitions with consecutive CPP_PASTE
826 tokens. */
827 unsigned int extra_tokens : 1;
828
829 /* 1 bits spare (32-bit). 33 on 64-bit target. */
830
831 union cpp_exp_u
832 {
833 /* Trailing array of replacement tokens (ISO), or assertion body value. */
834 cpp_token GTY ((tag ("false"), length ("%1.count"))) tokens[1];
835
836 /* Pointer to replacement text (traditional). See comment at top
837 of cpptrad.c for how traditional function-like macros are
838 encoded. */
839 const unsigned char *GTY ((tag ("true"))) text;
840 } GTY ((desc ("%1.kind == cmk_traditional"))) exp;
841 };
842
843 /* Poisoned identifiers are flagged NODE_POISONED. NODE_OPERATOR (C++
844 only) indicates an identifier that behaves like an operator such as
845 "xor". NODE_DIAGNOSTIC is for speed in lex_token: it indicates a
846 diagnostic may be required for this node. Currently this only
847 applies to __VA_ARGS__, poisoned identifiers, and -Wc++-compat
848 warnings about NODE_OPERATOR. */
849
850 /* Hash node flags. */
851 #define NODE_OPERATOR (1 << 0) /* C++ named operator. */
852 #define NODE_POISONED (1 << 1) /* Poisoned identifier. */
853 #define NODE_DIAGNOSTIC (1 << 2) /* Possible diagnostic when lexed. */
854 #define NODE_WARN (1 << 3) /* Warn if redefined or undefined. */
855 #define NODE_DISABLED (1 << 4) /* A disabled macro. */
856 #define NODE_USED (1 << 5) /* Dumped with -dU. */
857 #define NODE_CONDITIONAL (1 << 6) /* Conditional macro */
858 #define NODE_WARN_OPERATOR (1 << 7) /* Warn about C++ named operator. */
859 #define NODE_MODULE (1 << 8) /* C++-20 module-related name. */
860
861 /* Different flavors of hash node. */
862 enum node_type
863 {
864 NT_VOID = 0, /* Maybe an assert? */
865 NT_MACRO_ARG, /* A macro arg. */
866 NT_USER_MACRO, /* A user macro. */
867 NT_BUILTIN_MACRO, /* A builtin macro. */
868 NT_MACRO_MASK = NT_USER_MACRO /* Mask for either macro kind. */
869 };
870
871 /* Different flavors of builtin macro. _Pragma is an operator, but we
872 handle it with the builtin code for efficiency reasons. */
873 enum cpp_builtin_type
874 {
875 BT_SPECLINE = 0, /* `__LINE__' */
876 BT_DATE, /* `__DATE__' */
877 BT_FILE, /* `__FILE__' */
878 BT_BASE_FILE, /* `__BASE_FILE__' */
879 BT_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
880 BT_TIME, /* `__TIME__' */
881 BT_STDC, /* `__STDC__' */
882 BT_PRAGMA, /* `_Pragma' operator */
883 BT_TIMESTAMP, /* `__TIMESTAMP__' */
884 BT_COUNTER, /* `__COUNTER__' */
885 BT_HAS_ATTRIBUTE, /* `__has_attribute(x)' */
886 BT_HAS_STD_ATTRIBUTE, /* `__has_c_attribute(x)' */
887 BT_HAS_BUILTIN, /* `__has_builtin(x)' */
888 BT_HAS_INCLUDE, /* `__has_include(x)' */
889 BT_HAS_INCLUDE_NEXT /* `__has_include_next(x)' */
890 };
891
892 #define CPP_HASHNODE(HNODE) ((cpp_hashnode *) (HNODE))
893 #define HT_NODE(NODE) (&(NODE)->ident)
894 #define NODE_LEN(NODE) HT_LEN (HT_NODE (NODE))
895 #define NODE_NAME(NODE) HT_STR (HT_NODE (NODE))
896
897 /* The common part of an identifier node shared amongst all 3 C front
898 ends. Also used to store CPP identifiers, which are a superset of
899 identifiers in the grammatical sense. */
900
901 union GTY(()) _cpp_hashnode_value {
902 /* Assert (maybe NULL) */
903 cpp_macro * GTY((tag ("NT_VOID"))) answers;
904 /* Macro (maybe NULL) */
905 cpp_macro * GTY((tag ("NT_USER_MACRO"))) macro;
906 /* Code for a builtin macro. */
907 enum cpp_builtin_type GTY ((tag ("NT_BUILTIN_MACRO"))) builtin;
908 /* Macro argument index. */
909 unsigned short GTY ((tag ("NT_MACRO_ARG"))) arg_index;
910 };
911
912 struct GTY(()) cpp_hashnode {
913 struct ht_identifier ident;
914 unsigned int is_directive : 1;
915 unsigned int directive_index : 7; /* If is_directive,
916 then index into directive table.
917 Otherwise, a NODE_OPERATOR. */
918 unsigned int rid_code : 8; /* Rid code - for front ends. */
919 unsigned int flags : 9; /* CPP flags. */
920 ENUM_BITFIELD(node_type) type : 2; /* CPP node type. */
921
922 /* 5 bits spare. */
923
924 /* On a 64-bit system there would be 32-bits of padding to the value
925 field. So placing the deferred index here is not costly. */
926 unsigned deferred; /* Deferred index, (unless zero). */
927
928 union _cpp_hashnode_value GTY ((desc ("%1.type"))) value;
929 };
930
931 /* A class for iterating through the source locations within a
932 string token (before escapes are interpreted, and before
933 concatenation). */
934
935 class cpp_string_location_reader {
936 public:
937 cpp_string_location_reader (location_t src_loc,
938 line_maps *line_table);
939
940 source_range get_next ();
941
942 private:
943 location_t m_loc;
944 int m_offset_per_column;
945 };
946
947 /* A class for storing the source ranges of all of the characters within
948 a string literal, after escapes are interpreted, and after
949 concatenation.
950
951 This is not GTY-marked, as instances are intended to be temporary. */
952
953 class cpp_substring_ranges
954 {
955 public:
956 cpp_substring_ranges ();
957 ~cpp_substring_ranges ();
958
959 int get_num_ranges () const { return m_num_ranges; }
960 source_range get_range (int idx) const
961 {
962 linemap_assert (idx < m_num_ranges);
963 return m_ranges[idx];
964 }
965
966 void add_range (source_range range);
967 void add_n_ranges (int num, cpp_string_location_reader &loc_reader);
968
969 private:
970 source_range *m_ranges;
971 int m_num_ranges;
972 int m_alloc_ranges;
973 };
974
975 /* Call this first to get a handle to pass to other functions.
976
977 If you want cpplib to manage its own hashtable, pass in a NULL
978 pointer. Otherwise you should pass in an initialized hash table
979 that cpplib will share; this technique is used by the C front
980 ends. */
981 extern cpp_reader *cpp_create_reader (enum c_lang, struct ht *,
982 class line_maps *);
983
984 /* Reset the cpp_reader's line_map. This is only used after reading a
985 PCH file. */
986 extern void cpp_set_line_map (cpp_reader *, class line_maps *);
987
988 /* Call this to change the selected language standard (e.g. because of
989 command line options). */
990 extern void cpp_set_lang (cpp_reader *, enum c_lang);
991
992 /* Set the include paths. */
993 extern void cpp_set_include_chains (cpp_reader *, cpp_dir *, cpp_dir *, int);
994
995 /* Call these to get pointers to the options, callback, and deps
996 structures for a given reader. These pointers are good until you
997 call cpp_finish on that reader. You can either edit the callbacks
998 through the pointer returned from cpp_get_callbacks, or set them
999 with cpp_set_callbacks. */
1000 extern cpp_options *cpp_get_options (cpp_reader *) ATTRIBUTE_PURE;
1001 extern cpp_callbacks *cpp_get_callbacks (cpp_reader *) ATTRIBUTE_PURE;
1002 extern void cpp_set_callbacks (cpp_reader *, cpp_callbacks *);
1003 extern class mkdeps *cpp_get_deps (cpp_reader *) ATTRIBUTE_PURE;
1004
1005 extern const char *cpp_find_header_unit (cpp_reader *, const char *file,
1006 bool angle_p, location_t);
1007
1008 /* This function reads the file, but does not start preprocessing. It
1009 returns the name of the original file; this is the same as the
1010 input file, except for preprocessed input. This will generate at
1011 least one file change callback, and possibly a line change callback
1012 too. If there was an error opening the file, it returns NULL. */
1013 extern const char *cpp_read_main_file (cpp_reader *, const char *,
1014 bool injecting = false);
1015 extern location_t cpp_main_loc (const cpp_reader *);
1016
1017 /* Adjust for the main file to be an include. */
1018 extern void cpp_retrofit_as_include (cpp_reader *);
1019
1020 /* Set up built-ins with special behavior. Use cpp_init_builtins()
1021 instead unless your know what you are doing. */
1022 extern void cpp_init_special_builtins (cpp_reader *);
1023
1024 /* Set up built-ins like __FILE__. */
1025 extern void cpp_init_builtins (cpp_reader *, int);
1026
1027 /* This is called after options have been parsed, and partially
1028 processed. */
1029 extern void cpp_post_options (cpp_reader *);
1030
1031 /* Set up translation to the target character set. */
1032 extern void cpp_init_iconv (cpp_reader *);
1033
1034 /* Call this to finish preprocessing. If you requested dependency
1035 generation, pass an open stream to write the information to,
1036 otherwise NULL. It is your responsibility to close the stream. */
1037 extern void cpp_finish (cpp_reader *, FILE *deps_stream);
1038
1039 /* Call this to release the handle at the end of preprocessing. Any
1040 use of the handle after this function returns is invalid. */
1041 extern void cpp_destroy (cpp_reader *);
1042
1043 extern unsigned int cpp_token_len (const cpp_token *);
1044 extern unsigned char *cpp_token_as_text (cpp_reader *, const cpp_token *);
1045 extern unsigned char *cpp_spell_token (cpp_reader *, const cpp_token *,
1046 unsigned char *, bool);
1047 extern void cpp_register_pragma (cpp_reader *, const char *, const char *,
1048 void (*) (cpp_reader *), bool);
1049 extern void cpp_register_deferred_pragma (cpp_reader *, const char *,
1050 const char *, unsigned, bool, bool);
1051 extern int cpp_avoid_paste (cpp_reader *, const cpp_token *,
1052 const cpp_token *);
1053 extern const cpp_token *cpp_get_token (cpp_reader *);
1054 extern const cpp_token *cpp_get_token_with_location (cpp_reader *,
1055 location_t *);
1056 inline bool cpp_user_macro_p (const cpp_hashnode *node)
1057 {
1058 return node->type == NT_USER_MACRO;
1059 }
1060 inline bool cpp_builtin_macro_p (const cpp_hashnode *node)
1061 {
1062 return node->type == NT_BUILTIN_MACRO;
1063 }
1064 inline bool cpp_macro_p (const cpp_hashnode *node)
1065 {
1066 return node->type & NT_MACRO_MASK;
1067 }
1068 inline cpp_macro *cpp_set_deferred_macro (cpp_hashnode *node,
1069 cpp_macro *forced = NULL)
1070 {
1071 cpp_macro *old = node->value.macro;
1072
1073 node->value.macro = forced;
1074 node->type = NT_USER_MACRO;
1075 node->flags &= ~NODE_USED;
1076
1077 return old;
1078 }
1079 cpp_macro *cpp_get_deferred_macro (cpp_reader *, cpp_hashnode *, location_t);
1080
1081 /* Returns true if NODE is a function-like user macro. */
1082 inline bool cpp_fun_like_macro_p (cpp_hashnode *node)
1083 {
1084 return cpp_user_macro_p (node) && node->value.macro->fun_like;
1085 }
1086
1087 extern const unsigned char *cpp_macro_definition (cpp_reader *, cpp_hashnode *);
1088 extern const unsigned char *cpp_macro_definition (cpp_reader *, cpp_hashnode *,
1089 const cpp_macro *);
1090 inline location_t cpp_macro_definition_location (cpp_hashnode *node)
1091 {
1092 const cpp_macro *macro = node->value.macro;
1093 return macro ? macro->line : 0;
1094 }
1095 /* Return an idempotent time stamp (possibly from SOURCE_DATE_EPOCH). */
1096 enum class CPP_time_kind
1097 {
1098 FIXED = -1, /* Fixed time via source epoch. */
1099 DYNAMIC = -2, /* Dynamic via time(2). */
1100 UNKNOWN = -3 /* Wibbly wobbly, timey wimey. */
1101 };
1102 extern CPP_time_kind cpp_get_date (cpp_reader *, time_t *);
1103
1104 extern void _cpp_backup_tokens (cpp_reader *, unsigned int);
1105 extern const cpp_token *cpp_peek_token (cpp_reader *, int);
1106
1107 /* Evaluate a CPP_*CHAR* token. */
1108 extern cppchar_t cpp_interpret_charconst (cpp_reader *, const cpp_token *,
1109 unsigned int *, int *);
1110 /* Evaluate a vector of CPP_*STRING* tokens. */
1111 extern bool cpp_interpret_string (cpp_reader *,
1112 const cpp_string *, size_t,
1113 cpp_string *, enum cpp_ttype);
1114 extern const char *cpp_interpret_string_ranges (cpp_reader *pfile,
1115 const cpp_string *from,
1116 cpp_string_location_reader *,
1117 size_t count,
1118 cpp_substring_ranges *out,
1119 enum cpp_ttype type);
1120 extern bool cpp_interpret_string_notranslate (cpp_reader *,
1121 const cpp_string *, size_t,
1122 cpp_string *, enum cpp_ttype);
1123
1124 /* Convert a host character constant to the execution character set. */
1125 extern cppchar_t cpp_host_to_exec_charset (cpp_reader *, cppchar_t);
1126
1127 /* Used to register macros and assertions, perhaps from the command line.
1128 The text is the same as the command line argument. */
1129 extern void cpp_define (cpp_reader *, const char *);
1130 extern void cpp_define_unused (cpp_reader *, const char *);
1131 extern void cpp_define_formatted (cpp_reader *pfile,
1132 const char *fmt, ...) ATTRIBUTE_PRINTF_2;
1133 extern void cpp_define_formatted_unused (cpp_reader *pfile,
1134 const char *fmt,
1135 ...) ATTRIBUTE_PRINTF_2;
1136 extern void cpp_assert (cpp_reader *, const char *);
1137 extern void cpp_undef (cpp_reader *, const char *);
1138 extern void cpp_unassert (cpp_reader *, const char *);
1139
1140 /* Mark a node as a lazily defined macro. */
1141 extern void cpp_define_lazily (cpp_reader *, cpp_hashnode *node, unsigned N);
1142
1143 /* Undefine all macros and assertions. */
1144 extern void cpp_undef_all (cpp_reader *);
1145
1146 extern cpp_buffer *cpp_push_buffer (cpp_reader *, const unsigned char *,
1147 size_t, int);
1148 extern int cpp_defined (cpp_reader *, const unsigned char *, int);
1149
1150 /* A preprocessing number. Code assumes that any unused high bits of
1151 the double integer are set to zero. */
1152
1153 /* This type has to be equal to unsigned HOST_WIDE_INT, see
1154 gcc/c-family/c-lex.c. */
1155 typedef uint64_t cpp_num_part;
1156 typedef struct cpp_num cpp_num;
1157 struct cpp_num
1158 {
1159 cpp_num_part high;
1160 cpp_num_part low;
1161 bool unsignedp; /* True if value should be treated as unsigned. */
1162 bool overflow; /* True if the most recent calculation overflowed. */
1163 };
1164
1165 /* cpplib provides two interfaces for interpretation of preprocessing
1166 numbers.
1167
1168 cpp_classify_number categorizes numeric constants according to
1169 their field (integer, floating point, or invalid), radix (decimal,
1170 octal, hexadecimal), and type suffixes. */
1171
1172 #define CPP_N_CATEGORY 0x000F
1173 #define CPP_N_INVALID 0x0000
1174 #define CPP_N_INTEGER 0x0001
1175 #define CPP_N_FLOATING 0x0002
1176
1177 #define CPP_N_WIDTH 0x00F0
1178 #define CPP_N_SMALL 0x0010 /* int, float, short _Fract/Accum */
1179 #define CPP_N_MEDIUM 0x0020 /* long, double, long _Fract/_Accum. */
1180 #define CPP_N_LARGE 0x0040 /* long long, long double,
1181 long long _Fract/Accum. */
1182
1183 #define CPP_N_WIDTH_MD 0xF0000 /* machine defined. */
1184 #define CPP_N_MD_W 0x10000
1185 #define CPP_N_MD_Q 0x20000
1186
1187 #define CPP_N_RADIX 0x0F00
1188 #define CPP_N_DECIMAL 0x0100
1189 #define CPP_N_HEX 0x0200
1190 #define CPP_N_OCTAL 0x0400
1191 #define CPP_N_BINARY 0x0800
1192
1193 #define CPP_N_UNSIGNED 0x1000 /* Properties. */
1194 #define CPP_N_IMAGINARY 0x2000
1195 #define CPP_N_DFLOAT 0x4000
1196 #define CPP_N_DEFAULT 0x8000
1197
1198 #define CPP_N_FRACT 0x100000 /* Fract types. */
1199 #define CPP_N_ACCUM 0x200000 /* Accum types. */
1200 #define CPP_N_FLOATN 0x400000 /* _FloatN types. */
1201 #define CPP_N_FLOATNX 0x800000 /* _FloatNx types. */
1202
1203 #define CPP_N_USERDEF 0x1000000 /* C++0x user-defined literal. */
1204
1205 #define CPP_N_WIDTH_FLOATN_NX 0xF0000000 /* _FloatN / _FloatNx value
1206 of N, divided by 16. */
1207 #define CPP_FLOATN_SHIFT 24
1208 #define CPP_FLOATN_MAX 0xF0
1209
1210 /* Classify a CPP_NUMBER token. The return value is a combination of
1211 the flags from the above sets. */
1212 extern unsigned cpp_classify_number (cpp_reader *, const cpp_token *,
1213 const char **, location_t);
1214
1215 /* Return the classification flags for a float suffix. */
1216 extern unsigned int cpp_interpret_float_suffix (cpp_reader *, const char *,
1217 size_t);
1218
1219 /* Return the classification flags for an int suffix. */
1220 extern unsigned int cpp_interpret_int_suffix (cpp_reader *, const char *,
1221 size_t);
1222
1223 /* Evaluate a token classified as category CPP_N_INTEGER. */
1224 extern cpp_num cpp_interpret_integer (cpp_reader *, const cpp_token *,
1225 unsigned int);
1226
1227 /* Sign extend a number, with PRECISION significant bits and all
1228 others assumed clear, to fill out a cpp_num structure. */
1229 cpp_num cpp_num_sign_extend (cpp_num, size_t);
1230
1231 /* Output a diagnostic of some kind. */
1232 extern bool cpp_error (cpp_reader *, enum cpp_diagnostic_level,
1233 const char *msgid, ...)
1234 ATTRIBUTE_PRINTF_3;
1235 extern bool cpp_warning (cpp_reader *, enum cpp_warning_reason,
1236 const char *msgid, ...)
1237 ATTRIBUTE_PRINTF_3;
1238 extern bool cpp_pedwarning (cpp_reader *, enum cpp_warning_reason,
1239 const char *msgid, ...)
1240 ATTRIBUTE_PRINTF_3;
1241 extern bool cpp_warning_syshdr (cpp_reader *, enum cpp_warning_reason reason,
1242 const char *msgid, ...)
1243 ATTRIBUTE_PRINTF_3;
1244
1245 /* Output a diagnostic with "MSGID: " preceding the
1246 error string of errno. No location is printed. */
1247 extern bool cpp_errno (cpp_reader *, enum cpp_diagnostic_level,
1248 const char *msgid);
1249 /* Similarly, but with "FILENAME: " instead of "MSGID: ", where
1250 the filename is not localized. */
1251 extern bool cpp_errno_filename (cpp_reader *, enum cpp_diagnostic_level,
1252 const char *filename, location_t loc);
1253
1254 /* Same as cpp_error, except additionally specifies a position as a
1255 (translation unit) physical line and physical column. If the line is
1256 zero, then no location is printed. */
1257 extern bool cpp_error_with_line (cpp_reader *, enum cpp_diagnostic_level,
1258 location_t, unsigned,
1259 const char *msgid, ...)
1260 ATTRIBUTE_PRINTF_5;
1261 extern bool cpp_warning_with_line (cpp_reader *, enum cpp_warning_reason,
1262 location_t, unsigned,
1263 const char *msgid, ...)
1264 ATTRIBUTE_PRINTF_5;
1265 extern bool cpp_pedwarning_with_line (cpp_reader *, enum cpp_warning_reason,
1266 location_t, unsigned,
1267 const char *msgid, ...)
1268 ATTRIBUTE_PRINTF_5;
1269 extern bool cpp_warning_with_line_syshdr (cpp_reader *, enum cpp_warning_reason,
1270 location_t, unsigned,
1271 const char *msgid, ...)
1272 ATTRIBUTE_PRINTF_5;
1273
1274 extern bool cpp_error_at (cpp_reader * pfile, enum cpp_diagnostic_level,
1275 location_t src_loc, const char *msgid, ...)
1276 ATTRIBUTE_PRINTF_4;
1277
1278 extern bool cpp_error_at (cpp_reader * pfile, enum cpp_diagnostic_level,
1279 rich_location *richloc, const char *msgid, ...)
1280 ATTRIBUTE_PRINTF_4;
1281
1282 /* In lex.c */
1283 extern int cpp_ideq (const cpp_token *, const char *);
1284 extern void cpp_output_line (cpp_reader *, FILE *);
1285 extern unsigned char *cpp_output_line_to_string (cpp_reader *,
1286 const unsigned char *);
1287 extern const unsigned char *cpp_alloc_token_string
1288 (cpp_reader *, const unsigned char *, unsigned);
1289 extern void cpp_output_token (const cpp_token *, FILE *);
1290 extern const char *cpp_type2name (enum cpp_ttype, unsigned char flags);
1291 /* Returns the value of an escape sequence, truncated to the correct
1292 target precision. PSTR points to the input pointer, which is just
1293 after the backslash. LIMIT is how much text we have. WIDE is true
1294 if the escape sequence is part of a wide character constant or
1295 string literal. Handles all relevant diagnostics. */
1296 extern cppchar_t cpp_parse_escape (cpp_reader *, const unsigned char ** pstr,
1297 const unsigned char *limit, int wide);
1298
1299 /* Structure used to hold a comment block at a given location in the
1300 source code. */
1301
1302 typedef struct
1303 {
1304 /* Text of the comment including the terminators. */
1305 char *comment;
1306
1307 /* source location for the given comment. */
1308 location_t sloc;
1309 } cpp_comment;
1310
1311 /* Structure holding all comments for a given cpp_reader. */
1312
1313 typedef struct
1314 {
1315 /* table of comment entries. */
1316 cpp_comment *entries;
1317
1318 /* number of actual entries entered in the table. */
1319 int count;
1320
1321 /* number of entries allocated currently. */
1322 int allocated;
1323 } cpp_comment_table;
1324
1325 /* Returns the table of comments encountered by the preprocessor. This
1326 table is only populated when pfile->state.save_comments is true. */
1327 extern cpp_comment_table *cpp_get_comments (cpp_reader *);
1328
1329 /* In hash.c */
1330
1331 /* Lookup an identifier in the hashtable. Puts the identifier in the
1332 table if it is not already there. */
1333 extern cpp_hashnode *cpp_lookup (cpp_reader *, const unsigned char *,
1334 unsigned int);
1335
1336 typedef int (*cpp_cb) (cpp_reader *, cpp_hashnode *, void *);
1337 extern void cpp_forall_identifiers (cpp_reader *, cpp_cb, void *);
1338
1339 /* In macro.c */
1340 extern void cpp_scan_nooutput (cpp_reader *);
1341 extern int cpp_sys_macro_p (cpp_reader *);
1342 extern unsigned char *cpp_quote_string (unsigned char *, const unsigned char *,
1343 unsigned int);
1344 extern bool cpp_compare_macros (const cpp_macro *macro1,
1345 const cpp_macro *macro2);
1346
1347 /* In files.c */
1348 extern bool cpp_included (cpp_reader *, const char *);
1349 extern bool cpp_included_before (cpp_reader *, const char *, location_t);
1350 extern void cpp_make_system_header (cpp_reader *, int, int);
1351 extern bool cpp_push_include (cpp_reader *, const char *);
1352 extern bool cpp_push_default_include (cpp_reader *, const char *);
1353 extern void cpp_change_file (cpp_reader *, enum lc_reason, const char *);
1354 extern const char *cpp_get_path (struct _cpp_file *);
1355 extern cpp_dir *cpp_get_dir (struct _cpp_file *);
1356 extern cpp_buffer *cpp_get_buffer (cpp_reader *);
1357 extern struct _cpp_file *cpp_get_file (cpp_buffer *);
1358 extern cpp_buffer *cpp_get_prev (cpp_buffer *);
1359 extern void cpp_clear_file_cache (cpp_reader *);
1360
1361 /* In pch.c */
1362 struct save_macro_data;
1363 extern int cpp_save_state (cpp_reader *, FILE *);
1364 extern int cpp_write_pch_deps (cpp_reader *, FILE *);
1365 extern int cpp_write_pch_state (cpp_reader *, FILE *);
1366 extern int cpp_valid_state (cpp_reader *, const char *, int);
1367 extern void cpp_prepare_state (cpp_reader *, struct save_macro_data **);
1368 extern int cpp_read_state (cpp_reader *, const char *, FILE *,
1369 struct save_macro_data *);
1370
1371 /* In lex.c */
1372 extern void cpp_force_token_locations (cpp_reader *, location_t);
1373 extern void cpp_stop_forcing_token_locations (cpp_reader *);
1374 enum CPP_DO_task
1375 {
1376 CPP_DO_print,
1377 CPP_DO_location,
1378 CPP_DO_token
1379 };
1380
1381 extern void cpp_directive_only_process (cpp_reader *pfile,
1382 void *data,
1383 void (*cb) (cpp_reader *,
1384 CPP_DO_task,
1385 void *data, ...));
1386
1387 /* In expr.c */
1388 extern enum cpp_ttype cpp_userdef_string_remove_type
1389 (enum cpp_ttype type);
1390 extern enum cpp_ttype cpp_userdef_string_add_type
1391 (enum cpp_ttype type);
1392 extern enum cpp_ttype cpp_userdef_char_remove_type
1393 (enum cpp_ttype type);
1394 extern enum cpp_ttype cpp_userdef_char_add_type
1395 (enum cpp_ttype type);
1396 extern bool cpp_userdef_string_p
1397 (enum cpp_ttype type);
1398 extern bool cpp_userdef_char_p
1399 (enum cpp_ttype type);
1400 extern const char * cpp_get_userdef_suffix
1401 (const cpp_token *);
1402
1403 /* In charset.c */
1404
1405 /* A class to manage the state while converting a UTF-8 sequence to cppchar_t
1406 and computing the display width one character at a time. */
1407 class cpp_display_width_computation {
1408 public:
1409 cpp_display_width_computation (const char *data, int data_length,
1410 int tabstop);
1411 const char *next_byte () const { return m_next; }
1412 int bytes_processed () const { return m_next - m_begin; }
1413 int bytes_left () const { return m_bytes_left; }
1414 bool done () const { return !bytes_left (); }
1415 int display_cols_processed () const { return m_display_cols; }
1416
1417 int process_next_codepoint ();
1418 int advance_display_cols (int n);
1419
1420 private:
1421 const char *const m_begin;
1422 const char *m_next;
1423 size_t m_bytes_left;
1424 const int m_tabstop;
1425 int m_display_cols;
1426 };
1427
1428 /* Convenience functions that are simple use cases for class
1429 cpp_display_width_computation. Tab characters will be expanded to spaces
1430 as determined by TABSTOP. */
1431 int cpp_byte_column_to_display_column (const char *data, int data_length,
1432 int column, int tabstop);
1433 inline int cpp_display_width (const char *data, int data_length,
1434 int tabstop)
1435 {
1436 return cpp_byte_column_to_display_column (data, data_length, data_length,
1437 tabstop);
1438 }
1439 int cpp_display_column_to_byte_column (const char *data, int data_length,
1440 int display_col, int tabstop);
1441 int cpp_wcwidth (cppchar_t c);
1442
1443 #endif /* ! LIBCPP_CPPLIB_H */