std-c23:

std-c23  ::= preprocessing-file? external-declaration+

no references


token:

token    ::= keyword
           | identifier
           | constant
           | string-literal
           | punctuator

no references


preprocessing-token:

preprocessing-token
         ::= header-name
           | identifier
           | '.'? digit ( identifier-continue | "'" ( digit | nondigit ) | ( 'e' | 'E' | 'p' | 'P' ) sign | '.' )*
           | character-constant
           | string-literal
           | punctuator
           | 'each universal-character-name that cannot be one of the above'
           | 'each non-white-space character that cannot be one of the above'

referenced by:


keyword:

keyword  ::= 'alignas'
           | 'alignof'
           | '_Atomic'
           | 'auto'
           | '_BitInt'
           | 'bool'
           | 'break'
           | 'case'
           | 'char'
           | '_Complex'
           | 'const'
           | 'constexpr'
           | 'continue'
           | '_Decimal128'
           | '_Decimal32'
           | '_Decimal64'
           | 'default'
           | 'do'
           | 'double'
           | 'else'
           | 'enum'
           | 'extern'
           | 'false'
           | 'float'
           | 'for'
           | '_Generic'
           | 'goto'
           | 'if'
           | '_Imaginary'
           | 'inline'
           | 'int'
           | 'long'
           | '_Noreturn'
           | 'nullptr'
           | 'register'
           | 'restrict'
           | 'return'
           | 'short'
           | 'signed'
           | 'sizeof'
           | 'static'
           | 'static_assert'
           | 'struct'
           | 'switch'
           | 'thread_local'
           | 'true'
           | 'typedef'
           | 'typeof'
           | 'typeof_unqual'
           | 'union'
           | 'unsigned'
           | 'void'
           | 'volatile'
           | 'while'

referenced by:


identifier:

identifier
         ::= identifier-startidentifier-continue*

referenced by:


identifier-start:

identifier-start
         ::= nondigit
           | 'XID_Start character'
           | 'universal-character-name of class XID_Start'

referenced by:


identifier-continue:

identifier-continue
         ::= digit
           | nondigit
           | 'XID_Continue character'
           | 'universal-character-name of class XID_Continue'

referenced by:


nondigit:

nondigit ::= [A-Za-z_]

referenced by:


digit:

digit    ::= [0-9]

referenced by:


universal-character-name:

universal-character-name
         ::= ( '\u' | '\U' hex-quad ) hex-quad

referenced by:


hex-quad:

hex-quad ::= hexadecimal-digithexadecimal-digithexadecimal-digithexadecimal-digit

referenced by:


constant:

constant ::= integer-constant
           | floating-constant
           | enumeration-constant
           | character-constant
           | predefined-constant

referenced by:


integer-constant:

integer-constant
         ::= ( nonzero-digit ( "'"? digit )* | octal-constant | hexadecimal-constant | binary-prefixbinary-digit ( "'"? binary-digit )* ) integer-suffix?

referenced by:


octal-constant:

octal-constant
         ::= '0' octal-constant "'"? octal-digit

referenced by:


hexadecimal-constant:

hexadecimal-constant
         ::= hexadecimal-prefixhexadecimal-digit-sequence

referenced by:


hexadecimal-prefix:

hexadecimal-prefix
         ::= '0x'
           | '0X'

referenced by:


binary-prefix:

binary-prefix
         ::= '0b'
           | '0B'

referenced by:


nonzero-digit:

nonzero-digit
         ::= [1-9]

referenced by:


octal-digit:

octal-digit
         ::= [0-7]

referenced by:


hexadecimal-digit-sequence:

hexadecimal-digit-sequence
         ::= hexadecimal-digit ( "'"? hexadecimal-digit )*

referenced by:


hexadecimal-digit:

hexadecimal-digit
         ::= [A-Fa-f0-9]

referenced by:


binary-digit:

binary-digit
         ::= [0-1]

referenced by:


integer-suffix:

integer-suffix
         ::= unsigned-suffix ( long-suffix | long-long-suffix | bit-precise-int-suffix )?
           | ( long-suffix | long-long-suffix | bit-precise-int-suffix ) unsigned-suffix?

referenced by:


bit-precise-int-suffix:

bit-precise-int-suffix
         ::= 'wb'
           | 'WB'

referenced by:


unsigned-suffix:

unsigned-suffix
         ::= 'u'
           | 'U'

referenced by:


long-suffix:

long-suffix
         ::= 'l'
           | 'L'

referenced by:


long-long-suffix:

long-long-suffix
         ::= 'll'
           | 'LL'

referenced by:


floating-constant:

floating-constant
         ::= decimal-floating-constant
           | hexadecimal-floating-constant

referenced by:


decimal-floating-constant:

decimal-floating-constant
         ::= ( fractional-constantexponent-part? | digit-sequenceexponent-part ) floating-suffix?

referenced by:


hexadecimal-floating-constant:

hexadecimal-floating-constant
         ::= hexadecimal-prefix ( hexadecimal-fractional-constant | hexadecimal-digit-sequence ) binary-exponent-partfloating-suffix?

referenced by:


fractional-constant:

fractional-constant
         ::= digit-sequence? '.' digit-sequence
           | digit-sequence '.'

referenced by:


exponent-part:

exponent-part
         ::= [Ee] sign? digit-sequence

referenced by:


sign:

sign     ::= [+#x2D]

referenced by:


digit-sequence:

digit-sequence
         ::= digit ( "'"? digit )*

referenced by:


hexadecimal-fractional-constant:

hexadecimal-fractional-constant
         ::= hexadecimal-digit-sequence? '.' hexadecimal-digit-sequence
           | hexadecimal-digit-sequence '.'

referenced by:


binary-exponent-part:

binary-exponent-part
         ::= [Pp] sign? digit-sequence

referenced by:


floating-suffix:

floating-suffix
         ::= 'fl'
           | 'FL'
           | 'df'
           | 'dd'
           | 'dl'
           | 'DF'
           | 'DD'
           | 'DL'

referenced by:


enumeration-constant:

enumeration-constant
         ::= identifier

referenced by:


character-constant:

character-constant
         ::= encoding-prefix? "'" c-char+ "'"

referenced by:


encoding-prefix:

encoding-prefix
         ::= 'u8'
           | 'u'
           | 'U'
           | 'L'

referenced by:


c-char:

c-char   ::= "any member of the source character set except the single-quote ', backslash \, or new-line character"
           | escape-sequence

referenced by:


escape-sequence:

escape-sequence
         ::= simple-escape-sequence
           | octal-escape-sequence
           | '\x' hexadecimal-digit+
           | universal-character-name

referenced by:


simple-escape-sequence:

simple-escape-sequence
         ::= "\'"
           | '\"'
           | '\?'
           | '\\'
           | '\a'
           | '\b'
           | '\f'
           | '\n'
           | '\r'
           | '\t'
           | '\v'

referenced by:


octal-escape-sequence:

octal-escape-sequence
         ::= '\' octal-digit ( octal-digitoctal-digit? )?

referenced by:


predefined-constant:

predefined-constant
         ::= 'false'
           | 'true'
           | 'nullptr'

referenced by:


string-literal:

string-literal
         ::= encoding-prefix? '"' s-char* '"'

referenced by:


s-char:

s-char   ::= 'any member of the source character set except the double-quote ", backslash \, or new-line character'
           | escape-sequence

referenced by:


punctuator:

punctuator
         ::= '['
           | ']'
           | '('
           | ')'
           | '{'
           | '}'
           | '.'
           | '->'
           | '++'
           | '--'
           | '&'
           | '*'
           | '+'
           | '-'
           | '~'
           | '!'
           | '/'
           | '%'
           | '<<'
           | '>>'
           | '<'
           | '>'
           | '<='
           | '>='
           | '=='
           | '!='
           | '^'
           | '|'
           | '&&'
           | '||'
           | '?'
           | ':'
           | '::'
           | ';'
           | '...'
           | '='
           | '*='
           | '/='
           | '%='
           | '+='
           | '-='
           | '<<='
           | '>>='
           | '&='
           | '^='
           | '|='
           | ','
           | '#'
           | '##'
           | '<:'
           | ':>'
           | '<%'
           | '%>'
           | '%:'
           | '%:%:'

referenced by:


header-name:

header-name
         ::= '<' 'any member of the source character set except the new-line character and >'+ '>'
           | '"' 'any member of the source character set except the new-line character and '+ '"'

referenced by:


primary-expression:

primary-expression
         ::= identifier
           | constant
           | string-literal
           | '(' expression ')'
           | generic-selection

referenced by:


generic-selection:

generic-selection
         ::= '_Generic' '(' assignment-expression ( ',' generic-association )+ ')'

referenced by:


generic-association:

generic-association
         ::= ( type-name | default ) ':' assignment-expression

referenced by:


compound-literal:

compound-literal
         ::= '(' storage-class-specifier* type-name ')' braced-initializer

referenced by:


unary-expression:

unary-expression
         ::= ( '++' | '--' | 'sizeof' )* ( ( primary-expression | compound-literal ) ( '[' expression ']' | '(' ( assignment-expression ( ',' assignment-expression )* )? ')' | ( '.' | '->' ) identifier | '++' | '--' )* | unary-operatorcast-expression | ( 'sizeof' | 'alignof' ) '(' type-name ')' )

referenced by:


unary-operator:

unary-operator
         ::= '&'
           | '*'
           | '+'
           | '-'
           | '~'
           | '!'

referenced by:


cast-expression:

cast-expression
         ::= ( '(' type-name ')' )* unary-expression

referenced by:


multiplicative-expression:

multiplicative-expression
         ::= cast-expression ( ( '*' | '/' | '%' ) cast-expression )*

referenced by:


additive-expression:

additive-expression
         ::= multiplicative-expression ( ( '+' | '-' ) multiplicative-expression )*

referenced by:


shift-expression:

shift-expression
         ::= additive-expression ( ( '<<' | '>>' ) additive-expression )*

referenced by:


relational-expression:

relational-expression
         ::= shift-expression ( ( '<' | '>' | '<=' | '>=' ) shift-expression )*

referenced by:


equality-expression:

equality-expression
         ::= relational-expression ( ( '==' | '!=' ) relational-expression )*

referenced by:


AND-expression:

AND-expression
         ::= equality-expression ( '&' equality-expression )*

referenced by:


exclusive-OR-expression:

exclusive-OR-expression
         ::= AND-expression ( '^' AND-expression )*

referenced by:


inclusive-OR-expression:

inclusive-OR-expression
         ::= exclusive-OR-expression ( '|' exclusive-OR-expression )*

referenced by:


logical-AND-expression:

logical-AND-expression
         ::= inclusive-OR-expression ( '&&' inclusive-OR-expression )*

referenced by:


logical-OR-expression:

logical-OR-expression
         ::= logical-AND-expression ( '||' logical-AND-expression )*

referenced by:


conditional-expression:

conditional-expression
         ::= logical-OR-expression ( '?' expression ':' logical-OR-expression )*

referenced by:


assignment-expression:

assignment-expression
         ::= ( unary-expressionassignment-operator )* conditional-expression

referenced by:


assignment-operator:

assignment-operator
         ::= '='
           | '*='
           | '/='
           | '%='
           | '+='
           | '-='
           | '<<='
           | '>>='
           | '&='
           | '^='
           | '|='

referenced by:


expression:

expression
         ::= assignment-expression ( ',' assignment-expression )*

referenced by:


constant-expression:

constant-expression
         ::= conditional-expression

referenced by:


declaration:

declaration
         ::= ( declaration-specifiersinit-declarator-list? | attribute-specifier-sequencedeclaration-specifiersinit-declarator-list ) ';'
           | static_assert-declaration
           | attribute-declaration

referenced by:


declaration-specifiers:

declaration-specifiers
         ::= declaration-specifier+ attribute-specifier-sequence?

referenced by:


declaration-specifier:

declaration-specifier
         ::= storage-class-specifier
           | type-specifier-qualifier
           | function-specifier

referenced by:


init-declarator-list:

init-declarator-list
         ::= init-declarator ( ',' init-declarator )*

referenced by:


init-declarator:

init-declarator
         ::= declarator ( '=' initializer )?

referenced by:


attribute-declaration:

attribute-declaration
         ::= attribute-specifier-sequence ';'

referenced by:


storage-class-specifier:

storage-class-specifier
         ::= 'auto'
           | 'constexpr'
           | 'extern'
           | 'register'
           | 'static'
           | 'thread_local'
           | 'typedef'

referenced by:


type-specifier:

type-specifier
         ::= 'void'
           | 'char'
           | 'short'
           | 'int'
           | 'long'
           | 'float'
           | 'double'
           | 'signed'
           | 'unsigned'
           | '_BitInt' '(' constant-expression ')'
           | 'bool'
           | '_Complex'
           | '_Decimal32'
           | '_Decimal64'
           | '_Decimal128'
           | atomic-type-specifier
           | struct-or-union-specifier
           | enum-specifier
           | typedef-name
           | typeof-specifier

referenced by:


struct-or-union-specifier:

struct-or-union-specifier
         ::= struct-or-unionattribute-specifier-sequence? ( identifier? '{' member-declaration+ '}' | identifier )

referenced by:


struct-or-union:

struct-or-union
         ::= 'struct'
           | 'union'

referenced by:


member-declaration:

member-declaration
         ::= attribute-specifier-sequence? specifier-qualifier-list ( member-declarator ( ',' member-declarator )* )? ';'
           | static_assert-declaration

referenced by:


specifier-qualifier-list:

specifier-qualifier-list
         ::= type-specifier-qualifier+ attribute-specifier-sequence?

referenced by:


type-specifier-qualifier:

type-specifier-qualifier
         ::= type-specifier
           | type-qualifier
           | alignment-specifier

referenced by:


member-declarator:

member-declarator
         ::= declarator
           | declarator? ':' constant-expression

referenced by:


enum-specifier:

enum-specifier
         ::= enum ( attribute-specifier-sequence? identifier? enum-type-specifier? '{' enumerator ( ',' enumerator )* ','? '}' | identifierenum-type-specifier? )

referenced by:


enumerator:

enumerator
         ::= enumeration-constantattribute-specifier-sequence? ( '=' constant-expression )?

referenced by:


enum-type-specifier:

enum-type-specifier
         ::= ':' specifier-qualifier-list

referenced by:


atomic-type-specifier:

atomic-type-specifier
         ::= '_Atomic' '(' type-name ')'

referenced by:


typeof-specifier:

typeof-specifier
         ::= ( 'typeof' | 'typeof_unqual' ) '(' typeof-specifier-argument ')'

referenced by:


typeof-specifier-argument:

typeof-specifier-argument
         ::= expression
           | type-name

referenced by:


type-qualifier:

type-qualifier
         ::= 'const'
           | 'restrict'
           | 'volatile'
           | '_Atomic'

referenced by:


function-specifier:

function-specifier
         ::= 'inline'
           | '_Noreturn'

referenced by:


alignment-specifier:

alignment-specifier
         ::= 'alignas' '(' ( type-name | constant-expression ) ')'

referenced by:


declarator:

declarator
         ::= pointer? direct-declarator

referenced by:


direct-declarator:

direct-declarator
         ::= ( identifier | array-declarator | function-declarator ) attribute-specifier-sequence?
           | '(' declarator ')'

referenced by:


array-declarator:

array-declarator
         ::= direct-declarator '[' ( type-qualifier-list? assignment-expression? | ( statictype-qualifier-list? | type-qualifier-liststatic ) assignment-expression | type-qualifier-list* ) ']'

referenced by:


function-declarator:

function-declarator
         ::= direct-declarator '(' parameter-type-list? ')'

referenced by:


pointer:

pointer  ::= ( '*' attribute-specifier-sequence? type-qualifier-list? )+

referenced by:


type-qualifier-list:

type-qualifier-list
         ::= type-qualifier+

referenced by:


parameter-type-list:

parameter-type-list
         ::= parameter-declaration ( ',' parameter-declaration )* ( ',' '...' )?
           | '...'

referenced by:


parameter-declaration:

parameter-declaration
         ::= attribute-specifier-sequence? declaration-specifiers ( declarator | abstract-declarator )?

referenced by:


type-name:

type-name
         ::= specifier-qualifier-listabstract-declarator?

referenced by:


abstract-declarator:

abstract-declarator
         ::= pointer
           | pointer? direct-abstract-declarator

referenced by:


direct-abstract-declarator:

direct-abstract-declarator
         ::= '(' abstract-declarator ')'
           | ( array-abstract-declarator | function-abstract-declarator ) attribute-specifier-sequence?

referenced by:


array-abstract-declarator:

array-abstract-declarator
         ::= direct-abstract-declarator? '[' ( type-qualifier-list? assignment-expression? | ( statictype-qualifier-list? | type-qualifier-liststatic ) assignment-expression | '*' ) ']'

referenced by:


function-abstract-declarator:

function-abstract-declarator
         ::= direct-abstract-declarator? '(' parameter-type-list? ')'

referenced by:


typedef-name:

typedef-name
         ::= identifier

referenced by:


braced-initializer:

braced-initializer
         ::= '{' ( designation? initializer ( ',' designation? initializer )* ','? )? '}'

referenced by:


initializer:

initializer
         ::= assignment-expression
           | braced-initializer

referenced by:


designation:

designation
         ::= designator+ '='

referenced by:


designator:

designator
         ::= '[' constant-expression ']'
           | '.' identifier

referenced by:


static_assert-declaration:

static_assert-declaration
         ::= 'static_assert' '(' constant-expression ( ',' string-literal )? ')' ';'

referenced by:


attribute-specifier-sequence:

attribute-specifier-sequence
         ::= attribute-specifier+

referenced by:


attribute-specifier:

attribute-specifier
         ::= '[' '[' attribute? ( ',' attribute? )* ']' ']'

referenced by:


attribute:

attribute
         ::= attribute-tokenattribute-argument-clause?

referenced by:


attribute-token:

attribute-token
         ::= standard-attribute
           | attribute-prefixed-token

referenced by:


standard-attribute:

standard-attribute
         ::= identifier

referenced by:


attribute-prefixed-token:

attribute-prefixed-token
         ::= attribute-prefix '::' identifier

referenced by:


attribute-prefix:

attribute-prefix
         ::= identifier

referenced by:


attribute-argument-clause:

attribute-argument-clause
         ::= '(' balanced-token-sequence? ')'

referenced by:


balanced-token-sequence:

balanced-token-sequence
         ::= balanced-token+

referenced by:


balanced-token:

balanced-token
         ::= '(' balanced-token-sequence? ')'
           | '[' balanced-token-sequence? ']'
           | '{' balanced-token-sequence? '}'
           | 'any token other than a parenthesis, a bracket, or a brace'

referenced by:


statement:

statement
         ::= labeled-statement
           | unlabeled-statement

referenced by:


unlabeled-statement:

unlabeled-statement
         ::= expression-statement
           | attribute-specifier-sequence? ( primary-block | jump-statement )

referenced by:


primary-block:

primary-block
         ::= compound-statement
           | selection-statement
           | iteration-statement

referenced by:


secondary-block:

secondary-block
         ::= statement

referenced by:


label:

label    ::= attribute-specifier-sequence? ( identifier | caseconstant-expression | default ) ':'

referenced by:


labeled-statement:

labeled-statement
         ::= labelstatement

referenced by:


compound-statement:

compound-statement
         ::= '{' block-item* '}'

referenced by:


block-item:

block-item
         ::= declaration
           | unlabeled-statement
           | label

referenced by:


expression-statement:

expression-statement
         ::= ( attribute-specifier-sequence? expression )? ';'

referenced by:


selection-statement:

selection-statement
         ::= ( 'if' '(' expression ')' ( secondary-block 'else' )? | 'switch' '(' expression ')' ) secondary-block

referenced by:


iteration-statement:

iteration-statement
         ::= ( 'while' '(' expression | 'for' '(' ( expression? ';' | declaration ) expression? ';' expression? ) ')' secondary-block
           | 'do' secondary-block 'while' '(' expression ')' ';'

referenced by:


jump-statement:

jump-statement
         ::= ( 'goto' identifier | 'continue' | 'break' | 'return' expression? ) ';'

referenced by:


external-declaration:

external-declaration
         ::= function-definition
           | declaration

referenced by:


function-definition:

function-definition
         ::= attribute-specifier-sequence? declaration-specifiersdeclaratorfunction-body

referenced by:


function-body:

function-body
         ::= compound-statement

referenced by:


preprocessing-file:

preprocessing-file
         ::= group?

referenced by:


group:

group    ::= group-part+

referenced by:


group-part:

group-part
         ::= if-section
           | control-line
           | text-line
           | '#' non-directive

referenced by:


if-section:

if-section
         ::= if-groupelif-group* else-group? endif-line

referenced by:


if-group:

if-group ::= '#' ( 'if' constant-expression | ( 'ifdef' | 'ifndef' ) identifier ) 'the new-line character' group?

referenced by:


elif-group:

elif-group
         ::= '#' ( 'elif' constant-expression | ( 'elifdef' | 'elifndef' ) identifier ) 'the new-line character' group?

referenced by:


else-group:

else-group
         ::= '#' 'else' 'the new-line character' group?

referenced by:


endif-line:

endif-line
         ::= '#' 'endif' 'the new-line character'

referenced by:


control-line:

control-line
         ::= '#' ( ( 'include' | 'embed' | 'line' ) pp-tokens | 'undef' identifier | ( 'error' | 'warning' | 'pragma' ) pp-tokens? | 'define' identifier ( "a '(' character not immediately preceded by white space" ( identifier-list | ( identifier-list ',' )? '...' )? ')' )? replacement-list )? 'the new-line character'

referenced by:


text-line:

text-line
         ::= pp-tokens? 'the new-line character'

referenced by:


non-directive:

non-directive
         ::= pp-tokens 'the new-line character'

referenced by:


replacement-list:

replacement-list
         ::= pp-tokens?

referenced by:


pp-tokens:

pp-tokens
         ::= preprocessing-token+

referenced by:


identifier-list:

identifier-list
         ::= identifier ( ',' identifier )*

referenced by:


pp-parameter:

pp-parameter
         ::= pp-parameter-namepp-parameter-clause?

referenced by:


pp-parameter-name:

pp-parameter-name
         ::= pp-standard-parameter
           | pp-prefixed-parameter

referenced by:


pp-standard-parameter:

pp-standard-parameter
         ::= identifier

referenced by:


pp-prefixed-parameter:

pp-prefixed-parameter
         ::= identifier '::' identifier

referenced by:


pp-parameter-clause:

pp-parameter-clause
         ::= '(' pp-balanced-token-sequence? ')'

referenced by:


pp-balanced-token-sequence:

pp-balanced-token-sequence
         ::= pp-balanced-token+

referenced by:


pp-balanced-token:

pp-balanced-token
         ::= '(' pp-balanced-token-sequence? ')'
           | '[' pp-balanced-token-sequence? ']'
           | '{' pp-balanced-token-sequence? '}'
           | 'any pp-token other than a parenthesis, a bracket, or a brace'

referenced by:


defined-macro-expression:

defined-macro-expression
         ::= 'defined' ( identifier | '(' identifier ')' )

no references


header-name-tokens:

header-name-tokens
         ::= string-literal
           | '<' 'any preprocessing-token other than >'+ '>'

referenced by:


has-include-expression:

has-include-expression
         ::= '__has_include' '(' ( header-name | header-name-tokens ) ')'

no references


has-embed-expression:

has-embed-expression
         ::= '__has_embed' '(' ( header-namepp-parameter* | header-name-tokenspp-balanced-token-sequence? ) ')'

no references


has-c-attribute-express:

has-c-attribute-express
         ::= '__has_c_attribute' '(' pp-tokens ')'

no references


va-opt-replacement:

va-opt-replacement
         ::= '__VA_OPT__' '(' pp-tokens? ')'

no references


standard-pragma:

standard-pragma
         ::= '#' 'pragma' 'STDC' ( ( 'FP_CONTRACT' | 'FENV_ACCESS' | 'CX_LIMITED_RANGE' ) on-off-switch | 'FENV_DEC_ROUND' dec-direction | 'FENV_ROUND' direction )

no references


on-off-switch:

on-off-switch
         ::= 'ON'
           | 'OFF'
           | 'DEFAULT'

referenced by:


direction:

direction
         ::= 'FE_DOWNWARD'
           | 'FE_TONEAREST'
           | 'FE_TONEARESTFROMZERO'
           | 'FE_TOWARDZERO'
           | 'FE_UPWARD'
           | 'FE_DYNAMIC'

referenced by:


dec-direction:

dec-direction
         ::= 'FE_DEC_DOWNWARD'
           | 'FE_DEC_TONEAREST'
           | 'FE_DEC_TONEARESTFROMZERO'
           | 'FE_DEC_TOWARDZERO'
           | 'FE_DEC_UPWARD'
           | 'FE_DEC_DYNAMIC'

referenced by:


n-char-sequence:

n-char-sequence
         ::= ( digit | nondigit )+

no references


n-wchar-sequence:

n-wchar-sequence
         ::= ( digit | nondigit )+

no references


d-char-sequence:

d-char-sequence
         ::= ( digit | nondigit )+

no references


d-wchar-sequence:

d-wchar-sequence
         ::= ( digit | nondigit )+

no references