forked from gcc-mirror/gcc
-
Notifications
You must be signed in to change notification settings - Fork 16
/
Copy pathcpplib.h
1713 lines (1411 loc) · 59.7 KB
/
cpplib.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* Definitions for CPP library.
Copyright (C) 1995-2025 Free Software Foundation, Inc.
Written by Per Bothner, 1994-95.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 3, or (at your option) any
later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>.
In other words, you are welcome to use, share and improve this program.
You are forbidden to forbid anyone else to use, share and improve
what you give them. Help stamp out software-hoarding! */
#ifndef LIBCPP_CPPLIB_H
#define LIBCPP_CPPLIB_H
#include <sys/types.h>
#include "symtab.h"
#include "line-map.h"
typedef struct cpp_reader cpp_reader;
typedef struct cpp_buffer cpp_buffer;
typedef struct cpp_options cpp_options;
typedef struct cpp_token cpp_token;
typedef struct cpp_string cpp_string;
typedef struct cpp_hashnode cpp_hashnode;
typedef struct cpp_macro cpp_macro;
typedef struct cpp_callbacks cpp_callbacks;
typedef struct cpp_dir cpp_dir;
struct _cpp_file;
class rich_location;
/* The first three groups, apart from '=', can appear in preprocessor
expressions (+= and -= are used to indicate unary + and - resp.).
This allows a lookup table to be implemented in _cpp_parse_expr.
The first group, to CPP_LAST_EQ, can be immediately followed by an
'='. The lexer needs operators ending in '=', like ">>=", to be in
the same order as their counterparts without the '=', like ">>".
See the cpp_operator table optab in expr.cc if you change the order or
add or remove anything in the first group. */
#define TTYPE_TABLE \
OP(EQ, "=") \
OP(NOT, "!") \
OP(GREATER, ">") /* compare */ \
OP(LESS, "<") \
OP(PLUS, "+") /* math */ \
OP(MINUS, "-") \
OP(MULT, "*") \
OP(DIV, "/") \
OP(MOD, "%") \
OP(AND, "&") /* bit ops */ \
OP(OR, "|") \
OP(XOR, "^") \
OP(RSHIFT, ">>") \
OP(LSHIFT, "<<") \
\
OP(COMPL, "~") \
OP(AND_AND, "&&") /* logical */ \
OP(OR_OR, "||") \
OP(QUERY, "?") \
OP(COLON, ":") \
OP(COMMA, ",") /* grouping */ \
OP(OPEN_PAREN, "(") \
OP(CLOSE_PAREN, ")") \
TK(EOF, NONE) \
OP(EQ_EQ, "==") /* compare */ \
OP(NOT_EQ, "!=") \
OP(GREATER_EQ, ">=") \
OP(LESS_EQ, "<=") \
OP(SPACESHIP, "<=>") \
\
/* These two are unary + / - in preprocessor expressions. */ \
OP(PLUS_EQ, "+=") /* math */ \
OP(MINUS_EQ, "-=") \
\
OP(MULT_EQ, "*=") \
OP(DIV_EQ, "/=") \
OP(MOD_EQ, "%=") \
OP(AND_EQ, "&=") /* bit ops */ \
OP(OR_EQ, "|=") \
OP(XOR_EQ, "^=") \
OP(RSHIFT_EQ, ">>=") \
OP(LSHIFT_EQ, "<<=") \
/* Digraphs together, beginning with CPP_FIRST_DIGRAPH. */ \
OP(HASH, "#") /* digraphs */ \
OP(PASTE, "##") \
OP(OPEN_SQUARE, "[") \
OP(CLOSE_SQUARE, "]") \
OP(OPEN_BRACE, "{") \
OP(CLOSE_BRACE, "}") \
/* The remainder of the punctuation. Order is not significant. */ \
OP(SEMICOLON, ";") /* structure */ \
OP(ELLIPSIS, "...") \
OP(PLUS_PLUS, "++") /* increment */ \
OP(MINUS_MINUS, "--") \
OP(DEREF, "->") /* accessors */ \
OP(DOT, ".") \
OP(SCOPE, "::") \
OP(DEREF_STAR, "->*") \
OP(DOT_STAR, ".*") \
OP(ATSIGN, "@") /* used in Objective-C */ \
\
TK(NAME, IDENT) /* word */ \
TK(AT_NAME, IDENT) /* @word - Objective-C */ \
TK(NUMBER, LITERAL) /* 34_be+ta */ \
\
TK(CHAR, LITERAL) /* 'char' */ \
TK(WCHAR, LITERAL) /* L'char' */ \
TK(CHAR16, LITERAL) /* u'char' */ \
TK(CHAR32, LITERAL) /* U'char' */ \
TK(UTF8CHAR, LITERAL) /* u8'char' */ \
TK(OTHER, LITERAL) /* stray punctuation */ \
\
TK(STRING, LITERAL) /* "string" */ \
TK(WSTRING, LITERAL) /* L"string" */ \
TK(STRING16, LITERAL) /* u"string" */ \
TK(STRING32, LITERAL) /* U"string" */ \
TK(UTF8STRING, LITERAL) /* u8"string" */ \
TK(OBJC_STRING, LITERAL) /* @"string" - Objective-C */ \
TK(HEADER_NAME, LITERAL) /* <stdio.h> in #include */ \
TK(UNEVAL_STRING, LITERAL) /* unevaluated "string" - C++26 */ \
\
TK(CHAR_USERDEF, LITERAL) /* 'char'_suffix - C++11 */ \
TK(WCHAR_USERDEF, LITERAL) /* L'char'_suffix - C++11 */ \
TK(CHAR16_USERDEF, LITERAL) /* u'char'_suffix - C++11 */ \
TK(CHAR32_USERDEF, LITERAL) /* U'char'_suffix - C++11 */ \
TK(UTF8CHAR_USERDEF, LITERAL) /* u8'char'_suffix - C++11 */ \
TK(STRING_USERDEF, LITERAL) /* "string"_suffix - C++11 */ \
TK(WSTRING_USERDEF, LITERAL) /* L"string"_suffix - C++11 */ \
TK(STRING16_USERDEF, LITERAL) /* u"string"_suffix - C++11 */ \
TK(STRING32_USERDEF, LITERAL) /* U"string"_suffix - C++11 */ \
TK(UTF8STRING_USERDEF,LITERAL) /* u8"string"_suffix - C++11 */ \
\
TK(EMBED, LITERAL) /* #embed - C23 */ \
\
TK(COMMENT, LITERAL) /* Only if output comments. */ \
/* SPELL_LITERAL happens to DTRT. */ \
TK(MACRO_ARG, NONE) /* Macro argument. */ \
TK(PRAGMA, NONE) /* Only for deferred pragmas. */ \
TK(PRAGMA_EOL, NONE) /* End-of-line for deferred pragmas. */ \
TK(PADDING, NONE) /* Whitespace for -E. */
#define OP(e, s) CPP_ ## e,
#define TK(e, s) CPP_ ## e,
enum cpp_ttype
{
TTYPE_TABLE
N_TTYPES,
/* A token type for keywords, as opposed to ordinary identifiers. */
CPP_KEYWORD,
/* Positions in the table. */
CPP_LAST_EQ = CPP_LSHIFT,
CPP_FIRST_DIGRAPH = CPP_HASH,
CPP_LAST_PUNCTUATOR= CPP_ATSIGN,
CPP_LAST_CPP_OP = CPP_LESS_EQ
};
#undef OP
#undef TK
/* C language kind, used when calling cpp_create_reader. */
enum c_lang {CLK_GNUC89 = 0, CLK_GNUC99, CLK_GNUC11, CLK_GNUC17, CLK_GNUC23,
CLK_GNUC2Y,
CLK_STDC89, CLK_STDC94, CLK_STDC99, CLK_STDC11, CLK_STDC17,
CLK_STDC23, CLK_STDC2Y,
CLK_GNUCXX, CLK_CXX98, CLK_GNUCXX11, CLK_CXX11,
CLK_GNUCXX14, CLK_CXX14, CLK_GNUCXX17, CLK_CXX17,
CLK_GNUCXX20, CLK_CXX20, CLK_GNUCXX23, CLK_CXX23,
CLK_GNUCXX26, CLK_CXX26, CLK_ASM};
/* Payload of a NUMBER, STRING, CHAR or COMMENT token. */
struct GTY(()) cpp_string {
unsigned int len;
/* TEXT is always null terminated (terminator not included in len); but this
GTY markup arranges that PCH streaming works properly even if there is a
null byte in the middle of the string. */
const unsigned char * GTY((string_length ("1 + %h.len"))) text;
};
/* Flags for the cpp_token structure. */
#define PREV_WHITE (1 << 0) /* If whitespace before this token. */
#define DIGRAPH (1 << 1) /* If it was a digraph. */
#define STRINGIFY_ARG (1 << 2) /* If macro argument to be stringified. */
#define PASTE_LEFT (1 << 3) /* If on LHS of a ## operator. */
#define NAMED_OP (1 << 4) /* C++ named operators. */
#define PREV_FALLTHROUGH (1 << 5) /* On a token preceeded by FALLTHROUGH
comment. */
#define DECIMAL_INT (1 << 6) /* Decimal integer, set in c-lex.cc. */
#define PURE_ZERO (1 << 7) /* Single 0 digit, used by the C++ frontend,
set in c-lex.cc. */
#define COLON_SCOPE PURE_ZERO /* Adjacent colons in C < 23. */
#define NO_DOT_COLON PURE_ZERO /* Set on CPP_NAME tokens whose expansion
shouldn't start with CPP_DOT or CPP_COLON
after optional CPP_PADDING. */
#define SP_DIGRAPH (1 << 8) /* # or ## token was a digraph. */
#define SP_PREV_WHITE (1 << 9) /* If whitespace before a ##
operator, or before this token
after a # operator. */
#define NO_EXPAND (1 << 10) /* Do not macro-expand this token. */
#define PRAGMA_OP (1 << 11) /* _Pragma token. */
#define BOL (1 << 12) /* Token at beginning of line. */
/* Specify which field, if any, of the cpp_token union is used. */
enum cpp_token_fld_kind {
CPP_TOKEN_FLD_NODE,
CPP_TOKEN_FLD_SOURCE,
CPP_TOKEN_FLD_STR,
CPP_TOKEN_FLD_ARG_NO,
CPP_TOKEN_FLD_TOKEN_NO,
CPP_TOKEN_FLD_PRAGMA,
CPP_TOKEN_FLD_NONE
};
/* A macro argument in the cpp_token union. */
struct GTY(()) cpp_macro_arg {
/* Argument number. */
unsigned int arg_no;
/* The original spelling of the macro argument token. */
cpp_hashnode *
GTY ((nested_ptr (union tree_node,
"%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
"%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
spelling;
};
/* An identifier in the cpp_token union. */
struct GTY(()) cpp_identifier {
/* The canonical (UTF-8) spelling of the identifier. */
cpp_hashnode *
GTY ((nested_ptr (union tree_node,
"%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
"%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
node;
/* The original spelling of the identifier. */
cpp_hashnode *
GTY ((nested_ptr (union tree_node,
"%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
"%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
spelling;
};
/* A preprocessing token. This occupies 32 bytes on a 64-bit host. On a
32-bit host it occupies 20 or 24 bytes, depending whether a uint64_t
requires 4- or 8-byte alignment. */
struct GTY(()) cpp_token {
/* Location of first char of token, together with range of full token. */
location_t src_loc;
ENUM_BITFIELD(cpp_ttype) type : CHAR_BIT; /* token type */
unsigned short flags; /* flags - see above */
union cpp_token_u
{
/* An identifier. */
struct cpp_identifier GTY ((tag ("CPP_TOKEN_FLD_NODE"))) node;
/* Inherit padding from this token. */
cpp_token * GTY ((tag ("CPP_TOKEN_FLD_SOURCE"))) source;
/* A string, or number. */
struct cpp_string GTY ((tag ("CPP_TOKEN_FLD_STR"))) str;
/* Argument no. (and original spelling) for a CPP_MACRO_ARG. */
struct cpp_macro_arg GTY ((tag ("CPP_TOKEN_FLD_ARG_NO"))) macro_arg;
/* Original token no. for a CPP_PASTE (from a sequence of
consecutive paste tokens in a macro expansion). */
unsigned int GTY ((tag ("CPP_TOKEN_FLD_TOKEN_NO"))) token_no;
/* Caller-supplied identifier for a CPP_PRAGMA. */
unsigned int GTY ((tag ("CPP_TOKEN_FLD_PRAGMA"))) pragma;
} GTY ((desc ("cpp_token_val_index (&%1)"))) val;
};
/* Say which field is in use. */
extern enum cpp_token_fld_kind cpp_token_val_index (const cpp_token *tok);
/* A type wide enough to hold any multibyte source character.
cpplib's character constant interpreter requires an unsigned type.
Also, a typedef for the signed equivalent.
The width of this type is capped at 32 bits; there do exist targets
where wchar_t is 64 bits, but only in a non-default mode, and there
would be no meaningful interpretation for a wchar_t value greater
than 2^32 anyway -- the widest wide-character encoding around is
ISO 10646, which stops at 2^31. */
#if CHAR_BIT * SIZEOF_INT >= 32
# define CPPCHAR_SIGNED_T int
#elif CHAR_BIT * SIZEOF_LONG >= 32
# define CPPCHAR_SIGNED_T long
#else
# error "Cannot find a least-32-bit signed integer type"
#endif
typedef unsigned CPPCHAR_SIGNED_T cppchar_t;
typedef CPPCHAR_SIGNED_T cppchar_signed_t;
/* Style of header dependencies to generate. */
enum cpp_deps_style { DEPS_NONE = 0, DEPS_USER, DEPS_SYSTEM };
/* Structured format of module dependencies to generate. */
enum cpp_fdeps_format { FDEPS_FMT_NONE = 0, FDEPS_FMT_P1689R5 };
/* The possible normalization levels, from most restrictive to least. */
enum cpp_normalize_level {
/* In NFKC. */
normalized_KC = 0,
/* In NFC. */
normalized_C,
/* In NFC, except for subsequences where being in NFC would make
the identifier invalid. */
normalized_identifier_C,
/* Not normalized at all. */
normalized_none
};
enum cpp_main_search
{
CMS_none, /* A regular source file. */
CMS_header, /* Is a directly-specified header file (eg PCH or
header-unit). */
CMS_user, /* Search the user INCLUDE path. */
CMS_system, /* Search the system INCLUDE path. */
};
/* The possible bidirectional control characters checking levels. */
enum cpp_bidirectional_level {
/* No checking. */
bidirectional_none = 0,
/* Only detect unpaired uses of bidirectional control characters. */
bidirectional_unpaired = 1,
/* Detect any use of bidirectional control characters. */
bidirectional_any = 2,
/* Also warn about UCNs. */
bidirectional_ucn = 4
};
/* This structure is nested inside struct cpp_reader, and
carries all the options visible to the command line. */
struct cpp_options
{
/* The language we're preprocessing. */
enum c_lang lang;
/* Nonzero means use extra default include directories for C++. */
unsigned char cplusplus;
/* Nonzero means handle cplusplus style comments. */
unsigned char cplusplus_comments;
/* Nonzero means define __OBJC__, treat @ as a special token, use
the OBJC[PLUS]_INCLUDE_PATH environment variable, and allow
"#import". */
unsigned char objc;
/* Nonzero means don't copy comments into the output file. */
unsigned char discard_comments;
/* Nonzero means don't copy comments into the output file during
macro expansion. */
unsigned char discard_comments_in_macro_exp;
/* Nonzero means process the ISO trigraph sequences. */
unsigned char trigraphs;
/* Nonzero means process the ISO digraph sequences. */
unsigned char digraphs;
/* Nonzero means to allow hexadecimal floats and LL suffixes. */
unsigned char extended_numbers;
/* Nonzero means process u/U prefix literals (UTF-16/32). */
unsigned char uliterals;
/* Nonzero means process u8 prefixed character literals (UTF-8). */
unsigned char utf8_char_literals;
/* Nonzero means process r/R raw strings. If this is set, uliterals
must be set as well. */
unsigned char rliterals;
/* Nonzero means print names of header files (-H). */
unsigned char print_include_names;
/* Nonzero means complain about deprecated features. */
unsigned char cpp_warn_deprecated;
/* Nonzero means warn if slash-star appears in a comment. */
unsigned char warn_comments;
/* Nonzero means to warn about __DATA__, __TIME__ and __TIMESTAMP__ usage. */
unsigned char warn_date_time;
/* Nonzero means warn if a user-supplied include directory does not
exist. */
unsigned char warn_missing_include_dirs;
/* Nonzero means warn if there are any trigraphs. */
unsigned char warn_trigraphs;
/* Nonzero means warn about multicharacter charconsts. */
unsigned char warn_multichar;
/* Nonzero means warn about various incompatibilities with
traditional C. */
unsigned char cpp_warn_traditional;
/* Nonzero means warn about long long numeric constants. */
unsigned char cpp_warn_long_long;
/* Nonzero means warn about text after an #endif (or #else). */
unsigned char warn_endif_labels;
/* Nonzero means warn about implicit sign changes owing to integer
promotions. */
unsigned char warn_num_sign_change;
/* Zero means don't warn about __VA_ARGS__ usage in c89 pedantic mode.
Presumably the usage is protected by the appropriate #ifdef. */
unsigned char warn_variadic_macros;
/* Nonzero means warn about builtin macros that are redefined or
explicitly undefined. */
unsigned char warn_builtin_macro_redefined;
/* Different -Wimplicit-fallthrough= levels. */
unsigned char cpp_warn_implicit_fallthrough;
/* Nonzero means warn about a define of a different macro right after
#ifndef/#if !defined header guard directive. */
unsigned char warn_header_guard;
/* Nonzero means we should look for header.gcc files that remap file
names. */
unsigned char remap;
/* Zero means dollar signs are punctuation. */
unsigned char dollars_in_ident;
/* Nonzero means UCNs are accepted in identifiers. */
unsigned char extended_identifiers;
/* True if we should warn about dollars in identifiers or numbers
for this translation unit. */
unsigned char warn_dollars;
/* Nonzero means warn if undefined identifiers are evaluated in an #if. */
unsigned char warn_undef;
/* Nonzero means warn if "defined" is encountered in a place other than
an #if. */
unsigned char warn_expansion_to_defined;
/* Nonzero means warn of unused macros from the main file. */
unsigned char warn_unused_macros;
/* Nonzero for the 1999 C Standard, including corrigenda and amendments. */
unsigned char c99;
/* Nonzero if we are conforming to a specific C or C++ standard. */
unsigned char std;
/* Nonzero means give all the error messages the ANSI standard requires. */
unsigned char cpp_pedantic;
/* Nonzero means we're looking at already preprocessed code, so don't
bother trying to do macro expansion and whatnot. */
unsigned char preprocessed;
/* Nonzero means we are going to emit debugging logs during
preprocessing. */
unsigned char debug;
/* Nonzero means we are tracking locations of tokens involved in
macro expansion. 1 Means we track the location in degraded mode
where we do not track locations of tokens resulting from the
expansion of arguments of function-like macro. 2 Means we do
track all macro expansions. This last option is the one that
consumes the highest amount of memory. */
unsigned char track_macro_expansion;
/* Nonzero means handle C++ alternate operator names. */
unsigned char operator_names;
/* Nonzero means warn about use of C++ alternate operator names. */
unsigned char warn_cxx_operator_names;
/* True for traditional preprocessing. */
unsigned char traditional;
/* Nonzero for C++ 2011 Standard user-defined literals. */
unsigned char user_literals;
/* Nonzero means warn when a string or character literal is followed by a
ud-suffix which does not beging with an underscore. */
unsigned char warn_literal_suffix;
/* Nonzero means interpret imaginary, fixed-point, or other gnu extension
literal number suffixes as user-defined literal number suffixes. */
unsigned char ext_numeric_literals;
/* Nonzero means extended identifiers allow the characters specified
in C11. */
unsigned char c11_identifiers;
/* Nonzero means extended identifiers allow the characters specified
by Unicode XID_Start and XID_Continue properties. */
unsigned char xid_identifiers;
/* Nonzero for C++ 2014 Standard binary constants. */
unsigned char binary_constants;
/* Nonzero for C2Y imaginary (floating) constants. */
unsigned char imaginary_constants;
/* Nonzero for C++ 2014 Standard digit separators. */
unsigned char digit_separators;
/* Nonzero for C23 decimal floating-point constants. */
unsigned char dfp_constants;
/* Nonzero for C++20 __VA_OPT__ feature. */
unsigned char va_opt;
/* Nonzero for the '::' token. */
unsigned char scope;
/* Nonzero for the '#elifdef' and '#elifndef' directives. */
unsigned char elifdef;
/* Nonzero for the '#warning' directive. */
unsigned char warning_directive;
/* Nonzero means tokenize C++20 module directives. */
unsigned char module_directives;
/* Nonzero for C++23 size_t literals. */
unsigned char size_t_literals;
/* Nonzero for C++23 delimited escape sequences. */
unsigned char delimited_escape_seqs;
/* Nonzero for C++23 named universal character escape sequences. */
unsigned char named_uc_escape_seqs;
/* Nonzero for C++ and C23 UCNs for characters below 0xa0. */
unsigned char low_ucns;
/* Nonzero for C2Y 0o prefixed octal integer constants. */
unsigned char octal_constants;
/* Nonzero for 'true' and 'false' in #if expressions. */
unsigned char true_false;
/* Nonzero for the '#embed' directive. */
unsigned char embed;
/* Holds the name of the target (execution) character set. */
const char *narrow_charset;
/* Holds the name of the target wide character set. */
const char *wide_charset;
/* Holds the name of the input character set. */
const char *input_charset;
/* The minimum permitted level of normalization before a warning
is generated. See enum cpp_normalize_level. */
int warn_normalize;
/* True to warn about precompiled header files we couldn't use. */
bool warn_invalid_pch;
/* True if dependencies should be restored from a precompiled header. */
bool restore_pch_deps;
/* True if warn about differences between C90 and C99. */
signed char cpp_warn_c90_c99_compat;
/* True if warn about differences between C11 and C23. */
signed char cpp_warn_c11_c23_compat;
/* True if warn about differences between C23 and C2Y. */
signed char cpp_warn_c23_c2y_compat;
/* True if warn about differences between C++98 and C++11. */
bool cpp_warn_cxx11_compat;
/* True if warn about differences between C++17 and C++20. */
bool cpp_warn_cxx20_compat;
/* Nonzero if bidirectional control characters checking is on. See enum
cpp_bidirectional_level. */
unsigned char cpp_warn_bidirectional;
/* True if libcpp should warn about invalid UTF-8 characters in comments.
2 if it should be a pedwarn. */
unsigned char cpp_warn_invalid_utf8;
/* True if libcpp should warn about invalid forms of delimited or named
escape sequences. */
bool cpp_warn_unicode;
/* True if -finput-charset= option has been used explicitly. */
bool cpp_input_charset_explicit;
/* -Wleading-whitespace= value. */
unsigned char cpp_warn_leading_whitespace;
/* -Wtrailing-whitespace= value. */
unsigned char cpp_warn_trailing_whitespace;
/* -ftabstop= value. */
unsigned int cpp_tabstop;
/* Dependency generation. */
struct
{
/* Style of header dependencies to generate. */
enum cpp_deps_style style;
/* Structured format of module dependencies to generate. */
enum cpp_fdeps_format fdeps_format;
/* Assume missing files are generated files. */
bool missing_files;
/* Generate phony targets for each dependency apart from the first
one. */
bool phony_targets;
/* Generate dependency info for modules. */
bool modules;
/* If true, no dependency is generated on the main file. */
bool ignore_main_file;
/* If true, intend to use the preprocessor output (e.g., for compilation)
in addition to the dependency info. */
bool need_preprocessor_output;
} deps;
/* Target-specific features set by the front end or client. */
/* Precision for target CPP arithmetic, target characters, target
ints and target wide characters, respectively. */
size_t precision, char_precision, int_precision, wchar_precision;
/* True means chars (wide chars, UTF-8 chars) are unsigned. */
bool unsigned_char, unsigned_wchar, unsigned_utf8char;
/* True if the most significant byte in a word has the lowest
address in memory. */
bool bytes_big_endian;
/* Nonzero means __STDC__ should have the value 0 in system headers. */
unsigned char stdc_0_in_system_headers;
/* True disables tokenization outside of preprocessing directives. */
bool directives_only;
/* True enables canonicalization of system header file paths. */
bool canonical_system_headers;
/* The maximum depth of the nested #include. */
unsigned int max_include_depth;
cpp_main_search main_search : 8;
};
#if GCC_VERSION >= 3005
#define ATTRIBUTE_CPP_PPDIAG(m, n) \
__attribute__ ((__format__ (__gcc_diag__, m , n))) ATTRIBUTE_NONNULL(m)
#else
#define ATTRIBUTE_CPP_PPDIAG(m, n) ATTRIBUTE_NONNULL(m)
#endif
/* Diagnostic levels. To get a diagnostic without associating a
position in the translation unit with it, use cpp_error_with_line
with a line number of zero. */
enum cpp_diagnostic_level {
/* Warning, an error with -Werror. */
CPP_DL_WARNING = 0,
/* Same as CPP_DL_WARNING, except it is not suppressed in system headers. */
CPP_DL_WARNING_SYSHDR,
/* Warning, an error with -pedantic-errors or -Werror. */
CPP_DL_PEDWARN,
/* An error. */
CPP_DL_ERROR,
/* An internal consistency check failed. Prints "internal error: ",
otherwise the same as CPP_DL_ERROR. */
CPP_DL_ICE,
/* An informative note following a warning. */
CPP_DL_NOTE,
/* A fatal error. */
CPP_DL_FATAL
};
/* Warning reason codes. Use a reason code of CPP_W_NONE for unclassified
warnings and diagnostics that are not warnings. */
enum cpp_warning_reason {
CPP_W_NONE = 0,
CPP_W_DEPRECATED,
CPP_W_COMMENTS,
CPP_W_MISSING_INCLUDE_DIRS,
CPP_W_TRIGRAPHS,
CPP_W_MULTICHAR,
CPP_W_TRADITIONAL,
CPP_W_LONG_LONG,
CPP_W_ENDIF_LABELS,
CPP_W_NUM_SIGN_CHANGE,
CPP_W_VARIADIC_MACROS,
CPP_W_BUILTIN_MACRO_REDEFINED,
CPP_W_DOLLARS,
CPP_W_UNDEF,
CPP_W_UNUSED_MACROS,
CPP_W_CXX_OPERATOR_NAMES,
CPP_W_NORMALIZE,
CPP_W_INVALID_PCH,
CPP_W_WARNING_DIRECTIVE,
CPP_W_LITERAL_SUFFIX,
CPP_W_SIZE_T_LITERALS,
CPP_W_DATE_TIME,
CPP_W_PEDANTIC,
CPP_W_C90_C99_COMPAT,
CPP_W_C11_C23_COMPAT,
CPP_W_C23_C2Y_COMPAT,
CPP_W_CXX11_COMPAT,
CPP_W_CXX20_COMPAT,
CPP_W_CXX14_EXTENSIONS,
CPP_W_CXX17_EXTENSIONS,
CPP_W_CXX20_EXTENSIONS,
CPP_W_CXX23_EXTENSIONS,
CPP_W_CXX26_EXTENSIONS,
CPP_W_EXPANSION_TO_DEFINED,
CPP_W_BIDIRECTIONAL,
CPP_W_INVALID_UTF8,
CPP_W_UNICODE,
CPP_W_HEADER_GUARD,
CPP_W_PRAGMA_ONCE_OUTSIDE_HEADER,
CPP_W_LEADING_WHITESPACE,
CPP_W_TRAILING_WHITESPACE
};
/* Callback for header lookup for HEADER, which is the name of a
source file. It is used as a method of last resort to find headers
that are not otherwise found during the normal include processing.
The return value is the malloced name of a header to try and open,
if any, or NULL otherwise. This callback is called only if the
header is otherwise unfound. */
typedef const char *(*missing_header_cb)(cpp_reader *, const char *header, cpp_dir **);
/* Call backs to cpplib client. */
struct cpp_callbacks
{
/* Called when a new line of preprocessed output is started. */
void (*line_change) (cpp_reader *, const cpp_token *, int);
/* Called when switching to/from a new file.
The line_map is for the new file. It is NULL if there is no new file.
(In C this happens when done with <built-in>+<command line> and also
when done with a main file.) This can be used for resource cleanup. */
void (*file_change) (cpp_reader *, const line_map_ordinary *);
void (*dir_change) (cpp_reader *, const char *);
void (*include) (cpp_reader *, location_t, const unsigned char *,
const char *, int, const cpp_token **);
void (*define) (cpp_reader *, location_t, cpp_hashnode *);
void (*undef) (cpp_reader *, location_t, cpp_hashnode *);
void (*ident) (cpp_reader *, location_t, const cpp_string *);
void (*def_pragma) (cpp_reader *, location_t);
int (*valid_pch) (cpp_reader *, const char *, int);
void (*read_pch) (cpp_reader *, const char *, int, const char *);
missing_header_cb missing_header;
/* Context-sensitive macro support. Returns macro (if any) that should
be expanded. */
cpp_hashnode * (*macro_to_expand) (cpp_reader *, const cpp_token *);
/* Called to emit a diagnostic. This callback receives the
translated message. */
bool (*diagnostic) (cpp_reader *,
enum cpp_diagnostic_level,
enum cpp_warning_reason,
rich_location *,
const char *, va_list *)
ATTRIBUTE_CPP_PPDIAG (5,0);
/* Callbacks for when a macro is expanded, or tested (whether
defined or not at the time) in #ifdef, #ifndef or "defined". */
void (*used_define) (cpp_reader *, location_t, cpp_hashnode *);
void (*used_undef) (cpp_reader *, location_t, cpp_hashnode *);
/* Called before #define and #undef or other macro definition
changes are processed. */
void (*before_define) (cpp_reader *);
/* Called whenever a macro is expanded or tested.
Second argument is the location of the start of the current expansion. */
void (*used) (cpp_reader *, location_t, cpp_hashnode *);
/* Callback to identify whether an attribute exists. */
int (*has_attribute) (cpp_reader *, bool);
/* Callback to determine whether a built-in function is recognized. */
int (*has_builtin) (cpp_reader *);
/* Callback to determine whether a feature is available. */
int (*has_feature) (cpp_reader *, bool);
/* Callback that can change a user lazy into normal macro. */
void (*user_lazy_macro) (cpp_reader *, cpp_macro *, unsigned);
/* Callback to handle deferred cpp_macros. */
cpp_macro *(*user_deferred_macro) (cpp_reader *, location_t, cpp_hashnode *);
/* Callback to parse SOURCE_DATE_EPOCH from environment. */
time_t (*get_source_date_epoch) (cpp_reader *);
/* Callback for providing suggestions for misspelled directives. */
const char *(*get_suggestion) (cpp_reader *, const char *, const char *const *);
/* Callback for when a comment is encountered, giving the location
of the opening slash, a pointer to the content (which is not
necessarily 0-terminated), and the length of the content.
The content contains the opening slash-star (or slash-slash),
and for C-style comments contains the closing star-slash. For
C++-style comments it does not include the terminating newline. */
void (*comment) (cpp_reader *, location_t, const unsigned char *,
size_t);
/* Callback for filename remapping in __FILE__ and __BASE_FILE__ macro
expansions. */
const char *(*remap_filename) (const char*);
/* Maybe translate a #include into something else. Return a
cpp_buffer containing the translation if translating. */
char *(*translate_include) (cpp_reader *, line_maps *, location_t,
const char *path);
};
#ifdef VMS
#define INO_T_CPP ino_t ino[3]
#elif defined (_AIX) && SIZEOF_INO_T == 4
#define INO_T_CPP ino64_t ino
#else
#define INO_T_CPP ino_t ino
#endif
#if defined (_AIX) && SIZEOF_DEV_T == 4
#define DEV_T_CPP dev64_t dev
#else
#define DEV_T_CPP dev_t dev
#endif
/* Chain of directories to look for include files in. */
struct cpp_dir
{
/* NULL-terminated singly-linked list. */
struct cpp_dir *next;
/* NAME of the directory, NUL-terminated. */
char *name;
unsigned int len;
/* One if a system header, two if a system header that has extern
"C" guards for C++. */
unsigned char sysp;
/* Is this a user-supplied directory? */
bool user_supplied_p;
/* The canonicalized NAME as determined by lrealpath. This field
is only used by hosts that lack reliable inode numbers. */
char *canonical_name;
/* Mapping of file names for this directory for MS-DOS and related
platforms. A NULL-terminated array of (from, to) pairs. */
const char **name_map;
/* Routine to construct pathname, given the search path name and the
HEADER we are trying to find, return a constructed pathname to
try and open. If this is NULL, the constructed pathname is as
constructed by append_file_to_dir. */
char *(*construct) (const char *header, cpp_dir *dir);
/* The C front end uses these to recognize duplicated
directories in the search path. */
INO_T_CPP;
DEV_T_CPP;
};
/* The kind of the cpp_macro. */
enum cpp_macro_kind {
cmk_macro, /* An ISO macro (token expansion). */
cmk_assert, /* An assertion. */
cmk_traditional /* A traditional macro (text expansion). */
};
/* Each macro definition is recorded in a cpp_macro structure.
Variadic macros cannot occur with traditional cpp. */
struct GTY(()) cpp_macro {
union cpp_parm_u
{
/* Parameters, if any. If parameter names use extended identifiers,
the original spelling of those identifiers, not the canonical
UTF-8 spelling, goes here. */
cpp_hashnode ** GTY ((tag ("false"),
nested_ptr (union tree_node,
"%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
"%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL"),
length ("%1.paramc"))) params;
/* If this is an assertion, the next one in the chain. */
cpp_macro *GTY ((tag ("true"))) next;
} GTY ((desc ("%1.kind == cmk_assert"))) parm;
/* Definition line number. */
location_t line;
/* Number of tokens in body, or bytes for traditional macros. */
/* Do we really need 2^32-1 range here? */
unsigned int count;
/* Number of parameters. */
unsigned short paramc;
/* Non-zero if this is a user-lazy macro, value provided by user. */
unsigned char lazy;
/* The kind of this macro (ISO, trad or assert) */
unsigned kind : 2;
/* If a function-like macro. */
unsigned int fun_like : 1;
/* If a variadic macro. */
unsigned int variadic : 1;
/* If macro defined in system header. */
unsigned int syshdr : 1;
/* Nonzero if it has been expanded or had its existence tested. */
unsigned int used : 1;
/* Indicate whether the tokens include extra CPP_PASTE tokens at the
end to track invalid redefinitions with consecutive CPP_PASTE
tokens. */
unsigned int extra_tokens : 1;
/* Imported C++20 macro (from a header unit). */
unsigned int imported_p : 1;
/* 0 bits spare (32-bit). 32 on 64-bit target. */
union cpp_exp_u
{
/* Trailing array of replacement tokens (ISO), or assertion body value. */
cpp_token GTY ((tag ("false"), length ("%1.count"))) tokens[1];
/* Pointer to replacement text (traditional). See comment at top
of cpptrad.c for how traditional function-like macros are
encoded. */
const unsigned char *GTY ((tag ("true"))) text;
} GTY ((desc ("%1.kind == cmk_traditional"))) exp;
};
/* Poisoned identifiers are flagged NODE_POISONED. NODE_OPERATOR (C++
only) indicates an identifier that behaves like an operator such as
"xor". NODE_DIAGNOSTIC is for speed in lex_token: it indicates a
diagnostic may be required for this node. Currently this only
applies to __VA_ARGS__, poisoned identifiers, and -Wc++-compat
warnings about NODE_OPERATOR. */
/* Hash node flags. */
#define NODE_OPERATOR (1 << 0) /* C++ named operator. */
#define NODE_POISONED (1 << 1) /* Poisoned identifier. */
#define NODE_DIAGNOSTIC (1 << 2) /* Possible diagnostic when lexed. */
#define NODE_WARN (1 << 3) /* Warn if redefined or undefined. */
#define NODE_DISABLED (1 << 4) /* A disabled macro. */
#define NODE_USED (1 << 5) /* Dumped with -dU. */
#define NODE_CONDITIONAL (1 << 6) /* Conditional macro */
#define NODE_WARN_OPERATOR (1 << 7) /* Warn about C++ named operator. */
#define NODE_MODULE (1 << 8) /* C++-20 module-related name. */