Line data Source code
1 : /* Definitions for CPP library.
2 : Copyright (C) 1995-2023 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.cc 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_GNUCXX23, CLK_CXX23,
177 : CLK_GNUCXX26, CLK_CXX26, CLK_ASM};
178 :
179 : /* Payload of a NUMBER, STRING, CHAR or COMMENT token. */
180 : struct GTY(()) cpp_string {
181 : unsigned int len;
182 :
183 : /* TEXT is always null terminated (terminator not included in len); but this
184 : GTY markup arranges that PCH streaming works properly even if there is a
185 : null byte in the middle of the string. */
186 : const unsigned char * GTY((string_length ("1 + %h.len"))) text;
187 : };
188 :
189 : /* Flags for the cpp_token structure. */
190 : #define PREV_WHITE (1 << 0) /* If whitespace before this token. */
191 : #define DIGRAPH (1 << 1) /* If it was a digraph. */
192 : #define STRINGIFY_ARG (1 << 2) /* If macro argument to be stringified. */
193 : #define PASTE_LEFT (1 << 3) /* If on LHS of a ## operator. */
194 : #define NAMED_OP (1 << 4) /* C++ named operators. */
195 : #define PREV_FALLTHROUGH (1 << 5) /* On a token preceeded by FALLTHROUGH
196 : comment. */
197 : #define DECIMAL_INT (1 << 6) /* Decimal integer, set in c-lex.cc. */
198 : #define PURE_ZERO (1 << 7) /* Single 0 digit, used by the C++ frontend,
199 : set in c-lex.cc. */
200 : #define SP_DIGRAPH (1 << 8) /* # or ## token was a digraph. */
201 : #define SP_PREV_WHITE (1 << 9) /* If whitespace before a ##
202 : operator, or before this token
203 : after a # operator. */
204 : #define NO_EXPAND (1 << 10) /* Do not macro-expand this token. */
205 : #define PRAGMA_OP (1 << 11) /* _Pragma token. */
206 : #define BOL (1 << 12) /* Token at beginning of line. */
207 :
208 : /* Specify which field, if any, of the cpp_token union is used. */
209 :
210 : enum cpp_token_fld_kind {
211 : CPP_TOKEN_FLD_NODE,
212 : CPP_TOKEN_FLD_SOURCE,
213 : CPP_TOKEN_FLD_STR,
214 : CPP_TOKEN_FLD_ARG_NO,
215 : CPP_TOKEN_FLD_TOKEN_NO,
216 : CPP_TOKEN_FLD_PRAGMA,
217 : CPP_TOKEN_FLD_NONE
218 : };
219 :
220 : /* A macro argument in the cpp_token union. */
221 : struct GTY(()) cpp_macro_arg {
222 : /* Argument number. */
223 : unsigned int arg_no;
224 : /* The original spelling of the macro argument token. */
225 : cpp_hashnode *
226 : GTY ((nested_ptr (union tree_node,
227 : "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
228 : "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
229 : spelling;
230 : };
231 :
232 : /* An identifier in the cpp_token union. */
233 : struct GTY(()) cpp_identifier {
234 : /* The canonical (UTF-8) spelling of the identifier. */
235 : cpp_hashnode *
236 : GTY ((nested_ptr (union tree_node,
237 : "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
238 : "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
239 : node;
240 : /* The original spelling of the identifier. */
241 : cpp_hashnode *
242 : GTY ((nested_ptr (union tree_node,
243 : "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
244 : "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
245 : spelling;
246 : };
247 :
248 : /* A preprocessing token. This has been carefully packed and should
249 : occupy 16 bytes on 32-bit hosts and 24 bytes on 64-bit hosts. */
250 : struct GTY(()) cpp_token {
251 :
252 : /* Location of first char of token, together with range of full token. */
253 : location_t src_loc;
254 :
255 : ENUM_BITFIELD(cpp_ttype) type : CHAR_BIT; /* token type */
256 : unsigned short flags; /* flags - see above */
257 :
258 : union cpp_token_u
259 : {
260 : /* An identifier. */
261 : struct cpp_identifier GTY ((tag ("CPP_TOKEN_FLD_NODE"))) node;
262 :
263 : /* Inherit padding from this token. */
264 : cpp_token * GTY ((tag ("CPP_TOKEN_FLD_SOURCE"))) source;
265 :
266 : /* A string, or number. */
267 : struct cpp_string GTY ((tag ("CPP_TOKEN_FLD_STR"))) str;
268 :
269 : /* Argument no. (and original spelling) for a CPP_MACRO_ARG. */
270 : struct cpp_macro_arg GTY ((tag ("CPP_TOKEN_FLD_ARG_NO"))) macro_arg;
271 :
272 : /* Original token no. for a CPP_PASTE (from a sequence of
273 : consecutive paste tokens in a macro expansion). */
274 : unsigned int GTY ((tag ("CPP_TOKEN_FLD_TOKEN_NO"))) token_no;
275 :
276 : /* Caller-supplied identifier for a CPP_PRAGMA. */
277 : unsigned int GTY ((tag ("CPP_TOKEN_FLD_PRAGMA"))) pragma;
278 : } GTY ((desc ("cpp_token_val_index (&%1)"))) val;
279 : };
280 :
281 : /* Say which field is in use. */
282 : extern enum cpp_token_fld_kind cpp_token_val_index (const cpp_token *tok);
283 :
284 : /* A type wide enough to hold any multibyte source character.
285 : cpplib's character constant interpreter requires an unsigned type.
286 : Also, a typedef for the signed equivalent.
287 : The width of this type is capped at 32 bits; there do exist targets
288 : where wchar_t is 64 bits, but only in a non-default mode, and there
289 : would be no meaningful interpretation for a wchar_t value greater
290 : than 2^32 anyway -- the widest wide-character encoding around is
291 : ISO 10646, which stops at 2^31. */
292 : #if CHAR_BIT * SIZEOF_INT >= 32
293 : # define CPPCHAR_SIGNED_T int
294 : #elif CHAR_BIT * SIZEOF_LONG >= 32
295 : # define CPPCHAR_SIGNED_T long
296 : #else
297 : # error "Cannot find a least-32-bit signed integer type"
298 : #endif
299 : typedef unsigned CPPCHAR_SIGNED_T cppchar_t;
300 : typedef CPPCHAR_SIGNED_T cppchar_signed_t;
301 :
302 : /* Style of header dependencies to generate. */
303 : enum cpp_deps_style { DEPS_NONE = 0, DEPS_USER, DEPS_SYSTEM };
304 :
305 : /* The possible normalization levels, from most restrictive to least. */
306 : enum cpp_normalize_level {
307 : /* In NFKC. */
308 : normalized_KC = 0,
309 : /* In NFC. */
310 : normalized_C,
311 : /* In NFC, except for subsequences where being in NFC would make
312 : the identifier invalid. */
313 : normalized_identifier_C,
314 : /* Not normalized at all. */
315 : normalized_none
316 : };
317 :
318 : enum cpp_main_search
319 : {
320 : CMS_none, /* A regular source file. */
321 : CMS_header, /* Is a directly-specified header file (eg PCH or
322 : header-unit). */
323 : CMS_user, /* Search the user INCLUDE path. */
324 : CMS_system, /* Search the system INCLUDE path. */
325 : };
326 :
327 : /* The possible bidirectional control characters checking levels. */
328 : enum cpp_bidirectional_level {
329 : /* No checking. */
330 : bidirectional_none = 0,
331 : /* Only detect unpaired uses of bidirectional control characters. */
332 : bidirectional_unpaired = 1,
333 : /* Detect any use of bidirectional control characters. */
334 : bidirectional_any = 2,
335 : /* Also warn about UCNs. */
336 : bidirectional_ucn = 4
337 : };
338 :
339 : /* This structure is nested inside struct cpp_reader, and
340 : carries all the options visible to the command line. */
341 : struct cpp_options
342 : {
343 : /* The language we're preprocessing. */
344 : enum c_lang lang;
345 :
346 : /* Nonzero means use extra default include directories for C++. */
347 : unsigned char cplusplus;
348 :
349 : /* Nonzero means handle cplusplus style comments. */
350 : unsigned char cplusplus_comments;
351 :
352 : /* Nonzero means define __OBJC__, treat @ as a special token, use
353 : the OBJC[PLUS]_INCLUDE_PATH environment variable, and allow
354 : "#import". */
355 : unsigned char objc;
356 :
357 : /* Nonzero means don't copy comments into the output file. */
358 : unsigned char discard_comments;
359 :
360 : /* Nonzero means don't copy comments into the output file during
361 : macro expansion. */
362 : unsigned char discard_comments_in_macro_exp;
363 :
364 : /* Nonzero means process the ISO trigraph sequences. */
365 : unsigned char trigraphs;
366 :
367 : /* Nonzero means process the ISO digraph sequences. */
368 : unsigned char digraphs;
369 :
370 : /* Nonzero means to allow hexadecimal floats and LL suffixes. */
371 : unsigned char extended_numbers;
372 :
373 : /* Nonzero means process u/U prefix literals (UTF-16/32). */
374 : unsigned char uliterals;
375 :
376 : /* Nonzero means process u8 prefixed character literals (UTF-8). */
377 : unsigned char utf8_char_literals;
378 :
379 : /* Nonzero means process r/R raw strings. If this is set, uliterals
380 : must be set as well. */
381 : unsigned char rliterals;
382 :
383 : /* Nonzero means print names of header files (-H). */
384 : unsigned char print_include_names;
385 :
386 : /* Nonzero means complain about deprecated features. */
387 : unsigned char cpp_warn_deprecated;
388 :
389 : /* Nonzero means warn if slash-star appears in a comment. */
390 : unsigned char warn_comments;
391 :
392 : /* Nonzero means to warn about __DATA__, __TIME__ and __TIMESTAMP__ usage. */
393 : unsigned char warn_date_time;
394 :
395 : /* Nonzero means warn if a user-supplied include directory does not
396 : exist. */
397 : unsigned char warn_missing_include_dirs;
398 :
399 : /* Nonzero means warn if there are any trigraphs. */
400 : unsigned char warn_trigraphs;
401 :
402 : /* Nonzero means warn about multicharacter charconsts. */
403 : unsigned char warn_multichar;
404 :
405 : /* Nonzero means warn about various incompatibilities with
406 : traditional C. */
407 : unsigned char cpp_warn_traditional;
408 :
409 : /* Nonzero means warn about long long numeric constants. */
410 : unsigned char cpp_warn_long_long;
411 :
412 : /* Nonzero means warn about text after an #endif (or #else). */
413 : unsigned char warn_endif_labels;
414 :
415 : /* Nonzero means warn about implicit sign changes owing to integer
416 : promotions. */
417 : unsigned char warn_num_sign_change;
418 :
419 : /* Zero means don't warn about __VA_ARGS__ usage in c89 pedantic mode.
420 : Presumably the usage is protected by the appropriate #ifdef. */
421 : unsigned char warn_variadic_macros;
422 :
423 : /* Nonzero means warn about builtin macros that are redefined or
424 : explicitly undefined. */
425 : unsigned char warn_builtin_macro_redefined;
426 :
427 : /* Different -Wimplicit-fallthrough= levels. */
428 : unsigned char cpp_warn_implicit_fallthrough;
429 :
430 : /* Nonzero means we should look for header.gcc files that remap file
431 : names. */
432 : unsigned char remap;
433 :
434 : /* Zero means dollar signs are punctuation. */
435 : unsigned char dollars_in_ident;
436 :
437 : /* Nonzero means UCNs are accepted in identifiers. */
438 : unsigned char extended_identifiers;
439 :
440 : /* True if we should warn about dollars in identifiers or numbers
441 : for this translation unit. */
442 : unsigned char warn_dollars;
443 :
444 : /* Nonzero means warn if undefined identifiers are evaluated in an #if. */
445 : unsigned char warn_undef;
446 :
447 : /* Nonzero means warn if "defined" is encountered in a place other than
448 : an #if. */
449 : unsigned char warn_expansion_to_defined;
450 :
451 : /* Nonzero means warn of unused macros from the main file. */
452 : unsigned char warn_unused_macros;
453 :
454 : /* Nonzero for the 1999 C Standard, including corrigenda and amendments. */
455 : unsigned char c99;
456 :
457 : /* Nonzero if we are conforming to a specific C or C++ standard. */
458 : unsigned char std;
459 :
460 : /* Nonzero means give all the error messages the ANSI standard requires. */
461 : unsigned char cpp_pedantic;
462 :
463 : /* Nonzero means we're looking at already preprocessed code, so don't
464 : bother trying to do macro expansion and whatnot. */
465 : unsigned char preprocessed;
466 :
467 : /* Nonzero means we are going to emit debugging logs during
468 : preprocessing. */
469 : unsigned char debug;
470 :
471 : /* Nonzero means we are tracking locations of tokens involved in
472 : macro expansion. 1 Means we track the location in degraded mode
473 : where we do not track locations of tokens resulting from the
474 : expansion of arguments of function-like macro. 2 Means we do
475 : track all macro expansions. This last option is the one that
476 : consumes the highest amount of memory. */
477 : unsigned char track_macro_expansion;
478 :
479 : /* Nonzero means handle C++ alternate operator names. */
480 : unsigned char operator_names;
481 :
482 : /* Nonzero means warn about use of C++ alternate operator names. */
483 : unsigned char warn_cxx_operator_names;
484 :
485 : /* True for traditional preprocessing. */
486 : unsigned char traditional;
487 :
488 : /* Nonzero for C++ 2011 Standard user-defined literals. */
489 : unsigned char user_literals;
490 :
491 : /* Nonzero means warn when a string or character literal is followed by a
492 : ud-suffix which does not beging with an underscore. */
493 : unsigned char warn_literal_suffix;
494 :
495 : /* Nonzero means interpret imaginary, fixed-point, or other gnu extension
496 : literal number suffixes as user-defined literal number suffixes. */
497 : unsigned char ext_numeric_literals;
498 :
499 : /* Nonzero means extended identifiers allow the characters specified
500 : in C11. */
501 : unsigned char c11_identifiers;
502 :
503 : /* Nonzero means extended identifiers allow the characters specified
504 : by Unicode XID_Start and XID_Continue properties. */
505 : unsigned char xid_identifiers;
506 :
507 : /* Nonzero for C++ 2014 Standard binary constants. */
508 : unsigned char binary_constants;
509 :
510 : /* Nonzero for C++ 2014 Standard digit separators. */
511 : unsigned char digit_separators;
512 :
513 : /* Nonzero for C2X decimal floating-point constants. */
514 : unsigned char dfp_constants;
515 :
516 : /* Nonzero for C++20 __VA_OPT__ feature. */
517 : unsigned char va_opt;
518 :
519 : /* Nonzero for the '::' token. */
520 : unsigned char scope;
521 :
522 : /* Nonzero for the '#elifdef' and '#elifndef' directives. */
523 : unsigned char elifdef;
524 :
525 : /* Nonzero for the '#warning' directive. */
526 : unsigned char warning_directive;
527 :
528 : /* Nonzero means tokenize C++20 module directives. */
529 : unsigned char module_directives;
530 :
531 : /* Nonzero for C++23 size_t literals. */
532 : unsigned char size_t_literals;
533 :
534 : /* Nonzero for C++23 delimited escape sequences. */
535 : unsigned char delimited_escape_seqs;
536 :
537 : /* Nonzero for 'true' and 'false' in #if expressions. */
538 : unsigned char true_false;
539 :
540 : /* Holds the name of the target (execution) character set. */
541 : const char *narrow_charset;
542 :
543 : /* Holds the name of the target wide character set. */
544 : const char *wide_charset;
545 :
546 : /* Holds the name of the input character set. */
547 : const char *input_charset;
548 :
549 : /* The minimum permitted level of normalization before a warning
550 : is generated. See enum cpp_normalize_level. */
551 : int warn_normalize;
552 :
553 : /* True to warn about precompiled header files we couldn't use. */
554 : bool warn_invalid_pch;
555 :
556 : /* True if dependencies should be restored from a precompiled header. */
557 : bool restore_pch_deps;
558 :
559 : /* True if warn about differences between C90 and C99. */
560 : signed char cpp_warn_c90_c99_compat;
561 :
562 : /* True if warn about differences between C11 and C2X. */
563 : signed char cpp_warn_c11_c2x_compat;
564 :
565 : /* True if warn about differences between C++98 and C++11. */
566 : bool cpp_warn_cxx11_compat;
567 :
568 : /* True if warn about differences between C++17 and C++20. */
569 : bool cpp_warn_cxx20_compat;
570 :
571 : /* Nonzero if bidirectional control characters checking is on. See enum
572 : cpp_bidirectional_level. */
573 : unsigned char cpp_warn_bidirectional;
574 :
575 : /* True if libcpp should warn about invalid UTF-8 characters in comments.
576 : 2 if it should be a pedwarn. */
577 : unsigned char cpp_warn_invalid_utf8;
578 :
579 : /* True if libcpp should warn about invalid forms of delimited or named
580 : escape sequences. */
581 : bool cpp_warn_unicode;
582 :
583 : /* True if -finput-charset= option has been used explicitly. */
584 : bool cpp_input_charset_explicit;
585 :
586 : /* Dependency generation. */
587 : struct
588 : {
589 : /* Style of header dependencies to generate. */
590 : enum cpp_deps_style style;
591 :
592 : /* Assume missing files are generated files. */
593 : bool missing_files;
594 :
595 : /* Generate phony targets for each dependency apart from the first
596 : one. */
597 : bool phony_targets;
598 :
599 : /* Generate dependency info for modules. */
600 : bool modules;
601 :
602 : /* If true, no dependency is generated on the main file. */
603 : bool ignore_main_file;
604 :
605 : /* If true, intend to use the preprocessor output (e.g., for compilation)
606 : in addition to the dependency info. */
607 : bool need_preprocessor_output;
608 : } deps;
609 :
610 : /* Target-specific features set by the front end or client. */
611 :
612 : /* Precision for target CPP arithmetic, target characters, target
613 : ints and target wide characters, respectively. */
614 : size_t precision, char_precision, int_precision, wchar_precision;
615 :
616 : /* True means chars (wide chars, UTF-8 chars) are unsigned. */
617 : bool unsigned_char, unsigned_wchar, unsigned_utf8char;
618 :
619 : /* True if the most significant byte in a word has the lowest
620 : address in memory. */
621 : bool bytes_big_endian;
622 :
623 : /* Nonzero means __STDC__ should have the value 0 in system headers. */
624 : unsigned char stdc_0_in_system_headers;
625 :
626 : /* True disables tokenization outside of preprocessing directives. */
627 : bool directives_only;
628 :
629 : /* True enables canonicalization of system header file paths. */
630 : bool canonical_system_headers;
631 :
632 : /* The maximum depth of the nested #include. */
633 : unsigned int max_include_depth;
634 :
635 : cpp_main_search main_search : 8;
636 : };
637 :
638 : /* Diagnostic levels. To get a diagnostic without associating a
639 : position in the translation unit with it, use cpp_error_with_line
640 : with a line number of zero. */
641 :
642 : enum cpp_diagnostic_level {
643 : /* Warning, an error with -Werror. */
644 : CPP_DL_WARNING = 0,
645 : /* Same as CPP_DL_WARNING, except it is not suppressed in system headers. */
646 : CPP_DL_WARNING_SYSHDR,
647 : /* Warning, an error with -pedantic-errors or -Werror. */
648 : CPP_DL_PEDWARN,
649 : /* An error. */
650 : CPP_DL_ERROR,
651 : /* An internal consistency check failed. Prints "internal error: ",
652 : otherwise the same as CPP_DL_ERROR. */
653 : CPP_DL_ICE,
654 : /* An informative note following a warning. */
655 : CPP_DL_NOTE,
656 : /* A fatal error. */
657 : CPP_DL_FATAL
658 : };
659 :
660 : /* Warning reason codes. Use a reason code of CPP_W_NONE for unclassified
661 : warnings and diagnostics that are not warnings. */
662 :
663 : enum cpp_warning_reason {
664 : CPP_W_NONE = 0,
665 : CPP_W_DEPRECATED,
666 : CPP_W_COMMENTS,
667 : CPP_W_MISSING_INCLUDE_DIRS,
668 : CPP_W_TRIGRAPHS,
669 : CPP_W_MULTICHAR,
670 : CPP_W_TRADITIONAL,
671 : CPP_W_LONG_LONG,
672 : CPP_W_ENDIF_LABELS,
673 : CPP_W_NUM_SIGN_CHANGE,
674 : CPP_W_VARIADIC_MACROS,
675 : CPP_W_BUILTIN_MACRO_REDEFINED,
676 : CPP_W_DOLLARS,
677 : CPP_W_UNDEF,
678 : CPP_W_UNUSED_MACROS,
679 : CPP_W_CXX_OPERATOR_NAMES,
680 : CPP_W_NORMALIZE,
681 : CPP_W_INVALID_PCH,
682 : CPP_W_WARNING_DIRECTIVE,
683 : CPP_W_LITERAL_SUFFIX,
684 : CPP_W_SIZE_T_LITERALS,
685 : CPP_W_DATE_TIME,
686 : CPP_W_PEDANTIC,
687 : CPP_W_C90_C99_COMPAT,
688 : CPP_W_C11_C2X_COMPAT,
689 : CPP_W_CXX11_COMPAT,
690 : CPP_W_CXX20_COMPAT,
691 : CPP_W_EXPANSION_TO_DEFINED,
692 : CPP_W_BIDIRECTIONAL,
693 : CPP_W_INVALID_UTF8,
694 : CPP_W_UNICODE
695 : };
696 :
697 : /* Callback for header lookup for HEADER, which is the name of a
698 : source file. It is used as a method of last resort to find headers
699 : that are not otherwise found during the normal include processing.
700 : The return value is the malloced name of a header to try and open,
701 : if any, or NULL otherwise. This callback is called only if the
702 : header is otherwise unfound. */
703 : typedef const char *(*missing_header_cb)(cpp_reader *, const char *header, cpp_dir **);
704 :
705 : /* Call backs to cpplib client. */
706 : struct cpp_callbacks
707 : {
708 : /* Called when a new line of preprocessed output is started. */
709 : void (*line_change) (cpp_reader *, const cpp_token *, int);
710 :
711 : /* Called when switching to/from a new file.
712 : The line_map is for the new file. It is NULL if there is no new file.
713 : (In C this happens when done with <built-in>+<command line> and also
714 : when done with a main file.) This can be used for resource cleanup. */
715 : void (*file_change) (cpp_reader *, const line_map_ordinary *);
716 :
717 : void (*dir_change) (cpp_reader *, const char *);
718 : void (*include) (cpp_reader *, location_t, const unsigned char *,
719 : const char *, int, const cpp_token **);
720 : void (*define) (cpp_reader *, location_t, cpp_hashnode *);
721 : void (*undef) (cpp_reader *, location_t, cpp_hashnode *);
722 : void (*ident) (cpp_reader *, location_t, const cpp_string *);
723 : void (*def_pragma) (cpp_reader *, location_t);
724 : int (*valid_pch) (cpp_reader *, const char *, int);
725 : void (*read_pch) (cpp_reader *, const char *, int, const char *);
726 : missing_header_cb missing_header;
727 :
728 : /* Context-sensitive macro support. Returns macro (if any) that should
729 : be expanded. */
730 : cpp_hashnode * (*macro_to_expand) (cpp_reader *, const cpp_token *);
731 :
732 : /* Called to emit a diagnostic. This callback receives the
733 : translated message. */
734 : bool (*diagnostic) (cpp_reader *,
735 : enum cpp_diagnostic_level,
736 : enum cpp_warning_reason,
737 : rich_location *,
738 : const char *, va_list *)
739 : ATTRIBUTE_FPTR_PRINTF(5,0);
740 :
741 : /* Callbacks for when a macro is expanded, or tested (whether
742 : defined or not at the time) in #ifdef, #ifndef or "defined". */
743 : void (*used_define) (cpp_reader *, location_t, cpp_hashnode *);
744 : void (*used_undef) (cpp_reader *, location_t, cpp_hashnode *);
745 : /* Called before #define and #undef or other macro definition
746 : changes are processed. */
747 : void (*before_define) (cpp_reader *);
748 : /* Called whenever a macro is expanded or tested.
749 : Second argument is the location of the start of the current expansion. */
750 : void (*used) (cpp_reader *, location_t, cpp_hashnode *);
751 :
752 : /* Callback to identify whether an attribute exists. */
753 : int (*has_attribute) (cpp_reader *, bool);
754 :
755 : /* Callback to determine whether a built-in function is recognized. */
756 : int (*has_builtin) (cpp_reader *);
757 :
758 : /* Callback that can change a user lazy into normal macro. */
759 : void (*user_lazy_macro) (cpp_reader *, cpp_macro *, unsigned);
760 :
761 : /* Callback to handle deferred cpp_macros. */
762 : cpp_macro *(*user_deferred_macro) (cpp_reader *, location_t, cpp_hashnode *);
763 :
764 : /* Callback to parse SOURCE_DATE_EPOCH from environment. */
765 : time_t (*get_source_date_epoch) (cpp_reader *);
766 :
767 : /* Callback for providing suggestions for misspelled directives. */
768 : const char *(*get_suggestion) (cpp_reader *, const char *, const char *const *);
769 :
770 : /* Callback for when a comment is encountered, giving the location
771 : of the opening slash, a pointer to the content (which is not
772 : necessarily 0-terminated), and the length of the content.
773 : The content contains the opening slash-star (or slash-slash),
774 : and for C-style comments contains the closing star-slash. For
775 : C++-style comments it does not include the terminating newline. */
776 : void (*comment) (cpp_reader *, location_t, const unsigned char *,
777 : size_t);
778 :
779 : /* Callback for filename remapping in __FILE__ and __BASE_FILE__ macro
780 : expansions. */
781 : const char *(*remap_filename) (const char*);
782 :
783 : /* Maybe translate a #include into something else. Return a
784 : cpp_buffer containing the translation if translating. */
785 : char *(*translate_include) (cpp_reader *, line_maps *, location_t,
786 : const char *path);
787 : };
788 :
789 : #ifdef VMS
790 : #define INO_T_CPP ino_t ino[3]
791 : #elif defined (_AIX) && SIZEOF_INO_T == 4
792 : #define INO_T_CPP ino64_t ino
793 : #else
794 : #define INO_T_CPP ino_t ino
795 : #endif
796 :
797 : #if defined (_AIX) && SIZEOF_DEV_T == 4
798 : #define DEV_T_CPP dev64_t dev
799 : #else
800 : #define DEV_T_CPP dev_t dev
801 : #endif
802 :
803 : /* Chain of directories to look for include files in. */
804 : struct cpp_dir
805 : {
806 : /* NULL-terminated singly-linked list. */
807 : struct cpp_dir *next;
808 :
809 : /* NAME of the directory, NUL-terminated. */
810 : char *name;
811 : unsigned int len;
812 :
813 : /* One if a system header, two if a system header that has extern
814 : "C" guards for C++. */
815 : unsigned char sysp;
816 :
817 : /* Is this a user-supplied directory? */
818 : bool user_supplied_p;
819 :
820 : /* The canonicalized NAME as determined by lrealpath. This field
821 : is only used by hosts that lack reliable inode numbers. */
822 : char *canonical_name;
823 :
824 : /* Mapping of file names for this directory for MS-DOS and related
825 : platforms. A NULL-terminated array of (from, to) pairs. */
826 : const char **name_map;
827 :
828 : /* Routine to construct pathname, given the search path name and the
829 : HEADER we are trying to find, return a constructed pathname to
830 : try and open. If this is NULL, the constructed pathname is as
831 : constructed by append_file_to_dir. */
832 : char *(*construct) (const char *header, cpp_dir *dir);
833 :
834 : /* The C front end uses these to recognize duplicated
835 : directories in the search path. */
836 : INO_T_CPP;
837 : DEV_T_CPP;
838 : };
839 :
840 : /* The kind of the cpp_macro. */
841 : enum cpp_macro_kind {
842 : cmk_macro, /* An ISO macro (token expansion). */
843 : cmk_assert, /* An assertion. */
844 : cmk_traditional /* A traditional macro (text expansion). */
845 : };
846 :
847 : /* Each macro definition is recorded in a cpp_macro structure.
848 : Variadic macros cannot occur with traditional cpp. */
849 : struct GTY(()) cpp_macro {
850 : union cpp_parm_u
851 : {
852 : /* Parameters, if any. If parameter names use extended identifiers,
853 : the original spelling of those identifiers, not the canonical
854 : UTF-8 spelling, goes here. */
855 : cpp_hashnode ** GTY ((tag ("false"),
856 : nested_ptr (union tree_node,
857 : "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
858 : "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL"),
859 : length ("%1.paramc"))) params;
860 :
861 : /* If this is an assertion, the next one in the chain. */
862 : cpp_macro *GTY ((tag ("true"))) next;
863 : } GTY ((desc ("%1.kind == cmk_assert"))) parm;
864 :
865 : /* Definition line number. */
866 : location_t line;
867 :
868 : /* Number of tokens in body, or bytes for traditional macros. */
869 : /* Do we really need 2^32-1 range here? */
870 : unsigned int count;
871 :
872 : /* Number of parameters. */
873 : unsigned short paramc;
874 :
875 : /* Non-zero if this is a user-lazy macro, value provided by user. */
876 : unsigned char lazy;
877 :
878 : /* The kind of this macro (ISO, trad or assert) */
879 : unsigned kind : 2;
880 :
881 : /* If a function-like macro. */
882 : unsigned int fun_like : 1;
883 :
884 : /* If a variadic macro. */
885 : unsigned int variadic : 1;
886 :
887 : /* If macro defined in system header. */
888 : unsigned int syshdr : 1;
889 :
890 : /* Nonzero if it has been expanded or had its existence tested. */
891 : unsigned int used : 1;
892 :
893 : /* Indicate whether the tokens include extra CPP_PASTE tokens at the
894 : end to track invalid redefinitions with consecutive CPP_PASTE
895 : tokens. */
896 : unsigned int extra_tokens : 1;
897 :
898 : /* Imported C++20 macro (from a header unit). */
899 : unsigned int imported_p : 1;
900 :
901 : /* 0 bits spare (32-bit). 32 on 64-bit target. */
902 :
903 : union cpp_exp_u
904 : {
905 : /* Trailing array of replacement tokens (ISO), or assertion body value. */
906 : cpp_token GTY ((tag ("false"), length ("%1.count"))) tokens[1];
907 :
908 : /* Pointer to replacement text (traditional). See comment at top
909 : of cpptrad.c for how traditional function-like macros are
910 : encoded. */
911 : const unsigned char *GTY ((tag ("true"))) text;
912 : } GTY ((desc ("%1.kind == cmk_traditional"))) exp;
913 : };
914 :
915 : /* Poisoned identifiers are flagged NODE_POISONED. NODE_OPERATOR (C++
916 : only) indicates an identifier that behaves like an operator such as
917 : "xor". NODE_DIAGNOSTIC is for speed in lex_token: it indicates a
918 : diagnostic may be required for this node. Currently this only
919 : applies to __VA_ARGS__, poisoned identifiers, and -Wc++-compat
920 : warnings about NODE_OPERATOR. */
921 :
922 : /* Hash node flags. */
923 : #define NODE_OPERATOR (1 << 0) /* C++ named operator. */
924 : #define NODE_POISONED (1 << 1) /* Poisoned identifier. */
925 : #define NODE_DIAGNOSTIC (1 << 2) /* Possible diagnostic when lexed. */
926 : #define NODE_WARN (1 << 3) /* Warn if redefined or undefined. */
927 : #define NODE_DISABLED (1 << 4) /* A disabled macro. */
928 : #define NODE_USED (1 << 5) /* Dumped with -dU. */
929 : #define NODE_CONDITIONAL (1 << 6) /* Conditional macro */
930 : #define NODE_WARN_OPERATOR (1 << 7) /* Warn about C++ named operator. */
931 : #define NODE_MODULE (1 << 8) /* C++-20 module-related name. */
932 :
933 : /* Different flavors of hash node. */
934 : enum node_type
935 : {
936 : NT_VOID = 0, /* Maybe an assert? */
937 : NT_MACRO_ARG, /* A macro arg. */
938 : NT_USER_MACRO, /* A user macro. */
939 : NT_BUILTIN_MACRO, /* A builtin macro. */
940 : NT_MACRO_MASK = NT_USER_MACRO /* Mask for either macro kind. */
941 : };
942 :
943 : /* Different flavors of builtin macro. _Pragma is an operator, but we
944 : handle it with the builtin code for efficiency reasons. */
945 : enum cpp_builtin_type
946 : {
947 : BT_SPECLINE = 0, /* `__LINE__' */
948 : BT_DATE, /* `__DATE__' */
949 : BT_FILE, /* `__FILE__' */
950 : BT_FILE_NAME, /* `__FILE_NAME__' */
951 : BT_BASE_FILE, /* `__BASE_FILE__' */
952 : BT_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
953 : BT_TIME, /* `__TIME__' */
954 : BT_STDC, /* `__STDC__' */
955 : BT_PRAGMA, /* `_Pragma' operator */
956 : BT_TIMESTAMP, /* `__TIMESTAMP__' */
957 : BT_COUNTER, /* `__COUNTER__' */
958 : BT_HAS_ATTRIBUTE, /* `__has_attribute(x)' */
959 : BT_HAS_STD_ATTRIBUTE, /* `__has_c_attribute(x)' */
960 : BT_HAS_BUILTIN, /* `__has_builtin(x)' */
961 : BT_HAS_INCLUDE, /* `__has_include(x)' */
962 : BT_HAS_INCLUDE_NEXT /* `__has_include_next(x)' */
963 : };
964 :
965 : #define CPP_HASHNODE(HNODE) ((cpp_hashnode *) (HNODE))
966 : #define HT_NODE(NODE) (&(NODE)->ident)
967 : #define NODE_LEN(NODE) HT_LEN (HT_NODE (NODE))
968 : #define NODE_NAME(NODE) HT_STR (HT_NODE (NODE))
969 :
970 : /* The common part of an identifier node shared amongst all 3 C front
971 : ends. Also used to store CPP identifiers, which are a superset of
972 : identifiers in the grammatical sense. */
973 :
974 : union GTY(()) _cpp_hashnode_value {
975 : /* Assert (maybe NULL) */
976 : cpp_macro * GTY((tag ("NT_VOID"))) answers;
977 : /* Macro (maybe NULL) */
978 : cpp_macro * GTY((tag ("NT_USER_MACRO"))) macro;
979 : /* Code for a builtin macro. */
980 : enum cpp_builtin_type GTY ((tag ("NT_BUILTIN_MACRO"))) builtin;
981 : /* Macro argument index. */
982 : unsigned short GTY ((tag ("NT_MACRO_ARG"))) arg_index;
983 : };
984 :
985 : struct GTY(()) cpp_hashnode {
986 : struct ht_identifier ident;
987 : unsigned int is_directive : 1;
988 : unsigned int directive_index : 7; /* If is_directive,
989 : then index into directive table.
990 : Otherwise, a NODE_OPERATOR. */
991 : unsigned int rid_code : 8; /* Rid code - for front ends. */
992 : unsigned int flags : 9; /* CPP flags. */
993 : ENUM_BITFIELD(node_type) type : 2; /* CPP node type. */
994 :
995 : /* 5 bits spare. */
996 :
997 : /* The deferred cookie is applicable to NT_USER_MACRO or NT_VOID.
998 : The latter for when a macro had a prevailing undef.
999 : On a 64-bit system there would be 32-bits of padding to the value
1000 : field. So placing the deferred index here is not costly. */
1001 : unsigned deferred; /* Deferred cookie */
1002 :
1003 : union _cpp_hashnode_value GTY ((desc ("%1.type"))) value;
1004 : };
1005 :
1006 : /* A class for iterating through the source locations within a
1007 : string token (before escapes are interpreted, and before
1008 : concatenation). */
1009 :
1010 : class cpp_string_location_reader {
1011 : public:
1012 : cpp_string_location_reader (location_t src_loc,
1013 : line_maps *line_table);
1014 :
1015 : source_range get_next ();
1016 :
1017 : private:
1018 : location_t m_loc;
1019 : int m_offset_per_column;
1020 : };
1021 :
1022 : /* A class for storing the source ranges of all of the characters within
1023 : a string literal, after escapes are interpreted, and after
1024 : concatenation.
1025 :
1026 : This is not GTY-marked, as instances are intended to be temporary. */
1027 :
1028 : class cpp_substring_ranges
1029 : {
1030 : public:
1031 : cpp_substring_ranges ();
1032 : ~cpp_substring_ranges ();
1033 :
1034 : int get_num_ranges () const { return m_num_ranges; }
1035 : source_range get_range (int idx) const
1036 : {
1037 : linemap_assert (idx < m_num_ranges);
1038 : return m_ranges[idx];
1039 : }
1040 :
1041 : void add_range (source_range range);
1042 : void add_n_ranges (int num, cpp_string_location_reader &loc_reader);
1043 :
1044 : private:
1045 : source_range *m_ranges;
1046 : int m_num_ranges;
1047 : int m_alloc_ranges;
1048 : };
1049 :
1050 : /* Call this first to get a handle to pass to other functions.
1051 :
1052 : If you want cpplib to manage its own hashtable, pass in a NULL
1053 : pointer. Otherwise you should pass in an initialized hash table
1054 : that cpplib will share; this technique is used by the C front
1055 : ends. */
1056 : extern cpp_reader *cpp_create_reader (enum c_lang, struct ht *,
1057 : class line_maps *);
1058 :
1059 : /* Reset the cpp_reader's line_map. This is only used after reading a
1060 : PCH file. */
1061 : extern void cpp_set_line_map (cpp_reader *, class line_maps *);
1062 :
1063 : /* Call this to change the selected language standard (e.g. because of
1064 : command line options). */
1065 : extern void cpp_set_lang (cpp_reader *, enum c_lang);
1066 :
1067 : /* Set the include paths. */
1068 : extern void cpp_set_include_chains (cpp_reader *, cpp_dir *, cpp_dir *, int);
1069 :
1070 : /* Call these to get pointers to the options, callback, and deps
1071 : structures for a given reader. These pointers are good until you
1072 : call cpp_finish on that reader. You can either edit the callbacks
1073 : through the pointer returned from cpp_get_callbacks, or set them
1074 : with cpp_set_callbacks. */
1075 : extern cpp_options *cpp_get_options (cpp_reader *) ATTRIBUTE_PURE;
1076 : extern cpp_callbacks *cpp_get_callbacks (cpp_reader *) ATTRIBUTE_PURE;
1077 : extern void cpp_set_callbacks (cpp_reader *, cpp_callbacks *);
1078 : extern class mkdeps *cpp_get_deps (cpp_reader *) ATTRIBUTE_PURE;
1079 :
1080 : extern const char *cpp_probe_header_unit (cpp_reader *, const char *file,
1081 : bool angle_p, location_t);
1082 :
1083 : /* Call these to get name data about the various compile-time
1084 : charsets. */
1085 : extern const char *cpp_get_narrow_charset_name (cpp_reader *) ATTRIBUTE_PURE;
1086 : extern const char *cpp_get_wide_charset_name (cpp_reader *) ATTRIBUTE_PURE;
1087 :
1088 : /* This function reads the file, but does not start preprocessing. It
1089 : returns the name of the original file; this is the same as the
1090 : input file, except for preprocessed input. This will generate at
1091 : least one file change callback, and possibly a line change callback
1092 : too. If there was an error opening the file, it returns NULL. */
1093 : extern const char *cpp_read_main_file (cpp_reader *, const char *,
1094 : bool injecting = false);
1095 : extern location_t cpp_main_loc (const cpp_reader *);
1096 :
1097 : /* Adjust for the main file to be an include. */
1098 : extern void cpp_retrofit_as_include (cpp_reader *);
1099 :
1100 : /* Set up built-ins with special behavior. Use cpp_init_builtins()
1101 : instead unless your know what you are doing. */
1102 : extern void cpp_init_special_builtins (cpp_reader *);
1103 :
1104 : /* Set up built-ins like __FILE__. */
1105 : extern void cpp_init_builtins (cpp_reader *, int);
1106 :
1107 : /* This is called after options have been parsed, and partially
1108 : processed. */
1109 : extern void cpp_post_options (cpp_reader *);
1110 :
1111 : /* Set up translation to the target character set. */
1112 : extern void cpp_init_iconv (cpp_reader *);
1113 :
1114 : /* Call this to finish preprocessing. If you requested dependency
1115 : generation, pass an open stream to write the information to,
1116 : otherwise NULL. It is your responsibility to close the stream. */
1117 : extern void cpp_finish (cpp_reader *, FILE *deps_stream);
1118 :
1119 : /* Call this to release the handle at the end of preprocessing. Any
1120 : use of the handle after this function returns is invalid. */
1121 : extern void cpp_destroy (cpp_reader *);
1122 :
1123 : extern unsigned int cpp_token_len (const cpp_token *);
1124 : extern unsigned char *cpp_token_as_text (cpp_reader *, const cpp_token *);
1125 : extern unsigned char *cpp_spell_token (cpp_reader *, const cpp_token *,
1126 : unsigned char *, bool);
1127 : extern void cpp_register_pragma (cpp_reader *, const char *, const char *,
1128 : void (*) (cpp_reader *), bool);
1129 : extern void cpp_register_deferred_pragma (cpp_reader *, const char *,
1130 : const char *, unsigned, bool, bool);
1131 : extern int cpp_avoid_paste (cpp_reader *, const cpp_token *,
1132 : const cpp_token *);
1133 : extern const cpp_token *cpp_get_token (cpp_reader *);
1134 : extern const cpp_token *cpp_get_token_with_location (cpp_reader *,
1135 : location_t *);
1136 2885698 : inline bool cpp_user_macro_p (const cpp_hashnode *node)
1137 : {
1138 2885698 : return node->type == NT_USER_MACRO;
1139 : }
1140 : inline bool cpp_builtin_macro_p (const cpp_hashnode *node)
1141 : {
1142 : return node->type == NT_BUILTIN_MACRO;
1143 : }
1144 : inline bool cpp_macro_p (const cpp_hashnode *node)
1145 : {
1146 : return node->type & NT_MACRO_MASK;
1147 : }
1148 124890 : inline cpp_macro *cpp_set_deferred_macro (cpp_hashnode *node,
1149 : cpp_macro *forced = NULL)
1150 : {
1151 124890 : cpp_macro *old = node->value.macro;
1152 :
1153 124890 : node->value.macro = forced;
1154 124890 : node->type = NT_USER_MACRO;
1155 124890 : node->flags &= ~NODE_USED;
1156 :
1157 124890 : return old;
1158 : }
1159 : cpp_macro *cpp_get_deferred_macro (cpp_reader *, cpp_hashnode *, location_t);
1160 :
1161 : /* Returns true if NODE is a function-like user macro. */
1162 : inline bool cpp_fun_like_macro_p (cpp_hashnode *node)
1163 : {
1164 : return cpp_user_macro_p (node) && node->value.macro->fun_like;
1165 : }
1166 :
1167 : extern const unsigned char *cpp_macro_definition (cpp_reader *, cpp_hashnode *);
1168 : extern const unsigned char *cpp_macro_definition (cpp_reader *, cpp_hashnode *,
1169 : const cpp_macro *);
1170 86 : inline location_t cpp_macro_definition_location (cpp_hashnode *node)
1171 : {
1172 86 : const cpp_macro *macro = node->value.macro;
1173 86 : return macro ? macro->line : 0;
1174 : }
1175 : /* Return an idempotent time stamp (possibly from SOURCE_DATE_EPOCH). */
1176 : enum class CPP_time_kind
1177 : {
1178 : FIXED = -1, /* Fixed time via source epoch. */
1179 : DYNAMIC = -2, /* Dynamic via time(2). */
1180 : UNKNOWN = -3 /* Wibbly wobbly, timey wimey. */
1181 : };
1182 : extern CPP_time_kind cpp_get_date (cpp_reader *, time_t *);
1183 :
1184 : extern void _cpp_backup_tokens (cpp_reader *, unsigned int);
1185 : extern const cpp_token *cpp_peek_token (cpp_reader *, int);
1186 :
1187 : /* Evaluate a CPP_*CHAR* token. */
1188 : extern cppchar_t cpp_interpret_charconst (cpp_reader *, const cpp_token *,
1189 : unsigned int *, int *);
1190 : /* Evaluate a vector of CPP_*STRING* tokens. */
1191 : extern bool cpp_interpret_string (cpp_reader *,
1192 : const cpp_string *, size_t,
1193 : cpp_string *, enum cpp_ttype);
1194 : extern const char *cpp_interpret_string_ranges (cpp_reader *pfile,
1195 : const cpp_string *from,
1196 : cpp_string_location_reader *,
1197 : size_t count,
1198 : cpp_substring_ranges *out,
1199 : enum cpp_ttype type);
1200 : extern bool cpp_interpret_string_notranslate (cpp_reader *,
1201 : const cpp_string *, size_t,
1202 : cpp_string *, enum cpp_ttype);
1203 :
1204 : /* Convert a host character constant to the execution character set. */
1205 : extern cppchar_t cpp_host_to_exec_charset (cpp_reader *, cppchar_t);
1206 :
1207 : /* Used to register macros and assertions, perhaps from the command line.
1208 : The text is the same as the command line argument. */
1209 : extern void cpp_define (cpp_reader *, const char *);
1210 : extern void cpp_define_unused (cpp_reader *, const char *);
1211 : extern void cpp_define_formatted (cpp_reader *pfile,
1212 : const char *fmt, ...) ATTRIBUTE_PRINTF_2;
1213 : extern void cpp_define_formatted_unused (cpp_reader *pfile,
1214 : const char *fmt,
1215 : ...) ATTRIBUTE_PRINTF_2;
1216 : extern void cpp_assert (cpp_reader *, const char *);
1217 : extern void cpp_undef (cpp_reader *, const char *);
1218 : extern void cpp_unassert (cpp_reader *, const char *);
1219 :
1220 : /* Mark a node as a lazily defined macro. */
1221 : extern void cpp_define_lazily (cpp_reader *, cpp_hashnode *node, unsigned N);
1222 :
1223 : /* Undefine all macros and assertions. */
1224 : extern void cpp_undef_all (cpp_reader *);
1225 :
1226 : extern cpp_buffer *cpp_push_buffer (cpp_reader *, const unsigned char *,
1227 : size_t, int);
1228 : extern int cpp_defined (cpp_reader *, const unsigned char *, int);
1229 :
1230 : /* A preprocessing number. Code assumes that any unused high bits of
1231 : the double integer are set to zero. */
1232 :
1233 : /* This type has to be equal to unsigned HOST_WIDE_INT, see
1234 : gcc/c-family/c-lex.cc. */
1235 : typedef uint64_t cpp_num_part;
1236 : typedef struct cpp_num cpp_num;
1237 : struct cpp_num
1238 : {
1239 : cpp_num_part high;
1240 : cpp_num_part low;
1241 : bool unsignedp; /* True if value should be treated as unsigned. */
1242 : bool overflow; /* True if the most recent calculation overflowed. */
1243 : };
1244 :
1245 : /* cpplib provides two interfaces for interpretation of preprocessing
1246 : numbers.
1247 :
1248 : cpp_classify_number categorizes numeric constants according to
1249 : their field (integer, floating point, or invalid), radix (decimal,
1250 : octal, hexadecimal), and type suffixes. */
1251 :
1252 : #define CPP_N_CATEGORY 0x000F
1253 : #define CPP_N_INVALID 0x0000
1254 : #define CPP_N_INTEGER 0x0001
1255 : #define CPP_N_FLOATING 0x0002
1256 :
1257 : #define CPP_N_WIDTH 0x00F0
1258 : #define CPP_N_SMALL 0x0010 /* int, float, short _Fract/Accum */
1259 : #define CPP_N_MEDIUM 0x0020 /* long, double, long _Fract/_Accum. */
1260 : #define CPP_N_LARGE 0x0040 /* long long, long double,
1261 : long long _Fract/Accum. */
1262 :
1263 : #define CPP_N_WIDTH_MD 0xF0000 /* machine defined. */
1264 : #define CPP_N_MD_W 0x10000
1265 : #define CPP_N_MD_Q 0x20000
1266 :
1267 : #define CPP_N_RADIX 0x0F00
1268 : #define CPP_N_DECIMAL 0x0100
1269 : #define CPP_N_HEX 0x0200
1270 : #define CPP_N_OCTAL 0x0400
1271 : #define CPP_N_BINARY 0x0800
1272 :
1273 : #define CPP_N_UNSIGNED 0x1000 /* Properties. */
1274 : #define CPP_N_IMAGINARY 0x2000
1275 : #define CPP_N_DFLOAT 0x4000
1276 : #define CPP_N_DEFAULT 0x8000
1277 :
1278 : #define CPP_N_FRACT 0x100000 /* Fract types. */
1279 : #define CPP_N_ACCUM 0x200000 /* Accum types. */
1280 : #define CPP_N_FLOATN 0x400000 /* _FloatN types. */
1281 : #define CPP_N_FLOATNX 0x800000 /* _FloatNx types. */
1282 :
1283 : #define CPP_N_USERDEF 0x1000000 /* C++11 user-defined literal. */
1284 :
1285 : #define CPP_N_SIZE_T 0x2000000 /* C++23 size_t literal. */
1286 : #define CPP_N_BFLOAT16 0x4000000 /* std::bfloat16_t type. */
1287 :
1288 : #define CPP_N_WIDTH_FLOATN_NX 0xF0000000 /* _FloatN / _FloatNx value
1289 : of N, divided by 16. */
1290 : #define CPP_FLOATN_SHIFT 24
1291 : #define CPP_FLOATN_MAX 0xF0
1292 :
1293 : /* Classify a CPP_NUMBER token. The return value is a combination of
1294 : the flags from the above sets. */
1295 : extern unsigned cpp_classify_number (cpp_reader *, const cpp_token *,
1296 : const char **, location_t);
1297 :
1298 : /* Return the classification flags for a float suffix. */
1299 : extern unsigned int cpp_interpret_float_suffix (cpp_reader *, const char *,
1300 : size_t);
1301 :
1302 : /* Return the classification flags for an int suffix. */
1303 : extern unsigned int cpp_interpret_int_suffix (cpp_reader *, const char *,
1304 : size_t);
1305 :
1306 : /* Evaluate a token classified as category CPP_N_INTEGER. */
1307 : extern cpp_num cpp_interpret_integer (cpp_reader *, const cpp_token *,
1308 : unsigned int);
1309 :
1310 : /* Sign extend a number, with PRECISION significant bits and all
1311 : others assumed clear, to fill out a cpp_num structure. */
1312 : cpp_num cpp_num_sign_extend (cpp_num, size_t);
1313 :
1314 : /* Output a diagnostic of some kind. */
1315 : extern bool cpp_error (cpp_reader *, enum cpp_diagnostic_level,
1316 : const char *msgid, ...)
1317 : ATTRIBUTE_PRINTF_3;
1318 : extern bool cpp_warning (cpp_reader *, enum cpp_warning_reason,
1319 : const char *msgid, ...)
1320 : ATTRIBUTE_PRINTF_3;
1321 : extern bool cpp_pedwarning (cpp_reader *, enum cpp_warning_reason,
1322 : const char *msgid, ...)
1323 : ATTRIBUTE_PRINTF_3;
1324 : extern bool cpp_warning_syshdr (cpp_reader *, enum cpp_warning_reason reason,
1325 : const char *msgid, ...)
1326 : ATTRIBUTE_PRINTF_3;
1327 :
1328 : /* As their counterparts above, but use RICHLOC. */
1329 : extern bool cpp_warning_at (cpp_reader *, enum cpp_warning_reason,
1330 : rich_location *richloc, const char *msgid, ...)
1331 : ATTRIBUTE_PRINTF_4;
1332 : extern bool cpp_pedwarning_at (cpp_reader *, enum cpp_warning_reason,
1333 : rich_location *richloc, const char *msgid, ...)
1334 : ATTRIBUTE_PRINTF_4;
1335 :
1336 : /* Output a diagnostic with "MSGID: " preceding the
1337 : error string of errno. No location is printed. */
1338 : extern bool cpp_errno (cpp_reader *, enum cpp_diagnostic_level,
1339 : const char *msgid);
1340 : /* Similarly, but with "FILENAME: " instead of "MSGID: ", where
1341 : the filename is not localized. */
1342 : extern bool cpp_errno_filename (cpp_reader *, enum cpp_diagnostic_level,
1343 : const char *filename, location_t loc);
1344 :
1345 : /* Same as cpp_error, except additionally specifies a position as a
1346 : (translation unit) physical line and physical column. If the line is
1347 : zero, then no location is printed. */
1348 : extern bool cpp_error_with_line (cpp_reader *, enum cpp_diagnostic_level,
1349 : location_t, unsigned,
1350 : const char *msgid, ...)
1351 : ATTRIBUTE_PRINTF_5;
1352 : extern bool cpp_warning_with_line (cpp_reader *, enum cpp_warning_reason,
1353 : location_t, unsigned,
1354 : const char *msgid, ...)
1355 : ATTRIBUTE_PRINTF_5;
1356 : extern bool cpp_pedwarning_with_line (cpp_reader *, enum cpp_warning_reason,
1357 : location_t, unsigned,
1358 : const char *msgid, ...)
1359 : ATTRIBUTE_PRINTF_5;
1360 : extern bool cpp_warning_with_line_syshdr (cpp_reader *, enum cpp_warning_reason,
1361 : location_t, unsigned,
1362 : const char *msgid, ...)
1363 : ATTRIBUTE_PRINTF_5;
1364 :
1365 : extern bool cpp_error_at (cpp_reader * pfile, enum cpp_diagnostic_level,
1366 : location_t src_loc, const char *msgid, ...)
1367 : ATTRIBUTE_PRINTF_4;
1368 :
1369 : extern bool cpp_error_at (cpp_reader * pfile, enum cpp_diagnostic_level,
1370 : rich_location *richloc, const char *msgid, ...)
1371 : ATTRIBUTE_PRINTF_4;
1372 :
1373 : /* In lex.cc */
1374 : extern int cpp_ideq (const cpp_token *, const char *);
1375 : extern void cpp_output_line (cpp_reader *, FILE *);
1376 : extern unsigned char *cpp_output_line_to_string (cpp_reader *,
1377 : const unsigned char *);
1378 : extern const unsigned char *cpp_alloc_token_string
1379 : (cpp_reader *, const unsigned char *, unsigned);
1380 : extern void cpp_output_token (const cpp_token *, FILE *);
1381 : extern const char *cpp_type2name (enum cpp_ttype, unsigned char flags);
1382 : /* Returns the value of an escape sequence, truncated to the correct
1383 : target precision. PSTR points to the input pointer, which is just
1384 : after the backslash. LIMIT is how much text we have. WIDE is true
1385 : if the escape sequence is part of a wide character constant or
1386 : string literal. Handles all relevant diagnostics. */
1387 : extern cppchar_t cpp_parse_escape (cpp_reader *, const unsigned char ** pstr,
1388 : const unsigned char *limit, int wide);
1389 :
1390 : /* Structure used to hold a comment block at a given location in the
1391 : source code. */
1392 :
1393 : typedef struct
1394 : {
1395 : /* Text of the comment including the terminators. */
1396 : char *comment;
1397 :
1398 : /* source location for the given comment. */
1399 : location_t sloc;
1400 : } cpp_comment;
1401 :
1402 : /* Structure holding all comments for a given cpp_reader. */
1403 :
1404 : typedef struct
1405 : {
1406 : /* table of comment entries. */
1407 : cpp_comment *entries;
1408 :
1409 : /* number of actual entries entered in the table. */
1410 : int count;
1411 :
1412 : /* number of entries allocated currently. */
1413 : int allocated;
1414 : } cpp_comment_table;
1415 :
1416 : /* Returns the table of comments encountered by the preprocessor. This
1417 : table is only populated when pfile->state.save_comments is true. */
1418 : extern cpp_comment_table *cpp_get_comments (cpp_reader *);
1419 :
1420 : /* In hash.c */
1421 :
1422 : /* Lookup an identifier in the hashtable. Puts the identifier in the
1423 : table if it is not already there. */
1424 : extern cpp_hashnode *cpp_lookup (cpp_reader *, const unsigned char *,
1425 : unsigned int);
1426 :
1427 : typedef int (*cpp_cb) (cpp_reader *, cpp_hashnode *, void *);
1428 : extern void cpp_forall_identifiers (cpp_reader *, cpp_cb, void *);
1429 :
1430 : /* In macro.cc */
1431 : extern void cpp_scan_nooutput (cpp_reader *);
1432 : extern int cpp_sys_macro_p (cpp_reader *);
1433 : extern unsigned char *cpp_quote_string (unsigned char *, const unsigned char *,
1434 : unsigned int);
1435 : extern bool cpp_compare_macros (const cpp_macro *macro1,
1436 : const cpp_macro *macro2);
1437 :
1438 : /* In files.cc */
1439 : extern bool cpp_included (cpp_reader *, const char *);
1440 : extern bool cpp_included_before (cpp_reader *, const char *, location_t);
1441 : extern void cpp_make_system_header (cpp_reader *, int, int);
1442 : extern bool cpp_push_include (cpp_reader *, const char *);
1443 : extern bool cpp_push_default_include (cpp_reader *, const char *);
1444 : extern void cpp_change_file (cpp_reader *, enum lc_reason, const char *);
1445 : extern const char *cpp_get_path (struct _cpp_file *);
1446 : extern cpp_dir *cpp_get_dir (struct _cpp_file *);
1447 : extern cpp_buffer *cpp_get_buffer (cpp_reader *);
1448 : extern struct _cpp_file *cpp_get_file (cpp_buffer *);
1449 : extern cpp_buffer *cpp_get_prev (cpp_buffer *);
1450 : extern void cpp_clear_file_cache (cpp_reader *);
1451 :
1452 : /* cpp_get_converted_source returns the contents of the given file, as it exists
1453 : after cpplib has read it and converted it from the input charset to the
1454 : source charset. Return struct will be zero-filled if the data could not be
1455 : read for any reason. The data starts at the DATA pointer, but the TO_FREE
1456 : pointer is what should be passed to free(), as there may be an offset. */
1457 : struct cpp_converted_source
1458 : {
1459 : char *to_free;
1460 : char *data;
1461 : size_t len;
1462 : };
1463 : cpp_converted_source cpp_get_converted_source (const char *fname,
1464 : const char *input_charset);
1465 :
1466 : /* In pch.cc */
1467 : struct save_macro_data;
1468 : extern int cpp_save_state (cpp_reader *, FILE *);
1469 : extern int cpp_write_pch_deps (cpp_reader *, FILE *);
1470 : extern int cpp_write_pch_state (cpp_reader *, FILE *);
1471 : extern int cpp_valid_state (cpp_reader *, const char *, int);
1472 : extern void cpp_prepare_state (cpp_reader *, struct save_macro_data **);
1473 : extern int cpp_read_state (cpp_reader *, const char *, FILE *,
1474 : struct save_macro_data *);
1475 :
1476 : /* In lex.cc */
1477 : extern void cpp_force_token_locations (cpp_reader *, location_t);
1478 : extern void cpp_stop_forcing_token_locations (cpp_reader *);
1479 : enum CPP_DO_task
1480 : {
1481 : CPP_DO_print,
1482 : CPP_DO_location,
1483 : CPP_DO_token
1484 : };
1485 :
1486 : extern void cpp_directive_only_process (cpp_reader *pfile,
1487 : void *data,
1488 : void (*cb) (cpp_reader *,
1489 : CPP_DO_task,
1490 : void *data, ...));
1491 :
1492 : /* In expr.cc */
1493 : extern enum cpp_ttype cpp_userdef_string_remove_type
1494 : (enum cpp_ttype type);
1495 : extern enum cpp_ttype cpp_userdef_string_add_type
1496 : (enum cpp_ttype type);
1497 : extern enum cpp_ttype cpp_userdef_char_remove_type
1498 : (enum cpp_ttype type);
1499 : extern enum cpp_ttype cpp_userdef_char_add_type
1500 : (enum cpp_ttype type);
1501 : extern bool cpp_userdef_string_p
1502 : (enum cpp_ttype type);
1503 : extern bool cpp_userdef_char_p
1504 : (enum cpp_ttype type);
1505 : extern const char * cpp_get_userdef_suffix
1506 : (const cpp_token *);
1507 :
1508 : /* In charset.cc */
1509 :
1510 : /* The result of attempting to decode a run of UTF-8 bytes. */
1511 :
1512 : struct cpp_decoded_char
1513 : {
1514 : const char *m_start_byte;
1515 : const char *m_next_byte;
1516 :
1517 : bool m_valid_ch;
1518 : cppchar_t m_ch;
1519 : };
1520 :
1521 : /* Information for mapping between code points and display columns.
1522 :
1523 : This is a tabstop value, along with a callback for getting the
1524 : widths of characters. Normally this callback is cpp_wcwidth, but we
1525 : support other schemes for escaping non-ASCII unicode as a series of
1526 : ASCII chars when printing the user's source code in diagnostic-show-locus.cc
1527 :
1528 : For example, consider:
1529 : - the Unicode character U+03C0 "GREEK SMALL LETTER PI" (UTF-8: 0xCF 0x80)
1530 : - the Unicode character U+1F642 "SLIGHTLY SMILING FACE"
1531 : (UTF-8: 0xF0 0x9F 0x99 0x82)
1532 : - the byte 0xBF (a stray trailing byte of a UTF-8 character)
1533 : Normally U+03C0 would occupy one display column, U+1F642
1534 : would occupy two display columns, and the stray byte would be
1535 : printed verbatim as one display column.
1536 :
1537 : However when escaping them as unicode code points as "<U+03C0>"
1538 : and "<U+1F642>" they occupy 8 and 9 display columns respectively,
1539 : and when escaping them as bytes as "<CF><80>" and "<F0><9F><99><82>"
1540 : they occupy 8 and 16 display columns respectively. In both cases
1541 : the stray byte is escaped to <BF> as 4 display columns. */
1542 :
1543 : struct cpp_char_column_policy
1544 : {
1545 : cpp_char_column_policy (int tabstop,
1546 : int (*width_cb) (cppchar_t c))
1547 : : m_tabstop (tabstop),
1548 : m_undecoded_byte_width (1),
1549 : m_width_cb (width_cb)
1550 : {}
1551 :
1552 : int m_tabstop;
1553 : /* Width in display columns of a stray byte that isn't decodable
1554 : as UTF-8. */
1555 : int m_undecoded_byte_width;
1556 : int (*m_width_cb) (cppchar_t c);
1557 : };
1558 :
1559 : /* A class to manage the state while converting a UTF-8 sequence to cppchar_t
1560 : and computing the display width one character at a time. */
1561 : class cpp_display_width_computation {
1562 : public:
1563 : cpp_display_width_computation (const char *data, int data_length,
1564 : const cpp_char_column_policy &policy);
1565 : const char *next_byte () const { return m_next; }
1566 : int bytes_processed () const { return m_next - m_begin; }
1567 : int bytes_left () const { return m_bytes_left; }
1568 : bool done () const { return !bytes_left (); }
1569 : int display_cols_processed () const { return m_display_cols; }
1570 :
1571 : int process_next_codepoint (cpp_decoded_char *out);
1572 : int advance_display_cols (int n);
1573 :
1574 : private:
1575 : const char *const m_begin;
1576 : const char *m_next;
1577 : size_t m_bytes_left;
1578 : const cpp_char_column_policy &m_policy;
1579 : int m_display_cols;
1580 : };
1581 :
1582 : /* Convenience functions that are simple use cases for class
1583 : cpp_display_width_computation. Tab characters will be expanded to spaces
1584 : as determined by POLICY.m_tabstop, and non-printable-ASCII characters
1585 : will be escaped as per POLICY. */
1586 :
1587 : int cpp_byte_column_to_display_column (const char *data, int data_length,
1588 : int column,
1589 : const cpp_char_column_policy &policy);
1590 : inline int cpp_display_width (const char *data, int data_length,
1591 : const cpp_char_column_policy &policy)
1592 : {
1593 : return cpp_byte_column_to_display_column (data, data_length, data_length,
1594 : policy);
1595 : }
1596 : int cpp_display_column_to_byte_column (const char *data, int data_length,
1597 : int display_col,
1598 : const cpp_char_column_policy &policy);
1599 : int cpp_wcwidth (cppchar_t c);
1600 :
1601 : bool cpp_input_conversion_is_trivial (const char *input_charset);
1602 : int cpp_check_utf8_bom (const char *data, size_t data_length);
1603 : bool cpp_valid_utf8_p (const char *data, size_t num_bytes);
1604 :
1605 : bool cpp_is_combining_char (cppchar_t c);
1606 : bool cpp_is_printable_char (cppchar_t c);
1607 :
1608 : #endif /* ! LIBCPP_CPPLIB_H */
|
