tree-sitter-cuda.ebnf

//
// From tree-sitter-cuda/src/grammar.json
//
//
// EBNF to generate railroad diagram at 
//      (IPV6) https://www.bottlecaps.de/rr/ui
//      (IPV4) https://rr.red-dove.com/ui
//

translation_unit ::=
	 _top_level_item*

_top_level_item ::=
	 function_definition
	| linkage_specification
	| declaration
	| _top_level_statement
	| attributed_statement
	| type_definition
	| _empty_declaration
	| preproc_if
	| preproc_ifdef
	| preproc_include
	| preproc_def
	| preproc_function_def
	| preproc_call
	| namespace_definition
	| concept_definition
	| namespace_alias_definition
	| using_declaration
	| alias_declaration
	| static_assert_declaration
	| template_declaration
	| template_instantiation
	| constructor_or_destructor_definition
	| operator_cast_definition
	| operator_cast_declaration

_block_item ::=
	 function_definition
	| linkage_specification
	| declaration
	| _statement
	| attributed_statement
	| type_definition
	| _empty_declaration
	| preproc_if
	| preproc_ifdef
	| preproc_include
	| preproc_def
	| preproc_function_def
	| preproc_call
	| namespace_definition
	| concept_definition
	| namespace_alias_definition
	| using_declaration
	| alias_declaration
	| static_assert_declaration
	| template_declaration
	| template_instantiation
	| constructor_or_destructor_definition
	| operator_cast_definition
	| operator_cast_declaration

preproc_include ::=
	 '#'[ #x09]*'include' ( string_literal | system_lib_string | identifier | preproc_call_expression ) '#x0D'?'#x0A'

preproc_def ::=
	 '#'[ #x09]*'define' identifier preproc_arg? '#x0D'?'#x0A'

preproc_function_def ::=
	 '#'[ #x09]*'define' identifier preproc_params preproc_arg? '#x0D'?'#x0A'

preproc_params ::=
	 '(' ( ( identifier | '...' ) ( ',' ( identifier | '...' ) )* )? ')'

preproc_call ::=
	 preproc_directive preproc_arg? '#x0D'?'#x0A'

preproc_if ::=
	 '#'[ #x09]*'if' _preproc_expression '\n'  _block_item* ( preproc_else | preproc_elif )? '#'[ #x09]*'endif'

preproc_ifdef ::=
	 ( '#'[ #x09]*'ifdef' | '#'[ #x09]*'ifndef' ) identifier _block_item* ( preproc_else | preproc_elif | preproc_elifdef )? '#'[ #x09]*'endif'

preproc_else ::=
	 '#'[ #x09]*'else' _block_item*

preproc_elif ::=
	 '#'[ #x09]*'elif' _preproc_expression '\n'  _block_item* ( preproc_else | preproc_elif )?

preproc_elifdef ::=
	 ( '#'[ #x09]*'elifdef' | '#'[ #x09]*'elifndef' ) identifier _block_item* ( preproc_else | preproc_elif )?

preproc_if_in_field_declaration_list ::=
	 '#'[ #x09]*'if' _preproc_expression '\n'  _field_declaration_list_item* ( preproc_else_in_field_declaration_list | preproc_elif_in_field_declaration_list )? '#'[ #x09]*'endif'

preproc_ifdef_in_field_declaration_list ::=
	 ( '#'[ #x09]*'ifdef' | '#'[ #x09]*'ifndef' ) identifier _field_declaration_list_item* ( preproc_else_in_field_declaration_list | preproc_elif_in_field_declaration_list | preproc_elifdef )? '#'[ #x09]*'endif'

preproc_else_in_field_declaration_list ::=
	 '#'[ #x09]*'else' _field_declaration_list_item*

preproc_elif_in_field_declaration_list ::=
	 '#'[ #x09]*'elif' _preproc_expression '\n'  _field_declaration_list_item* ( preproc_else_in_field_declaration_list | preproc_elif_in_field_declaration_list )?

preproc_elifdef_in_field_declaration_list ::=
	 ( '#'[ #x09]*'elifdef' | '#'[ #x09]*'elifndef' ) identifier _field_declaration_list_item* ( preproc_else_in_field_declaration_list | preproc_elif_in_field_declaration_list )?

preproc_arg ::=
	 '\S'([^/#x0A]|'\/'[^*]|'\#x0D'?'#x0A')*

preproc_directive ::=
	 '#'[ #x09]*[a-zA-Z0-9][a-zA-Z_]*

_preproc_expression ::=
	 identifier
	| preproc_call_expression
	| number_literal
	| char_literal
	| preproc_defined
	| preproc_unary_expression
	| preproc_binary_expression
	| preproc_parenthesized_expression

preproc_parenthesized_expression ::=
	 '(' _preproc_expression ')'

preproc_defined ::=
	 'defined' '(' identifier ')'
	| 'defined' identifier

preproc_unary_expression ::=
	 ( '!' | '~' | '-' | '+' ) _preproc_expression

preproc_call_expression ::=
	 identifier preproc_argument_list

preproc_argument_list ::=
	 '(' ( _preproc_expression ( ',' _preproc_expression )* )? ')'

preproc_binary_expression ::=
	 _preproc_expression '+' _preproc_expression
	| _preproc_expression '-' _preproc_expression
	| _preproc_expression '*' _preproc_expression
	| _preproc_expression '/' _preproc_expression
	| _preproc_expression '%' _preproc_expression
	| _preproc_expression '||' _preproc_expression
	| _preproc_expression '&&' _preproc_expression
	| _preproc_expression '|' _preproc_expression
	| _preproc_expression '^' _preproc_expression
	| _preproc_expression '&' _preproc_expression
	| _preproc_expression '==' _preproc_expression
	| _preproc_expression '!=' _preproc_expression
	| _preproc_expression '>' _preproc_expression
	| _preproc_expression '>=' _preproc_expression
	| _preproc_expression '<=' _preproc_expression
	| _preproc_expression '<' _preproc_expression
	| _preproc_expression '<<' _preproc_expression
	| _preproc_expression '>>' _preproc_expression

function_definition ::=
	 ms_call_modifier? _declaration_specifiers _declarator ( compound_statement | try_statement )

_old_style_function_definition ::=
	 ms_call_modifier? _declaration_specifiers _old_style_function_declarator declaration* compound_statement

declaration ::=
	 _declaration_specifiers _declaration_declarator ';'

_declaration_declarator ::=
	 ( _declarator gnu_asm_expression? | init_declarator ) ( ',' ( _declarator gnu_asm_expression? | init_declarator ) )*

type_definition ::=
	 '__extension__'? 'typedef' _type_definition_type _type_definition_declarators attribute_specifier* ';'

_type_definition_type ::=
	 type_qualifier* _type_specifier type_qualifier*

_type_definition_declarators ::=
	 _type_declarator ( ',' _type_declarator )*

_declaration_modifiers ::=
	 launch_bounds
	| '__device__'
	| '__host__'
	| '__global__'
	| '__forceinline__'
	| '__noinline__'
	| storage_class_specifier
	| type_qualifier
	| attribute_specifier
	| attribute_declaration
	| ms_declspec_modifier
	| virtual
	| alignas_specifier

_declaration_specifiers ::=
	 _declaration_modifiers* _type_specifier _declaration_modifiers*

linkage_specification ::=
	 'extern' string_literal ( function_definition | declaration | declaration_list )

attribute_specifier ::=
	 '__attribute__' '(' argument_list ')'

attribute ::=
	 ( identifier '::' )? identifier argument_list?

attribute_declaration ::=
	 '[[' attribute ( ',' attribute )* ']]'

ms_declspec_modifier ::=
	 '__declspec' '(' identifier ')'

ms_based_modifier ::=
	 '__based' argument_list

ms_call_modifier ::=
	 '__cdecl'
	| '__clrcall'
	| '__stdcall'
	| '__fastcall'
	| '__thiscall'
	| '__vectorcall'

ms_restrict_modifier ::=
	 '__restrict'

ms_unsigned_ptr_modifier ::=
	 '__uptr'

ms_signed_ptr_modifier ::=
	 '__sptr'

ms_unaligned_ptr_modifier ::=
	 '_unaligned'
	| '__unaligned'

ms_pointer_modifier ::=
	 ms_unaligned_ptr_modifier
	| ms_restrict_modifier
	| ms_unsigned_ptr_modifier
	| ms_signed_ptr_modifier

declaration_list ::=
	 '{' _block_item* '}'

_declarator ::=
	 attributed_declarator
	| pointer_declarator
	| function_declarator
	| array_declarator
	| parenthesized_declarator
	| identifier
	| reference_declarator
	| qualified_identifier
	| template_function
	| operator_name
	| destructor_name
	| structured_binding_declarator

_field_declarator ::=
	 attributed_field_declarator
	| pointer_field_declarator
	| function_field_declarator
	| array_field_declarator
	| parenthesized_field_declarator
	| _field_identifier
	| reference_field_declarator
	| template_method
	| operator_name

_type_declarator ::=
	 attributed_type_declarator
	| pointer_type_declarator
	| function_type_declarator
	| array_type_declarator
	| parenthesized_type_declarator
	| _type_identifier
	| ( 'signed' | 'unsigned' | 'long' | 'short' )
	| primitive_type

_abstract_declarator ::=
	 abstract_pointer_declarator
	| abstract_function_declarator
	| abstract_array_declarator
	| abstract_parenthesized_declarator
	| abstract_reference_declarator

parenthesized_declarator ::=
	 '(' _declarator ')'

parenthesized_field_declarator ::=
	 '(' _field_declarator ')'

parenthesized_type_declarator ::=
	 '(' _type_declarator ')'

abstract_parenthesized_declarator ::=
	 '(' _abstract_declarator ')'

attributed_declarator ::=
	 _declarator attribute_declaration+

attributed_field_declarator ::=
	 _field_declarator attribute_declaration+

attributed_type_declarator ::=
	 _type_declarator attribute_declaration+

pointer_declarator ::=
	 ms_based_modifier? '*' ms_pointer_modifier* type_qualifier* _declarator

pointer_field_declarator ::=
	 ms_based_modifier? '*' ms_pointer_modifier* type_qualifier* _field_declarator

pointer_type_declarator ::=
	 ms_based_modifier? '*' ms_pointer_modifier* type_qualifier* _type_declarator

abstract_pointer_declarator ::=
	 '*' type_qualifier* _abstract_declarator?

function_declarator ::=
	 _declarator _function_declarator_seq

function_field_declarator ::=
	 _field_declarator _function_declarator_seq

function_type_declarator ::=
	 _type_declarator parameter_list

abstract_function_declarator ::=
	 _abstract_declarator? _function_declarator_seq

_old_style_function_declarator ::=
	 _declarator _old_style_parameter_list

array_declarator ::=
	 _declarator '[' type_qualifier* ( _expression | '*' )? ']'

array_field_declarator ::=
	 _field_declarator '[' type_qualifier* ( _expression | '*' )? ']'

array_type_declarator ::=
	 _type_declarator '[' type_qualifier* ( _expression | '*' )? ']'

abstract_array_declarator ::=
	 _abstract_declarator? '[' type_qualifier* ( _expression | '*' )? ']'

init_declarator ::=
	 _declarator '=' ( initializer_list | _expression )
	| _declarator ( argument_list | initializer_list )

compound_statement ::=
	 '{' _block_item* '}'

storage_class_specifier ::=
	 'extern'
	| 'static'
	| 'register'
	| 'inline'
	| '__inline'
	| '__inline__'
	| '__forceinline'
	| 'thread_local'
	| '__thread'
	| 'thread_local'

type_qualifier ::=
	 'const'
	| 'constexpr'
	| 'volatile'
	| 'restrict'
	| '__restrict__'
	| '__extension__'
	| '_Atomic'
	| '_Noreturn'
	| 'noreturn'
	| 'mutable'
	| 'constinit'
	| 'consteval'
	| '__shared__'
	| '__global__'
	| '__local__'
	| '__constant__'
	| '__grid_constant__'

_type_specifier ::=
	 struct_specifier
	| union_specifier
	| enum_specifier
	| class_specifier
	| sized_type_specifier
	| primitive_type
	| template_type
	| dependent_type
	| placeholder_type_specifier
	| decltype
	| qualified_type_identifier | _type_identifier

sized_type_specifier ::=
	 ( 'signed' | 'unsigned' | 'long' | 'short' )+ ( _type_identifier | primitive_type )?

primitive_type ::=
	 ( 'bool' | 'char' | 'int' | 'float' | 'double' | 'void' | 'size_t' | 'ssize_t' | 'ptrdiff_t' | 'intptr_t' | 'uintptr_t' | 'charptr_t' | 'nullptr_t' | 'max_align_t' | 'int8_t' | 'int16_t' | 'int32_t' | 'int64_t' | 'uint8_t' | 'uint16_t' | 'uint32_t' | 'uint64_t' | 'char8_t' | 'char16_t' | 'char32_t' | 'char64_t' )

enum_specifier ::=
	 'enum' ( 'class' | 'struct' )? ( _class_name _enum_base_clause? enumerator_list? | enumerator_list ) attribute_specifier?

enumerator_list ::=
	 '{' ( enumerator ( ',' enumerator )* )? ','? '}'

struct_specifier ::=
	 'struct' _class_declaration

union_specifier ::=
	 'union' _class_declaration

field_declaration_list ::=
	 '{' _field_declaration_list_item* '}'

_field_declaration_list_item ::=
	 field_declaration
	| preproc_def
	| preproc_function_def
	| preproc_call
	| preproc_if_in_field_declaration_list
	| preproc_ifdef_in_field_declaration_list
	| template_declaration
	| inline_method_definition
	| constructor_or_destructor_definition
	| constructor_or_destructor_declaration
	| operator_cast_definition
	| operator_cast_declaration
	| friend_declaration
	| access_specifier ':'
	| alias_declaration
	| using_declaration
	| type_definition
	| static_assert_declaration

field_declaration ::=
	 _declaration_specifiers ( _field_declarator ( bitfield_clause | initializer_list | '=' ( _expression | initializer_list ) )? ( ',' _field_declarator ( bitfield_clause | initializer_list | '=' ( _expression | initializer_list ) )? )* )? attribute_specifier? ';'

_field_declaration_declarator ::=
	 _field_declarator bitfield_clause? ( ',' _field_declarator bitfield_clause? )*

bitfield_clause ::=
	 ':' _expression

enumerator ::=
	 identifier ( '=' _expression )?

variadic_parameter ::=
	 '...'

parameter_list ::=
	 '(' ( ( parameter_declaration | optional_parameter_declaration | variadic_parameter_declaration | '...' ) ( ',' ( parameter_declaration | optional_parameter_declaration | variadic_parameter_declaration | '...' ) )* )? ')'

_old_style_parameter_list ::=
	 '(' ( ( identifier | variadic_parameter ) ( ',' ( identifier | variadic_parameter ) )* )? ')'

parameter_declaration ::=
	 _declaration_specifiers ( _declarator | _abstract_declarator )?

attributed_statement ::=
	 attribute_declaration+ _statement

_statement ::=
	 case_statement
	| _non_case_statement

_non_case_statement ::=
	 attributed_statement
	| labeled_statement
	| compound_statement
	| expression_statement
	| if_statement
	| switch_statement
	| do_statement
	| while_statement
	| for_statement
	| return_statement
	| break_statement
	| continue_statement
	| goto_statement
	| seh_try_statement
	| seh_leave_statement
	| co_return_statement
	| co_yield_statement
	| for_range_loop
	| try_statement
	| throw_statement

_top_level_statement ::=
	 case_statement
	| attributed_statement
	| labeled_statement
	| compound_statement
	| _top_level_expression_statement
	| if_statement
	| switch_statement
	| do_statement
	| while_statement
	| for_statement
	| return_statement
	| break_statement
	| continue_statement
	| goto_statement
	| co_return_statement
	| co_yield_statement
	| for_range_loop
	| try_statement
	| throw_statement

labeled_statement ::=
	 _statement_identifier ':' _statement

_top_level_expression_statement ::=
	 _expression_not_binary ';'

expression_statement ::=
	 ( _expression | comma_expression )? ';'

if_statement ::=
	 'if' 'constexpr'? condition_clause _statement else_clause?

else_clause ::=
	 'else' _statement

switch_statement ::=
	 'switch' condition_clause compound_statement

case_statement ::=
	 ( 'case' _expression | 'default' ) ':' ( _non_case_statement | declaration | type_definition )*

while_statement ::=
	 'while' condition_clause _statement

do_statement ::=
	 'do' _statement 'while' parenthesized_expression ';'

for_statement ::=
	 'for' '(' _for_statement_body ')' _statement

_for_statement_body ::=
	 ( declaration | ( _expression | comma_expression )? ';' ) ( _expression | comma_expression )? ';' ( _expression | comma_expression )?

return_statement ::=
	 ( 'return' ( _expression | comma_expression )? ';' | 'return' initializer_list ';' )

break_statement ::=
	 'break' ';'

continue_statement ::=
	 'continue' ';'

goto_statement ::=
	 'goto' _statement_identifier ';'

seh_try_statement ::=
	 '__try' compound_statement ( seh_except_clause | seh_finally_clause )

seh_except_clause ::=
	 '__except' parenthesized_expression compound_statement

seh_finally_clause ::=
	 '__finally' compound_statement

seh_leave_statement ::=
	 '__leave' ';'

_expression ::=
	 _expression_not_binary
	| binary_expression
	| kernel_call_expression

_expression_not_binary ::=
	 conditional_expression
	| assignment_expression
	| unary_expression
	| update_expression
	| cast_expression
	| pointer_expression
	| sizeof_expression
	| alignof_expression
	| offsetof_expression
	| generic_expression
	| subscript_expression
	| call_expression
	| field_expression
	| compound_literal_expression
	| identifier
	| number_literal
	| string_literal
	| true
	| false
	| null
	| concatenated_string
	| char_literal
	| parenthesized_expression
	| gnu_asm_expression
	| co_await_expression
	| requires_expression
	| requires_clause
	| template_function
	| qualified_identifier
	| new_expression
	| delete_expression
	| lambda_expression
	| parameter_pack_expansion
	| this
	| raw_string_literal
	| user_defined_literal
	| fold_expression

comma_expression ::=
	 _expression ',' ( _expression | comma_expression )

conditional_expression ::=
	 _expression '?' _expression? ':' _expression

_assignment_left_expression ::=
	 identifier
	| call_expression
	| field_expression
	| pointer_expression
	| subscript_expression
	| parenthesized_expression
	| qualified_identifier
	| user_defined_literal

assignment_expression ::=
	 _assignment_left_expression ( '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '&=' | '^=' | '|=' | 'and_eq' | 'or_eq' | 'xor_eq' ) ( _expression | initializer_list )

pointer_expression ::=
	 ( '*' | '&' ) _expression

unary_expression ::=
	 ( '!' | '~' | '-' | '+' ) _expression
	| ( 'not' | 'compl' ) _expression

binary_expression ::=
	 _expression '+' _expression
	| _expression '-' _expression
	| _expression '*' _expression
	| _expression '/' _expression
	| _expression '%' _expression
	| _expression '||' _expression
	| _expression '&&' _expression
	| _expression '|' _expression
	| _expression '^' _expression
	| _expression '&' _expression
	| _expression '==' _expression
	| _expression '!=' _expression
	| _expression '>' _expression
	| _expression '>=' _expression
	| _expression '<=' _expression
	| _expression '<' _expression
	| _expression '<<' _expression
	| _expression '>>' _expression
	| _expression '<=>' _expression
	| _expression 'or' _expression
	| _expression 'and' _expression
	| _expression 'bitor' _expression
	| _expression 'xor' _expression
	| _expression 'bitand' _expression
	| _expression 'not_eq' _expression

update_expression ::=
	 ( '--' | '++' ) _expression | _expression ( '--' | '++' )

cast_expression ::=
	 '(' type_descriptor ')' _expression

type_descriptor ::=
	 type_qualifier* _type_specifier type_qualifier* _abstract_declarator?

sizeof_expression ::=
	 'sizeof' ( _expression | '(' type_descriptor ')' ) | 'sizeof' '...' '(' identifier ')'

alignof_expression ::=
	 ( '__alignof__' | '__alignof' | '_alignof' | 'alignof' | '_Alignof' ) '(' type_descriptor ')'

offsetof_expression ::=
	 'offsetof' '(' type_descriptor ',' _field_identifier ')'

generic_expression ::=
	 '_Generic' '(' _expression ',' type_descriptor ':' _expression ( ',' type_descriptor ':' _expression )* ')'

subscript_expression ::=
	 _expression subscript_argument_list

call_expression ::=
	 _expression argument_list
	| primitive_type argument_list

gnu_asm_expression ::=
	 ( 'asm' | '__asm__' ) gnu_asm_qualifier* '(' ( string_literal | concatenated_string ) ( gnu_asm_output_operand_list ( gnu_asm_input_operand_list ( gnu_asm_clobber_list gnu_asm_goto_list? )? )? )? ')'

gnu_asm_qualifier ::=
	 'volatile'
	| 'inline'
	| 'goto'

gnu_asm_output_operand_list ::=
	 ':' ( gnu_asm_output_operand ( ',' gnu_asm_output_operand )* )?

gnu_asm_output_operand ::=
	 ( '[' identifier ']' )? string_literal '(' identifier ')'

gnu_asm_input_operand_list ::=
	 ':' ( gnu_asm_input_operand ( ',' gnu_asm_input_operand )* )?

gnu_asm_input_operand ::=
	 ( '[' identifier ']' )? string_literal '(' _expression ')'

gnu_asm_clobber_list ::=
	 ':' ( string_literal ( ',' string_literal )* )?

gnu_asm_goto_list ::=
	 ':' ( identifier ( ',' identifier )* )?

argument_list ::=
	 '(' ( ( '__extension__'? _expression | initializer_list | compound_statement ) ( ',' ( '__extension__'? _expression | initializer_list | compound_statement ) )* )? ')'

field_expression ::=
	 _expression ( '.' | '.*' | '->' ) ( _field_identifier | destructor_name | template_method | dependent_field_identifier )

compound_literal_expression ::=
	 '(' type_descriptor ')' initializer_list
	| ( _class_name | primitive_type ) initializer_list

parenthesized_expression ::=
	 '(' ( _expression | comma_expression ) ')'

initializer_list ::=
	 '{' ( ( initializer_pair | _expression | initializer_list ) ( ',' ( initializer_pair | _expression | initializer_list ) )* )? ','? '}'

initializer_pair ::=
	 ( subscript_designator | field_designator )+ '=' ( _expression | initializer_list )

subscript_designator ::=
	 '[' _expression ']'

field_designator ::=
	 '.' _field_identifier

number_literal ::=
	 ( [-\+]? ( ( ( '0b' | '0B' ) [01]+ ( "'"  [01]+ )* | [1-9] [0-9]* ( "'"  [0-9]+ )* | ( '0x' | '0X' ) [0-9a-fA-F]+ ( "'"  [0-9a-fA-F]+ )* | '0' [0-7]* ( "'"  [0-7]+ )* ) ('ll'|'LL')[uU]?|[uU]('ll'|'LL')?|[uU][lL]?|[uU][zZ]?|[lL][uU]?|[zZ][uU]?? | ( [0-9]+ ( "'"  [0-9]+ )* [eE] [-\+]? [0-9]+ ( "'"  [0-9]+ )* | [0-9]+ ( "'"  [0-9]+ )* '.' ( [0-9]+ ( "'"  [0-9]+ )* )? ( [eE] [-\+]? [0-9]+ ( "'"  [0-9]+ )* )? | '.' [0-9]+ ( "'"  [0-9]+ )* ( [eE] [-\+]? [0-9]+ ( "'"  [0-9]+ )* )? | ( '0x' | '0X' ) ( [0-9a-fA-F]+ ( "'"  [0-9a-fA-F]+ )* | [0-9a-fA-F]+ ( "'"  [0-9a-fA-F]+ )* '.' ( [0-9a-fA-F]+ ( "'"  [0-9a-fA-F]+ )* )? | '.' [0-9a-fA-F]+ ( "'"  [0-9a-fA-F]+ )* ) [pP] [-\+]? [0-9]+ ( "'"  [0-9]+ )* ) ([fF]('16'|'32'|'64'|'128')?)|[lL]|('bf16'|'BF16')? ) )

char_literal ::=
	 ( "L'" | "u'" | "U'" | "u8'" | "'"  ) ( escape_sequence | [^#x0A'] ) "'" 

concatenated_string ::=
	 ( identifier | string_literal | raw_string_literal ) ( string_literal | raw_string_literal ) ( identifier | string_literal | raw_string_literal )*

string_literal ::=
	 ( 'L"' | 'u"' | 'U"' | 'u8"' | '"'  ) ( [^\"#x0A]+ | escape_sequence )* '"' 

escape_sequence ::=
	 '\\'  ( [^xuU] | [0-9]'{2,3}' | 'x'[0-9a-fA-F]'{2,}' | 'u'[0-9a-fA-F]'{4}' | 'U'[0-9a-fA-F]'{8}' )

system_lib_string ::=
	 ( '<' ( [^>#x0A] | '\>' )* '>' )

true ::=
	 ( 'TRUE' | 'true' )

false ::=
	 ( 'FALSE' | 'false' )

null ::=
	 'NULL'
	| 'nullptr'

identifier ::=
	 ('\p{XID_Start}'|'\$'|'_'|'\u'[0-9A-Fa-f]'{4}'|'\U'[0-9A-Fa-f]'{8}')('\p{XID_Continue}'|'\$'|'\u'[0-9A-Fa-f]'{4}'|'\U'[0-9A-Fa-f]'{8}')*

_type_identifier ::=
	 identifier

_field_identifier ::=
	 identifier

_statement_identifier ::=
	 identifier

_empty_declaration ::=
	 _type_specifier ';'

macro_type_specifier ::=
	 identifier '(' type_descriptor ')'

comment ::=
	 ( '//' ('\'+('.'|'#x0D'?'#x0A')|[^\#x0A])* | '/*' [^*]*'\'*+([^/*][^*]*'\'*+)* '/' )

placeholder_type_specifier ::=
	 _type_specifier? ( auto | decltype_auto )

auto ::=
	 'auto'

decltype_auto ::=
	 'decltype' '(' auto ')'

decltype ::=
	 'decltype' '(' _expression ')'

_class_declaration ::=
	 ( attribute_specifier | alignas_specifier )* ms_declspec_modifier? attribute_declaration* _class_declaration_item

_class_declaration_item ::=
	 ( _class_name | _class_name? virtual_specifier? base_class_clause? field_declaration_list ) attribute_specifier?

class_specifier ::=
	 'class' _class_declaration

_class_name ::=
	 _type_identifier | template_type | qualified_type_identifier

virtual_specifier ::=
	 'final'
	| 'override'

virtual ::=
	 'virtual'

alignas_specifier ::=
	 'alignas' '(' ( _expression | primitive_type ) ')'

explicit_function_specifier ::=
	 'explicit'
	| 'explicit' '(' _expression ')'

base_class_clause ::=
	 ':' attribute_declaration* ( access_specifier | access_specifier virtual | virtual access_specifier )? _class_name '...'? ( ',' attribute_declaration* ( access_specifier | access_specifier virtual | virtual access_specifier )? _class_name '...'? )*

_enum_base_clause ::=
	 ':' ( qualified_type_identifier | _type_identifier | sized_type_specifier )

dependent_type ::=
	 'typename' _type_specifier

template_declaration ::=
	 'template' template_parameter_list requires_clause? ( _empty_declaration | alias_declaration | declaration | template_declaration | function_definition | concept_definition | friend_declaration | constructor_or_destructor_declaration | constructor_or_destructor_definition | operator_cast_declaration | operator_cast_definition )

template_instantiation ::=
	 'template' _declaration_specifiers? _declarator ';'

template_parameter_list ::=
	 '<' ( ( parameter_declaration | optional_parameter_declaration | type_parameter_declaration | variadic_parameter_declaration | variadic_type_parameter_declaration | optional_type_parameter_declaration | template_template_parameter_declaration ) ( ',' ( parameter_declaration | optional_parameter_declaration | type_parameter_declaration | variadic_parameter_declaration | variadic_type_parameter_declaration | optional_type_parameter_declaration | template_template_parameter_declaration ) )* )? '>'

type_parameter_declaration ::=
	 ( 'typename' | 'class' ) _type_identifier?

variadic_type_parameter_declaration ::=
	 ( 'typename' | 'class' ) '...' _type_identifier?

optional_type_parameter_declaration ::=
	 ( 'typename' | 'class' ) _type_identifier? '=' _type_specifier

template_template_parameter_declaration ::=
	 'template' template_parameter_list ( type_parameter_declaration | variadic_type_parameter_declaration | optional_type_parameter_declaration )

optional_parameter_declaration ::=
	 _declaration_specifiers _declarator? '=' _expression

variadic_parameter_declaration ::=
	 _declaration_specifiers ( variadic_declarator | variadic_reference_declarator )

variadic_declarator ::=
	 '...' identifier?

variadic_reference_declarator ::=
	 ( '&&' | '&' ) variadic_declarator

operator_cast ::=
	 'operator' _declaration_specifiers _abstract_declarator

field_initializer_list ::=
	 ':' field_initializer ( ',' field_initializer )*

field_initializer ::=
	 ( _field_identifier | template_method | qualified_field_identifier ) ( initializer_list | argument_list ) '...'?

inline_method_definition ::=
	 _declaration_specifiers _field_declarator ( ( compound_statement | try_statement ) | default_method_clause | delete_method_clause )

_constructor_specifiers ::=
	 _declaration_modifiers
	| explicit_function_specifier

operator_cast_definition ::=
	 _constructor_specifiers* ( operator_cast | qualified_operator_cast_identifier ) ( compound_statement | try_statement )

operator_cast_declaration ::=
	 _constructor_specifiers* ( operator_cast | qualified_operator_cast_identifier ) ( '=' _expression )? ';'

constructor_try_statement ::=
	 'try' field_initializer_list? compound_statement catch_clause+

constructor_or_destructor_definition ::=
	 _constructor_specifiers* function_declarator ( field_initializer_list? compound_statement | constructor_try_statement | default_method_clause | delete_method_clause )

constructor_or_destructor_declaration ::=
	 _constructor_specifiers* function_declarator ';'

default_method_clause ::=
	 '=' 'default' ';'

delete_method_clause ::=
	 '=' 'delete' ';'

friend_declaration ::=
	 'friend' ( declaration | function_definition | ( 'class' | 'struct' | 'union' )? _class_name ';' )

access_specifier ::=
	 'public'
	| 'private'
	| 'protected'

reference_declarator ::=
	 ( '&' | '&&' ) _declarator

reference_field_declarator ::=
	 ( '&' | '&&' ) _field_declarator

abstract_reference_declarator ::=
	 ( '&' | '&&' ) _abstract_declarator?

structured_binding_declarator ::=
	 '[' identifier ( ',' identifier )* ']'

ref_qualifier ::=
	 '&'
	| '&&'

_function_declarator_seq ::=
	 parameter_list _function_attributes_start? ref_qualifier? _function_exception_specification? _function_attributes_end? trailing_return_type? _function_postfix?

_function_attributes_start ::=
	 attribute_specifier+ type_qualifier* | attribute_specifier* type_qualifier+

_function_exception_specification ::=
	 noexcept
	| throw_specifier

_function_attributes_end ::=
	 gnu_asm_expression? ( attribute_specifier+ attribute_declaration* | attribute_specifier* attribute_declaration+ )

_function_postfix ::=
	 virtual_specifier+ | requires_clause

trailing_return_type ::=
	 '->' type_descriptor

noexcept ::=
	 'noexcept' ( '(' _expression? ')' )?

throw_specifier ::=
	 'throw' '(' ( type_descriptor ( ',' type_descriptor )* )? ')'

template_type ::=
	 _type_identifier template_argument_list

template_method ::=
	 ( _field_identifier | operator_name ) template_argument_list

template_function ::=
	 identifier template_argument_list

template_argument_list ::=
	 '<' ( ( type_descriptor | type_parameter_pack_expansion | _expression ) ( ',' ( type_descriptor | type_parameter_pack_expansion | _expression ) )* )? '>'

namespace_definition ::=
	 'inline'? 'namespace' ( _namespace_identifier | nested_namespace_specifier )? declaration_list

namespace_alias_definition ::=
	 'namespace' _namespace_identifier '=' ( _namespace_identifier | nested_namespace_specifier ) ';'

_namespace_specifier ::=
	 'inline'? _namespace_identifier

nested_namespace_specifier ::=
	 _namespace_specifier? '::' ( nested_namespace_specifier | _namespace_specifier )

using_declaration ::=
	 'using' ( 'namespace' | 'enum' )? ( identifier | qualified_identifier ) ';'

alias_declaration ::=
	 'using' _type_identifier attribute_declaration* '=' type_descriptor ';'

static_assert_declaration ::=
	 'static_assert' '(' _expression ( ',' ( string_literal | raw_string_literal | concatenated_string ) )? ')' ';'

concept_definition ::=
	 'concept' identifier '=' _expression ';'

for_range_loop ::=
	 'for' '(' _for_range_loop_body ')' _statement

_for_range_loop_body ::=
	 init_statement? _declaration_specifiers _declarator ':' ( _expression | initializer_list )

init_statement ::=
	 alias_declaration
	| type_definition
	| declaration
	| expression_statement

condition_clause ::=
	 '(' init_statement? ( _expression | comma_expression | condition_declaration ) ')'

condition_declaration ::=
	 _declaration_specifiers _declarator ( '=' _expression | initializer_list )

co_return_statement ::=
	 'co_return' _expression? ';'

co_yield_statement ::=
	 'co_yield' _expression ';'

throw_statement ::=
	 'throw' _expression? ';'

try_statement ::=
	 'try' compound_statement catch_clause+

catch_clause ::=
	 'catch' parameter_list compound_statement

raw_string_literal ::=
	 ( 'R"' | 'LR"' | 'uR"' | 'UR"' | 'u8R"' ) ( raw_string_delimiter '(' raw_string_content ')' raw_string_delimiter | '(' raw_string_content ')' ) '"' 

subscript_argument_list ::=
	 '[' ( ( _expression | initializer_list ) ( ',' ( _expression | initializer_list ) )* )? ']'

co_await_expression ::=
	 'co_await' _expression

new_expression ::=
	 '::'? 'new' argument_list? _type_specifier new_declarator? ( argument_list | initializer_list )?

new_declarator ::=
	 '[' _expression ']' new_declarator?

delete_expression ::=
	 '::'? 'delete' ( '[' ']' )? _expression

type_requirement ::=
	 'typename' _class_name

compound_requirement ::=
	 '{' _expression '}' 'noexcept'? trailing_return_type? ';'

_requirement ::=
	 expression_statement
	| type_requirement
	| compound_requirement

requirement_seq ::=
	 '{' _requirement* '}'

constraint_conjunction ::=
	 _requirement_clause_constraint ( '&&' | 'and' ) _requirement_clause_constraint

constraint_disjunction ::=
	 _requirement_clause_constraint ( '||' | 'or' ) _requirement_clause_constraint

_requirement_clause_constraint ::=
	 true
	| false
	| _class_name
	| fold_expression
	| lambda_expression
	| requires_expression
	| '(' _expression ')'
	| constraint_conjunction
	| constraint_disjunction

requires_clause ::=
	 'requires' _requirement_clause_constraint

requires_parameter_list ::=
	 '(' ( ( parameter_declaration | optional_parameter_declaration | variadic_parameter_declaration ) ( ',' ( parameter_declaration | optional_parameter_declaration | variadic_parameter_declaration ) )* )? ')'

requires_expression ::=
	 'requires' requires_parameter_list? requirement_seq

lambda_expression ::=
	 lambda_capture_specifier ( template_parameter_list requires_clause? )? abstract_function_declarator? compound_statement

lambda_capture_specifier ::=
	 '[' ( lambda_default_capture | _expression ( ',' _expression )* | lambda_default_capture ',' _expression ( ',' _expression )* ) ']'

lambda_default_capture ::=
	 '='
	| '&'

_fold_operator ::=
	 '+'
	| '-'
	| '*'
	| '/'
	| '%'
	| '^'
	| '&'
	| '|'
	| '='
	| '<'
	| '>'
	| '<<'
	| '>>'
	| '+='
	| '-='
	| '*='
	| '/='
	| '%='
	| '^='
	| '&='
	| '|='
	| '>>='
	| '<<='
	| '=='
	| '!='
	| '<='
	| '>='
	| '&&'
	| '||'
	| ','
	| '.*'
	| '->*'
	| 'or'
	| 'and'
	| 'bitor'
	| 'xor'
	| 'bitand'
	| 'not_eq'

_binary_fold_operator ::=
	 '+' '...' '+'
	| '-' '...' '-'
	| '*' '...' '*'
	| '/' '...' '/'
	| '%' '...' '%'
	| '^' '...' '^'
	| '&' '...' '&'
	| '|' '...' '|'
	| '=' '...' '='
	| '<' '...' '<'
	| '>' '...' '>'
	| '<<' '...' '<<'
	| '>>' '...' '>>'
	| '+=' '...' '+='
	| '-=' '...' '-='
	| '*=' '...' '*='
	| '/=' '...' '/='
	| '%=' '...' '%='
	| '^=' '...' '^='
	| '&=' '...' '&='
	| '|=' '...' '|='
	| '>>=' '...' '>>='
	| '<<=' '...' '<<='
	| '==' '...' '=='
	| '!=' '...' '!='
	| '<=' '...' '<='
	| '>=' '...' '>='
	| '&&' '...' '&&'
	| '||' '...' '||'
	| ',' '...' ','
	| '.*' '...' '.*'
	| '->*' '...' '->*'
	| 'or' '...' 'or'
	| 'and' '...' 'and'
	| 'bitor' '...' 'bitor'
	| 'xor' '...' 'xor'
	| 'bitand' '...' 'bitand'
	| 'not_eq' '...' 'not_eq'

_unary_left_fold ::=
	 '...' _fold_operator _expression

_unary_right_fold ::=
	 _expression _fold_operator '...'

_binary_fold ::=
	 _expression _binary_fold_operator _expression

fold_expression ::=
	 '(' ( _unary_right_fold | _unary_left_fold | _binary_fold ) ')'

parameter_pack_expansion ::=
	 _expression '...'

type_parameter_pack_expansion ::=
	 type_descriptor '...'

destructor_name ::=
	 '~' identifier

dependent_identifier ::=
	 'template' template_function

dependent_field_identifier ::=
	 'template' template_method

dependent_type_identifier ::=
	 'template' template_type

_scope_resolution ::=
	 ( _namespace_identifier | template_type | decltype | dependent_type_identifier )? '::'

qualified_field_identifier ::=
	 _scope_resolution ( dependent_field_identifier | qualified_field_identifier | template_method | _field_identifier )

qualified_identifier ::=
	 _scope_resolution ( dependent_identifier | qualified_identifier | template_function | 'template'? identifier | operator_name | destructor_name | pointer_type_declarator )

qualified_type_identifier ::=
	 _scope_resolution ( dependent_type_identifier | qualified_type_identifier | template_type | _type_identifier )

qualified_operator_cast_identifier ::=
	 _scope_resolution ( qualified_operator_cast_identifier | operator_cast )

operator_name ::=
	 'operator' ( 'co_await' | '+' | '-' | '*' | '/' | '%' | '^' | '&' | '|' | '~' | '!' | '=' | '<' | '>' | '+=' | '-=' | '*=' | '/=' | '%=' | '^=' | '&=' | '|=' | '<<' | '>>' | '>>=' | '<<=' | '==' | '!=' | '<=' | '>=' | '<=>' | '&&' | '||' | '++' | '--' | ',' | '->*' | '->' | '()' | '[]' | 'xor' | 'bitand' | 'bitor' | 'compl' | 'not' | 'xor_eq' | 'and_eq' | 'or_eq' | 'not_eq' | 'and' | 'or' | ( 'new' | 'delete' ) '[]'? | '""' identifier )

this ::=
	 'this'

literal_suffix ::=
	 [a-zA-Z_][a-zA-Z_]*

user_defined_literal ::=
	 ( number_literal | char_literal | string_literal | raw_string_literal | concatenated_string ) literal_suffix

_namespace_identifier ::=
	 identifier

kernel_call_expression ::=
	 _expression kernel_call_syntax argument_list

kernel_call_syntax ::=
	 ( '<' [ #x09#x0A#x0B#x0C#x0D]* '<' [ #x09#x0A#x0B#x0C#x0D]* '<' ) _expression ( ',' _expression )* ( '>' [ #x09#x0A#x0B#x0C#x0D]* '>' [ #x09#x0A#x0B#x0C#x0D]* '>' )

launch_bounds ::=
	 '__launch_bounds__' '(' _expression ( ',' _expression )? ')'