Repository navigation
Expand file tree
/
Copy pathlex.tex
More file actions
2370 lines (2157 loc) · 81.3 KB
/
Copy pathlex.tex
File metadata and controls
2370 lines (2157 loc) · 81.3 KB
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
%!TEX root = std.tex
\rSec0[lex]{Lexical conventions}
\gramSec[gram.lex]{Lexical conventions}
\indextext{lexical conventions|see{conventions, lexical}}
\indextext{translation!separate|see{compilation, separate}}
\indextext{separate translation|see{compilation, separate}}
\indextext{separate compilation|see{compilation, separate}}
\indextext{phases of translation|see{translation, phases}}
\indextext{source file character|see{character, source file}}
\indextext{alternative token|see{token, alternative}}
\indextext{digraph|see{token, alternative}}
\indextext{integer literal|see{literal, integer}}
\indextext{character literal|see{literal, character}}
\indextext{floating-point literal|see{literal, floating-point}}
\indextext{string literal|see{literal, string}}
\indextext{boolean literal|see{literal, boolean}}
\indextext{pointer literal|see{literal, pointer}}
\indextext{user-defined literal|see{literal, user-defined}}
\indextext{file, source|see{source file}}
\indextext{null character|see{character, null}}
\indextext{null wide character|see{wide-character, null}}
\rSec1[lex.separate]{Separate translation}
\pnum
\indextext{conventions!lexical|(}%
\indextext{compilation!separate|(}%
The text of the program is kept in units called
\defnx{source files}{source file} in this document.
A source file together with all the headers\iref{headers}
and source files included\iref{cpp.include} via the preprocessing
directive \tcode{\#include}, less any source lines skipped by any of the
conditional inclusion\iref{cpp.cond} preprocessing directives,
as modified by the implementation-defined behavior of any
conditionally-supported-directives\iref{cpp.pre} and pragmas\iref{cpp.pragma},
if any, is
called a \defnadj{preprocessing}{translation unit}.
\begin{note}
A \Cpp{} program need not all be translated at the same time.
Translation units can be separately translated and then later linked
to produce an executable program\iref{basic.link}.
\end{note}
\begin{note}
Source files, translation units, and translated translation units
need not necessarily be stored as files, nor need there be any one-to-one
correspondence between these entities and any external representation.
The description is conceptual only,
and does not specify any particular implementation.
\end{note}
\indextext{compilation!separate|)}
\rSec1[lex.phases]{Phases of translation}%
\pnum
\indextext{translation!phases|(}%
The precedence among the syntax rules of translation is specified by the
following phases.
\begin{footnote}
Implementations behave as if these separate phases
occur, although in practice different phases can be folded together.
\end{footnote}
\begin{enumerate}
\item
\indextext{character!source file}%
An implementation shall support input files
that are a sequence of UTF-8 code units (UTF-8 files).
It may also support
an \impldef{supported input files} set of other kinds of input files, and,
if so, the kind of an input file is determined in
an \impldef{determination of kind of input file} manner
that includes a means of designating input files as UTF-8 files,
independent of their content.
\begin{note}
In other words,
recognizing the \unicode{feff}{byte order mark} is not sufficient.
\end{note}
If an input file is determined to be a UTF-8 file,
then it shall be a well-formed UTF-8 code unit sequence and
it is decoded to produce a sequence of Unicode
\begin{footnote}
Unicode\textregistered\ is a registered trademark of Unicode, Inc.
This information is given for the convenience of users of this document and
does not constitute an endorsement by ISO or IEC of this product.
\end{footnote}
scalar values.
A sequence of translation character set elements\iref{lex.charset} is then formed
by mapping each Unicode scalar value
to the corresponding translation character set element.
In the resulting sequence,
each pair of characters in the input sequence consisting of
\unicode{000d}{carriage return} followed by \unicode{000a}{line feed},
as well as each
\unicode{000d}{carriage return} not immediately followed by a \unicode{000a}{line feed},
is replaced by a single new-line character.
For any other kind of input file supported by the implementation,
characters are mapped, in an
\impldef{mapping input file characters to translation character set} manner,
to a sequence of translation character set elements,
representing end-of-line indicators as new-line characters.
\item
\indextext{line splicing}%
If the first translation character is \unicode{feff}{byte order mark},
it is deleted.
Each sequence comprising a backslash character (\textbackslash)
immediately followed by
zero or more whitespace characters other than new-line followed by
a new-line character is deleted, splicing
physical source lines to form \defnx{logical source lines}{source line!logical}. Only the last
backslash on any physical source line is eligible for being part
of such a splice.
\begin{note}
Line splicing can form
a \grammarterm{universal-character-name}\iref{lex.charset}.
\end{note}
A source file that is not empty and that (after splicing)
does not end in a new-line character
is processed as if an additional new-line character were appended
to the file.
\item The source file is decomposed into preprocessing
tokens\iref{lex.pptoken} and sequences of whitespace characters
(including comments). A source file shall not end in a partial
preprocessing token or in a partial comment.
\begin{footnote}
A partial preprocessing
token would arise from a source file
ending in the first portion of a multi-character token that requires a
terminating sequence of characters, such as a \grammarterm{header-name}
that is missing the closing \tcode{"}
or \tcode{>}. A partial comment
would arise from a source file ending with an unclosed \tcode{/*}
comment.
\end{footnote}
Each comment\iref{lex.comment} is replaced by one \unicode{0020}{space} character. New-line characters are
retained. Whether each nonempty sequence of whitespace characters other
than new-line is retained or replaced by one \unicode{0020}{space} character is
unspecified.
As characters from the source file are consumed
to form the next preprocessing token
(i.e., not being consumed as part of a comment or other forms of whitespace),
except when matching a
\grammarterm{c-char-sequence},
\grammarterm{s-char-sequence},
\grammarterm{r-char-sequence},
\grammarterm{h-char-sequence}, or
\grammarterm{q-char-sequence},
\grammarterm{universal-character-name}s are recognized\iref{lex.universal.char} and
replaced by the designated element of the translation character set\iref{lex.charset}.
The process of dividing a source file's
characters into preprocessing tokens is context-dependent.
\begin{example}
See the handling of \tcode{<} within a \tcode{\#include} preprocessing
directive\iref{lex.header,cpp.include}.
\end{example}
\item The source file is analyzed as a \grammarterm{preprocessing-file}\iref{cpp.pre}.
Preprocessing directives\iref{cpp} are executed, macro invocations are
expanded\iref{cpp.replace}, and \tcode{_Pragma} unary operator expressions are executed\iref{cpp.pragma.op}.
A \tcode{\#include} preprocessing directive\iref{cpp.include} causes the named header or
source file to be processed from phase 1 through phase 4, recursively.
All preprocessing directives are then deleted.
Whitespace characters separating preprocessing tokens are no longer significant.
\item
For a sequence of two or more adjacent \grammarterm{string-literal} preprocessing tokens,
a common \grammarterm{encoding-prefix} is determined
as specified in \ref{lex.string}.
Each such \grammarterm{string-literal} preprocessing token is then considered to have
that common \grammarterm{encoding-prefix}.
\indextext{concatenation!string}%
Then, adjacent \grammarterm{string-literal} preprocessing tokens are concatenated\iref{lex.string}.
\item
Each preprocessing token is converted into a token\iref{lex.token}.
\item
The tokens constitute a \defn{translation unit} and
are syntactically and
semantically analyzed as a \grammarterm{translation-unit}\iref{basic.link} and
translated.
\begin{note}
The process of analyzing and translating the tokens can occasionally
result in one token being replaced by a sequence of other
tokens\iref{temp.names}.
\end{note}
It is
\impldef{whether the sources for
module units and header units
on which the current translation unit has an interface
dependency are required to be available during translation}
whether the sources for
module units and header units
on which the current translation unit has an interface
dependency\iref{module.unit,module.import}
are required to be available.
\begin{note}
Previously translated translation units can be preserved individually or in libraries.
The separate translation units of a program communicate\iref{basic.link} by (for example)
calls to functions whose names have external or module linkage,
manipulation of variables whose names have external or module linkage, or
manipulation of data files.
\end{note}
While the tokens constituting translation units
are being analyzed and translated,
required instantiations are performed.
\begin{note}
This can include
instantiations which have been explicitly
requested\iref{temp.explicit}.
\end{note}
The contexts from which instantiations may be performed
are determined by their respective points of instantiation\iref{temp.point}.
\begin{note}
Other requirements in this document can further constrain
the context from which an instantiation can be performed.
For example, a constexpr function template specialization
might have a point of instantiation at the end of a translation unit,
but its use in certain constant expressions could require
that it be instantiated at an earlier point\iref{temp.inst}.
\end{note}
The program is ill-formed if any instantiation fails.
During the analysis and translation of tokens,
each manifestly constant-evaluated expression is evaluated\iref{expr.const.defns}.
The values of these expressions affect
the types named and reflection values used in the program and
thus the syntactic analysis.
Their evaluation also can produce side effects that affect that analysis.
Constructs appearing at a program point $P$ are analyzed
in a context where each side effect of evaluating an expression $E$
as a full-expression is complete if and only if
\begin{itemize}
\item
$E$ is the expression corresponding to
a \grammarterm{consteval-block-declaration}\iref{dcl.pre}, and
\item
either that \grammarterm{consteval-block-declaration} or
the template definition from which it is instantiated
is reachable from\iref{module.reach}
\begin{itemize}
\item
$P$, or
\item
the point immediately following
the \grammarterm{class-specifier} of the outermost class
for which $P$ is in a complete-class context\iref{class.mem.general}.
\end{itemize}
\end{itemize}
\begin{example}
\begin{codeblock}
class S {
class Incomplete;
class Inner {
void fn() {
/* @$p_1$@ */ Incomplete i; // OK
}
} /* @$p_2$@ */ ;
consteval {
define_aggregate(^^Incomplete, {});
}
} /* @$p_3$@ */ ;
\end{codeblock}
Constructs at $p_1$ are analyzed in a context
where the side effect of the call to \tcode{define_aggregate} is complete
because
\begin{itemize}
\item
the call appears in a consteval block, and
\item
$p_1$ is in a complete-class context of \tcode{S} and
the consteval block is reachable from $p_3$.
\end{itemize}
\end{example}
\item
\indextext{linking}%
Translated translation units are combined, and
all external entity references are resolved\iref{basic.link}. Library
components are linked to satisfy external references to
entities not defined in the current translation. All such translator
output is collected into a program image which contains information
needed for execution in its execution environment.%
\indextext{translation!phases|)}
\end{enumerate}
\rSec1[lex.char]{Characters}%
\rSec2[lex.charset]{Character sets}
\pnum
\indextext{character set|(}%
The \defnadj{translation}{character set} consists of the following elements:
\begin{itemize}
\item
each abstract character assigned a code point in the Unicode codespace
as specified in the Unicode Standard, and
\item
a distinct character for each Unicode scalar value
not assigned to an abstract character.
\end{itemize}
\begin{note}
Unicode code points are integers
in the range $[0, \mathrm{10FFFF}]$ (hexadecimal).
A surrogate code point is a value
in the range $[\mathrm{D800}, \mathrm{DFFF}]$ (hexadecimal).
A Unicode scalar value is any code point that is not a surrogate code point.
\end{note}
\pnum
The \defnadj{basic}{character set} is a subset of the translation character set,
consisting of 99 characters as specified in \tref{lex.charset.basic}.
In this document,
glyphs are often used to identify
elements of the basic character set.
\begin{note}
Unicode short names are given only as a means to identifying the character;
the numerical value has no other meaning in this context.
\end{note}
\begin{floattable}{Basic character set}{lex.charset.basic}{lll}
\topline
\lhdrx{2}{character} & \rhdr{glyph} \\ \capsep
\ucode{0009} & \uname{character tabulation} & \\
\ucode{000b} & \uname{line tabulation} & \\
\ucode{000c} & \uname{form feed} & \\
\ucode{0020} & \uname{space} & \\
\ucode{000a} & \uname{line feed} & new-line \\
\ucode{0021} & \uname{exclamation mark} & \tcode{!} \\
\ucode{0022} & \uname{quotation mark} & \tcode{"} \\
\ucode{0023} & \uname{number sign} & \tcode{\#} \\
\ucode{0024} & \uname{dollar sign} & \tcode{\$} \\
\ucode{0025} & \uname{percent sign} & \tcode{\%} \\
\ucode{0026} & \uname{ampersand} & \tcode{\&} \\
\ucode{0027} & \uname{apostrophe} & \tcode{'} \\
\ucode{0028} & \uname{left parenthesis} & \tcode{(} \\
\ucode{0029} & \uname{right parenthesis} & \tcode{)} \\
\ucode{002a} & \uname{asterisk} & \tcode{*} \\
\ucode{002b} & \uname{plus sign} & \tcode{+} \\
\ucode{002c} & \uname{comma} & \tcode{,} \\
\ucode{002d} & \uname{hyphen-minus} & \tcode{-} \\
\ucode{002e} & \uname{full stop} & \tcode{.} \\
\ucode{002f} & \uname{solidus} & \tcode{/} \\
\ucode{0030} .. \ucode{0039} & \uname{digit zero .. nine} & \tcode{0 1 2 3 4 5 6 7 8 9} \\
\ucode{003a} & \uname{colon} & \tcode{:} \\
\ucode{003b} & \uname{semicolon} & \tcode{;} \\
\ucode{003c} & \uname{less-than sign} & \tcode{<} \\
\ucode{003d} & \uname{equals sign} & \tcode{=} \\
\ucode{003e} & \uname{greater-than sign} & \tcode{>} \\
\ucode{003f} & \uname{question mark} & \tcode{?} \\
\ucode{0040} & \uname{commercial at} & \tcode{@} \\
\ucode{0041} .. \ucode{005a} & \uname{latin capital letter a .. z} & \tcode{A B C D E F G H I J K L M} \\
& & \tcode{N O P Q R S T U V W X Y Z} \\
\ucode{005b} & \uname{left square bracket} & \tcode{[} \\
\ucode{005c} & \uname{reverse solidus} & \tcode{\textbackslash} \\
\ucode{005d} & \uname{right square bracket} & \tcode{]} \\
\ucode{005e} & \uname{circumflex accent} & \tcode{\caret} \\
\ucode{005f} & \uname{low line} & \tcode{_} \\
\ucode{0060} & \uname{grave accent} & \tcode{\`} \\
\ucode{0061} .. \ucode{007a} & \uname{latin small letter a .. z} & \tcode{a b c d e f g h i j k l m} \\
& & \tcode{n o p q r s t u v w x y z} \\
\ucode{007b} & \uname{left curly bracket} & \tcode{\{} \\
\ucode{007c} & \uname{vertical line} & \tcode{|} \\
\ucode{007d} & \uname{right curly bracket} & \tcode{\}} \\
\ucode{007e} & \uname{tilde} & \tcode{\textasciitilde} \\
\end{floattable}
\pnum
The \defnadj{basic literal}{character set} consists of
all characters of the basic character set,
plus the control characters specified in \tref{lex.charset.literal}.
\begin{floattable}{Additional control characters in the basic literal character set}{lex.charset.literal}{ll}
\topline
\ohdrx{2}{character} \\ \capsep
\ucode{0000} & \uname{null} \\
\ucode{0007} & \uname{alert} \\
\ucode{0008} & \uname{backspace} \\
\ucode{000d} & \uname{carriage return} \\
\end{floattable}
\pnum
A \defn{code unit} is an integer value
of character type\iref{basic.fundamental}.
Characters in a \grammarterm{character-literal}
other than a multicharacter or non-encodable character literal or
in a \grammarterm{string-literal} are encoded as
a sequence of one or more code units, as determined
by the \grammarterm{encoding-prefix}\iref{lex.ccon,lex.string};
this is termed the respective \defnadj{literal}{encoding}.
The \defnadj{ordinary literal}{encoding} is
the encoding applied to an ordinary character or string literal.
The \defnadj{wide literal}{encoding} is the encoding applied
to a wide character or string literal.
\pnum
A literal encoding or a locale-specific encoding of one of
the execution character sets\iref{character.seq}
encodes each element of the basic literal character set as
a single code unit with non-negative value,
distinct from the code unit for any other such element.
\begin{note}
A character not in the basic literal character set
can be encoded with more than one code unit;
the value of such a code unit can be the same as
that of a code unit for an element of the basic literal character set.
\end{note}
\indextext{character!null}%
\indextext{wide-character!null}%
The \unicode{0000}{null} character is encoded as the value \tcode{0}.
No other element of the translation character set
is encoded with a code unit of value \tcode{0}.
The code unit value of each decimal digit character after the digit \tcode{0} (\ucode{0030})
is one greater than the value of the previous.
The ordinary and wide literal encodings are otherwise
\impldef{ordinary and wide literal encodings}.
\indextext{UTF-8}%
\indextext{UTF-16}%
\indextext{UTF-32}%
For a UTF-8, UTF-16, or UTF-32 literal,
the implementation shall encode
the Unicode scalar value
corresponding to each character of the translation character set
as specified in the Unicode Standard
for the respective Unicode encoding form.
\indextext{character set|)}
\rSec2[lex.universal.char]{Universal character names}
\begin{bnf}
\nontermdef{n-char}\br
\textnormal{any member of the translation character set except the \unicode{007d}{right curly bracket} or new-line character}
\end{bnf}
\begin{bnf}
\nontermdef{n-char-sequence}\br
n-char \opt{n-char-sequence}
\end{bnf}
\begin{bnf}
\nontermdef{named-universal-character}\br
\terminal{\textbackslash N\{} n-char-sequence \terminal{\}}
\end{bnf}
\begin{bnf}
\nontermdef{hex-quad}\br
hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit
\end{bnf}
\begin{bnf}
\nontermdef{simple-hexadecimal-digit-sequence}\br
hexadecimal-digit \opt{simple-hexadecimal-digit-sequence}
\end{bnf}
\begin{bnf}
\nontermdef{universal-character-name}\br
\terminal{\textbackslash u} hex-quad\br
\terminal{\textbackslash U} hex-quad hex-quad\br
\terminal{\textbackslash u\{} simple-hexadecimal-digit-sequence \terminal{\}}\br
named-universal-character
\end{bnf}
\pnum
The \grammarterm{universal-character-name} construct provides a way to name any
element in the translation character set using just the basic character set.
If a \grammarterm{universal-character-name} outside
the \grammarterm{c-char-sequence} or \grammarterm{s-char-sequence}
of a \grammarterm{character-literal} or \grammarterm{string-literal}
(in either case, including within a \grammarterm{user-defined-literal})
corresponds to a control character or to a character in the basic character set,
the program is ill-formed.
\begin{note}
A sequence of characters resembling a \grammarterm{universal-character-name} in an
\grammarterm{r-char-sequence}\iref{lex.string} does not form a
\grammarterm{universal-character-name}.
\end{note}
\pnum
A \grammarterm{universal-character-name}
of the form \tcode{\textbackslash u} \grammarterm{hex-quad},
\tcode{\textbackslash U} \grammarterm{hex-quad} \grammarterm{hex-quad}, or
\tcode{\textbackslash u\{\grammarterm{simple-hexadecimal-digit-sequence}\}}
designates the character in the translation character set
whose Unicode scalar value is the hexadecimal number represented by
the sequence of \grammarterm{hexadecimal-digit}s
in the \grammarterm{universal-character-name}.
The program is ill-formed if that number is not a Unicode scalar value.
\pnum
A \grammarterm{universal-character-name}
that is a \grammarterm{named-universal-character}
designates the corresponding character
in the Unicode Standard (chapter 4.8 Name)
if the \grammarterm{n-char-sequence} is equal
to its character name or
to one of its character name aliases;
otherwise, the program is ill-formed.
\begin{note}
These aliases are listed in
the Unicode Character Database's \tcode{NameAliases.txt}.
None of these names or aliases have leading or trailing spaces.
\end{note}
\rSec1[lex.comment]{Comments}
\pnum
\indextext{comment|(}%
\indextext{comment!\tcode{/*} \tcode{*/}}%
\indextext{comment!\tcode{//}}%
The characters \tcode{/*} start a comment, which terminates with the
characters \tcode{*/}. These comments do not nest.
\indextext{comment!\tcode{//}}%
The characters \tcode{//} start a comment, which terminates immediately before the
next new-line character.
\begin{note}
The comment characters \tcode{//}, \tcode{/*},
and \tcode{*/} have no special meaning within a \tcode{//} comment and
are treated just like other characters. Similarly, the comment
characters \tcode{//} and \tcode{/*} have no special meaning within a
\tcode{/*} comment.
\end{note}
\indextext{comment|)}
\rSec1[lex.pptoken]{Preprocessing tokens}
\indextext{token!preprocessing|(}%
\begin{bnf}
\nontermdef{preprocessing-token}\br
header-name\br
import-keyword\br
module-keyword\br
export-keyword\br
identifier\br
pp-number\br
character-literal\br
user-defined-character-literal\br
string-literal\br
user-defined-string-literal\br
preprocessing-op-or-punc\br
\textnormal{each non-whitespace character that cannot be one of the above}
\end{bnf}
\pnum
A preprocessing token is the minimal lexical element of the language in translation
phases 3 through 5.
The categories of preprocessing token are: header names,
placeholder tokens produced by preprocessing \tcode{import} and \tcode{module} directives
(\grammarterm{import-keyword}, \grammarterm{module-keyword}, and \grammarterm{export-keyword}),
identifiers, preprocessing numbers, character literals (including user-defined character
literals), string literals (including user-defined string literals), preprocessing
operators and punctuators, and single non-whitespace characters that do not lexically
match the other preprocessing token categories.
If a \unicode{0027}{apostrophe}, a \unicode{0022}{quotation mark},
or any character not in the basic character set
matches the last category, the program is ill-formed.
\pnum
Preprocessing tokens can be separated by
\indextext{whitespace}%
whitespace;
\indextext{comment}%
this consists of comments\iref{lex.comment}, or whitespace characters
(\unicode{0020}{space},
\unicode{0009}{character tabulation},
new-line,
\unicode{000b}{line tabulation}, and
\unicode{000c}{form feed}), or both.
\begin{note}
As described in \ref{cpp}, in certain
circumstances during translation phase 4, whitespace (or the absence
thereof) serves as more than preprocessing token separation. Whitespace
can appear within a preprocessing token only as part of a header name or
between the quotation characters in a character literal or
string literal.
\end{note}
\pnum
Each preprocessing token that is converted to a token\iref{lex.token}
shall have the lexical form of a keyword, an identifier, a literal,
a header name,
or an operator or punctuator.
\pnum
\indexgrammar{\idxgram{import-keyword}}%
\indexgrammar{\idxgram{module-keyword}}%
\indexgrammar{\idxgram{export-keyword}}%
The \grammarterm{import-keyword} is produced
by processing an \keyword{import} directive\iref{cpp.import},
the \grammarterm{module-keyword} is produced
by preprocessing a \keyword{module} directive\iref{cpp.module}, and
the \grammarterm{export-keyword} is produced
by preprocessing either of the previous two directives.
\begin{note}
None has any observable spelling.
\end{note}
\pnum
If the input stream has been parsed into preprocessing tokens up to a
given character:
\begin{itemize}
\item
\indextext{literal!string!raw}%
If the next character begins a sequence of characters that could be the prefix
and initial double quote of a raw string literal, such as \tcode{R"}, the next preprocessing
token shall be a raw string literal. Between the initial and final
double quote characters of the raw string, any transformations performed in phase
2 (line splicing) are reverted; this reversion
is applied before any \grammarterm{d-char}, \grammarterm{r-char}, or delimiting
parenthesis is identified. The raw string literal is defined as the shortest sequence
of characters that matches the raw-string pattern
\begin{ncbnf}
\opt{encoding-prefix} \terminal{R} raw-string
\end{ncbnf}
\item Otherwise, if the next three characters are \tcode{<::} and the subsequent character
is neither \tcode{:} nor \tcode{>}, the \tcode{<} is treated as a preprocessing token by
itself and not as the first character of the alternative token \tcode{<:}.
\item
Otherwise, if the next three characters are \tcode{[::} and
the subsequent character is not \tcode{:}, or
if the next three characters are \tcode{[:>},
the \tcode{[} is treated as a preprocessing token by itself and
not as the first character of the preprocessing token \tcode{[:}.
\begin{note}
The tokens \tcode{[:} and \tcode{:]} cannot be composed from digraphs.
\end{note}
\item Otherwise,
the next preprocessing token is the longest sequence of
characters that could constitute a preprocessing token, even if that
would cause further lexical analysis to fail,
except that
\begin{itemize}
\item
a \grammarterm{string-literal} token is never formed
when a \grammarterm{header-name} token can be formed, and
\item
a \grammarterm{header-name}\iref{lex.header} is only formed
\begin{itemize}
\item
immediately after the \tcode{include} or \tcode{embed} preprocessing token in a
\tcode{\#include}\iref{cpp.include} or \tcode{\#embed}\iref{cpp.embed}
directive, respectively, or
\item
immediately after an \tcode{import} preprocessing token that
is at the start of a logical source line, or
\item
immediately after a preprocessing token sequence of \xname{has_include}
or \xname{has_embed} immediately followed by \tcode{(}
in a \tcode{\#if}, \tcode{\#elif}, or \tcode{\#embed} directive\iref{cpp.cond,cpp.embed}.
\end{itemize}
A preprocessing token is considered to be
\defnx{immediately after}{token!immediately after}
another preprocessing token if
the preprocessing tokens are on the same logical source line and
there are no intervening preprocessing tokens.
\end{itemize}
\end{itemize}
\pnum
\begin{example}
\begin{codeblock}
#define R "x"
const char* s = R"y"; // ill-formed raw string, not \tcode{"x" "y"}
\end{codeblock}
\end{example}
\pnum
\begin{example}
The program fragment \tcode{0xe+foo} is parsed as a
preprocessing number token (one that is not a valid
\grammarterm{integer-literal} or \grammarterm{floating-point-literal} token),
even though a parse as three preprocessing tokens
\tcode{0xe}, \tcode{+}, and \tcode{foo} can produce a valid expression (for example,
if \tcode{foo} is a macro defined as \tcode{1}). Similarly, the
program fragment \tcode{1E1} is parsed as a preprocessing number (one
that is a valid \grammarterm{floating-point-literal} token),
whether or not \tcode{E} is a macro name.
\end{example}
\pnum
\begin{example}
The program fragment \tcode{x+++++y} is parsed as \tcode{x
++ ++ + y}, which, if \tcode{x} and \tcode{y} have integral types,
violates a constraint on increment operators, even though the parse
\tcode{x ++ + ++ y} can yield a correct expression.
\end{example}
\indextext{token!preprocessing|)}
\rSec1[lex.header]{Header names}
\indextext{header!name|(}%
\begin{bnf}
\microtypesetup{protrusion=false}
\nontermdef{header-name}\br
\terminal{<} h-char-sequence \terminal{>}\br
\terminal{"} q-char-sequence \terminal{"}
\end{bnf}
\begin{bnf}
\nontermdef{h-char-sequence}\br
h-char \opt{h-char-sequence}
\end{bnf}
\begin{bnf}
\nontermdef{h-char}\br
\textnormal{any member of the translation character set except new-line and \unicode{003e}{greater-than sign}}
\end{bnf}
\begin{bnf}
\nontermdef{q-char-sequence}\br
q-char \opt{q-char-sequence}
\end{bnf}
\begin{bnf}
\nontermdef{q-char}\br
\textnormal{any member of the translation character set except new-line and \unicode{0022}{quotation mark}}
\end{bnf}
\pnum
The sequences in both forms of \grammarterm{header-name}{s} are mapped in an
\impldef{mapping header name to header or external source file} manner to headers or to
external source file names as specified in~\ref{cpp.include}.
\begin{note}
Header name preprocessing tokens appear only within
a \tcode{\#include} preprocessing directive,
a \tcode{__has_include} preprocessing expression, or
after certain occurrences of an \tcode{import} token
(see~\ref{lex.pptoken}).
\end{note}
\pnum
The appearance of either of the characters \tcode{'} or \tcode{\textbackslash} or of
either of the character sequences \tcode{/*} or \tcode{//} in a
\grammarterm{q-char-sequence} or an \grammarterm{h-char-sequence}
is conditionally-supported with \impldef{meaning of \tcode{'}, \tcode{\textbackslash},
\tcode{/*}, or \tcode{//} in a \grammarterm{q-char-sequence} or an
\grammarterm{h-char-sequence}} semantics, as is the appearance of the character
\tcode{"} in an \grammarterm{h-char-sequence}.
\begin{note}
Thus, a sequence of characters
that resembles an escape sequence can result in an error, be interpreted as the
character corresponding to the escape sequence, or have a completely different meaning,
depending on the implementation.
\end{note}
\indextext{header!name|)}
\rSec1[lex.ppnumber]{Preprocessing numbers}
\indextext{number!preprocessing|(}%
\begin{bnf}
\nontermdef{pp-number}\br
digit\br
\terminal{.} digit\br
pp-number identifier-continue\br
pp-number \terminal{'} digit\br
pp-number \terminal{'} nondigit\br
pp-number \terminal{e} sign\br
pp-number \terminal{E} sign\br
pp-number \terminal{p} sign\br
pp-number \terminal{P} sign\br
pp-number \terminal{.}
\end{bnf}
\pnum
Preprocessing number tokens lexically include
all \grammarterm{integer-literal} tokens\iref{lex.icon} and
all \grammarterm{floating-point-literal} tokens\iref{lex.fcon}.
\pnum
A preprocessing number does not have a type or a value; it acquires both
after a successful conversion to
an \grammarterm{integer-literal} token or
a \grammarterm{floating-point-literal} token.%
\indextext{number!preprocessing|)}
\rSec1[lex.operators]{Operators and punctuators}
\pnum
\indextext{operator|(}%
\indextext{punctuator|(}%
The lexical representation of \Cpp{} programs includes a number of
preprocessing tokens that are used in the syntax of the preprocessor or
are converted into tokens for operators and punctuators:
\begin{bnf}
\nontermdef{preprocessing-op-or-punc}\br
preprocessing-operator\br
operator-or-punctuator
\end{bnf}
\begin{bnf}
%% Ed. note: character protrusion would misalign various operators.
\microtypesetup{protrusion=false}
\nontermdef{preprocessing-operator} \textnormal{one of}\br
\terminal{\# \ \ \ \ \ \ \ \#\# \ \ \ \ \ \ \%: \ \ \ \ \ \ \%:\%:}
\end{bnf}
\begin{bnf}
\microtypesetup{protrusion=false}
\nontermdef{operator-or-punctuator} \textnormal{one of}\br
\terminal{\{ \ \ \ \ \ \ \ \} \ \ \ \ \ \ \ [ \ \ \ \ \ \ \ ] \ \ \ \ \ \ \ ( \ \ \ \ \ \ \ ) \ \ \ \ \ \ \ [: \ \ \ \ \ \ :]}\br
\terminal{<\% \ \ \ \ \ \ \%> \ \ \ \ \ \ <: \ \ \ \ \ \ :> \ \ \ \ \ \ ; \ \ \ \ \ \ \ : \ \ \ \ \ \ \ ...}\br
\terminal{? \ \ \ \ \ \ \ :: \ \ \ \ \ \ . \ \ \ \ \ \ \ .* \ \ \ \ \ \ -> \ \ \ \ \ \ ->* \ \ \ \ \ \caret{}\caret{} \ \ \ \ \ \ \~}\br
\terminal{! \ \ \ \ \ \ \ + \ \ \ \ \ \ \ - \ \ \ \ \ \ \ * \ \ \ \ \ \ \ / \ \ \ \ \ \ \ \% \ \ \ \ \ \ \ \caret{} \ \ \ \ \ \ \ \& \ \ \ \ \ \ \ |}\br
\terminal{= \ \ \ \ \ \ \ += \ \ \ \ \ \ -= \ \ \ \ \ \ *= \ \ \ \ \ \ /= \ \ \ \ \ \ \%= \ \ \ \ \ \ \caret{}= \ \ \ \ \ \ \&= \ \ \ \ \ \ |=}\br
\terminal{== \ \ \ \ \ \ != \ \ \ \ \ \ < \ \ \ \ \ \ \ > \ \ \ \ \ \ \ <= \ \ \ \ \ \ >= \ \ \ \ \ \ <=> \ \ \ \ \ \&\& \ \ \ \ \ \ ||}\br
\terminal{<< \ \ \ \ \ \ >> \ \ \ \ \ \ <<= \ \ \ \ \ >>= \ \ \ \ \ ++ \ \ \ \ \ \ -- \ \ \ \ \ \ ,}\br
\terminal{\keyword{and} \ \ \ \ \ \keyword{or} \ \ \ \ \ \ \keyword{xor} \ \ \ \ \ \keyword{not} \ \ \ \ \ \keyword{bitand} \ \ \keyword{bitor} \ \ \ \keyword{compl}}\br
\terminal{\keyword{and_eq} \ \ \keyword{or_eq} \ \ \ \keyword{xor_eq} \ \ \keyword{not_eq}}
\end{bnf}
Each \grammarterm{operator-or-punctuator} is converted to a single token
in translation phase 6\iref{lex.phases}.%
\indextext{punctuator|)}%
\indextext{operator|)}
\rSec1[lex.digraph]{Alternative tokens}
\pnum
\indextext{token!alternative|(}%
Alternative token representations are provided for some operators and
punctuators.
\begin{footnote}
\indextext{digraph}%
These include ``digraphs'' and additional reserved words. The term
``digraph'' (token consisting of two characters) is not perfectly
descriptive, since one of the alternative \grammarterm{preprocessing-token}s is
\tcode{\%:\%:} and of course several primary tokens contain two
characters. Nonetheless, those alternative tokens that aren't lexical
keywords are colloquially known as ``digraphs''.
\end{footnote}
\pnum
In all respects of the language, each alternative token behaves the
same, respectively, as its primary token, except for its spelling.
\begin{note}
The ``stringized'' values\iref{cpp.stringize} of
\tcode{[} and \tcode{<:} are different,
maintaining the source spelling.
\end{note}
The set of alternative tokens is defined in
\tref{lex.digraph}.
\begin{tokentable}{Alternative tokens}{lex.digraph}{Alternative}{Primary}
\tcode{<\%} & \tcode{\{} &
\keyword{and} & \tcode{\&\&} &
\keyword{and_eq} & \tcode{\&=} \\ \rowsep
\tcode{\%>} & \tcode{\}} &
\keyword{bitor} & \tcode{|} &
\keyword{or_eq} & \tcode{|=} \\ \rowsep
\tcode{<:} & \tcode{[} &
\keyword{or} & \tcode{||} &
\keyword{xor_eq} & \tcode{\caret=} \\ \rowsep
\tcode{:>} & \tcode{]} &
\keyword{xor} & \tcode{\caret} &
\keyword{not} & \tcode{!} \\ \rowsep
\tcode{\%:} & \tcode{\#} &
\keyword{compl} & \tcode{\~} &
\keyword{not_eq} & \tcode{!=} \\ \rowsep
\tcode{\%:\%:} & \tcode{\#\#} &
\keyword{bitand} & \tcode{\&} &
& \\
\end{tokentable}%
\indextext{token!alternative|)}
\rSec1[lex.token]{Tokens}
\indextext{token|(}%
\begin{bnf}
\nontermdef{token}\br
identifier\br
keyword\br
literal\br
header-name\br
operator-or-punctuator
\end{bnf}
\pnum
\indextext{\idxgram{token}}%
There are six kinds of tokens: identifiers, keywords, literals,
header names,
operators, and other separators.
\indextext{token|)}
\rSec1[lex.name]{Identifiers}
\indextext{XID_Start}%
\indextext{XID_Continue}%
\indextext{identifier|(}%
\begin{bnf}
\nontermdef{identifier}\br
identifier-start\br
identifier identifier-continue
\end{bnf}
\begin{bnf}
\nontermdef{identifier-start}\br
nondigit\br
\textnormal%
{an element of the translation character set with the Unicode property XID_Start or the Unicode property ID_Compat_Math_Start}
\end{bnf}
\begin{bnf}
\nontermdef{identifier-continue}\br
digit\br
nondigit\br
\textnormal%
{an element of the translation character set with the Unicode property XID_Continue or the Unicode property ID_Compat_Math_Continue}
\end{bnf}
\begin{bnf}
\nontermdef{nondigit} \textnormal{one of}\br
\terminal{a b c d e f g h i j k l m}\br
\terminal{n o p q r s t u v w x y z}\br
\terminal{A B C D E F G H I J K L M}\br
\terminal{N O P Q R S T U V W X Y Z _}
\end{bnf}
\begin{bnf}
\nontermdef{digit} \textnormal{one of}\br
\terminal{0 1 2 3 4 5 6 7 8 9}
\end{bnf}
\pnum
\indextext{name!length of}%
\indextext{name}%
\begin{note}
The character properties XID_Start and XID_Continue are described by \UAX{44} of the Unicode Standard.
\begin{footnote}
On systems in which linkers cannot accept extended
characters, an encoding of the \grammarterm{universal-character-name} can be used in
forming valid external identifiers. For example, some otherwise unused
character or sequence of characters can be used to encode the
\tcode{\textbackslash u} in a \grammarterm{universal-character-name}. Extended
characters can produce a long external identifier, but \Cpp{} does not
place a translation limit on significant characters for external
identifiers.
\end{footnote}
\end{note}
The program is ill-formed
if an \grammarterm{identifier} does not conform to
Normalization Form C as specified in the Unicode Standard.
\begin{note}
Identifiers are case-sensitive.
\end{note}
\begin{note}
\ref{uaxid} compares the requirements of \UAX{31} of the Unicode Standard
with the \Cpp{} rules for identifiers.
\end{note}
\begin{note}
In translation phase 4,
\grammarterm{identifier} also includes
those \grammarterm{preprocessing-token}s\iref{lex.pptoken}
differentiated as keywords\iref{lex.key}
in the later translation phase 7\iref{lex.token}.
\end{note}
\pnum
\indextext{\idxcode{import}}%
\indextext{\idxcode{final}}%
\indextext{\idxcode{module}}%
\indextext{\idxcode{override}}%
The identifiers in \tref{lex.name.special} have a special meaning when
appearing in a certain context. When referred to in the grammar, these identifiers
are used explicitly rather than using the \grammarterm{identifier} grammar production.
Unless otherwise specified, any ambiguity as to whether a given
\grammarterm{identifier} has a special meaning is resolved to interpret the
token as a regular \grammarterm{identifier}.
\begin{multicolfloattable}{Identifiers with special meaning}{lex.name.special}
{llllll}
\keyword{final} \\
\columnbreak
\keyword{import} \\
\columnbreak
\keyword{module} \\
\columnbreak
\keyword{override} \\
\columnbreak
\keyword{post} \\
\columnbreak
\keyword{pre} \\
\end{multicolfloattable}
\pnum
\begin{note}
Identifiers with special meaning
cannot be used as macro names\iref{cpp.replace.general}.