# Modified from this ANSI C yacc grammmar file I got from the Internet:
# https://www.lysator.liu.se/c/ANSI-C-grammar-y.html
#
#     In 1985, Jeff Lee published his Yacc grammar (which is accompanied by a
#     matching Lex specification) for the April 30, 1985 draft version of the
#     ANSI C standard.
#     Tom Stockfisch reposted it to net.sources in 1987; that original, as
#     mentioned in the answer to question 17.25 of the comp.lang.c FAQ, can be
#     ftp'ed from ftp.uu.net, file usenet/net.sources/ansi.c.grammar.Z.
#
#     Jutta Degener, 1995
#
# ...thanks, Jutta! :)
# - BAG, 2026

primary_expression
    | ident:    IDENTIFIER
    | literal:  CHAR
    | literal:  STRING
    | literal:  NUMBER
    | '(' expression ')'
    ;

field_name
    | IDENTIFIER
    ;

postfix_operator
    | index: '[' expression ']'
    | call:  '(' ( assignment_expression ( ',' assignment_expression )* )? ')'
    | dot:   '.' field_name
    | arrow: '->' field_name
    | inc:   '++'
    | dec:   '--'
    ;

postfix_expression
    | primary_expression ( postfix_operator )*
    ;

unary_operator
    | [ '&' '*' '+' '-' '~' '!' ]
    ;

unary_expression
    | postfix_expression
    | inc: '++' unary_expression
    | dec: '--' unary_expression
    | unary_operator cast_expression
    | sizeof_expr:  'sizeof' unary_expression
    | sizeof_type:  'sizeof' '(' type_name ')'
    ;

cast_expression
    | unary_expression
    | cast: '(' type_name ')' cast_expression
    ;

multiplicative_operator
    | [ '*' '/' '%' ]
    ;

multiplicative_expression
    | cast_expression ( multiplicative_operator cast_expression )*
    ;

additive_operator
    | [ '+' '-' ]
    ;

additive_expression
    | multiplicative_expression ( additive_operator multiplicative_expression )*
    ;

shift_operator
    | [ '<<' '>>' ]
    ;

shift_expression
    | additive_expression ( shift_operator additive_expression )*
    ;

relational_operator
    | [ '<' '>' '<=' '>=' ]
    ;

relational_expression
    | shift_expression ( relational_operator shift_expression )*
    ;

equality_operator
    | [ '==' '!=' ]
    ;

equality_expression
    | relational_expression ( equality_operator relational_expression )*
    ;

and_expression
    | equality_expression ( '&' equality_expression )*
    ;

exclusive_or_expression
    | and_expression ( '^' and_expression )*
    ;

inclusive_or_expression
    | exclusive_or_expression ( '|' exclusive_or_expression )*
    ;

logical_and_expression
    | inclusive_or_expression ( '&&' inclusive_or_expression )*
    ;

logical_or_expression
    | logical_and_expression ( '||' logical_and_expression )*
    ;

conditional_expression
    | logical_or_expression ( '?' expression ':' conditional_expression )?
    ;

assignment_operator
    | [ '=' '*=' '/=' '%=' '+=' '-=' '<<=' '>>=' '&=' '^=' '|=' ]
    ;

assignment_expression
    | unary_expression assignment_operator assignment_expression
    | conditional_expression
    ;

expression
    | assignment_expression ( ',' assignment_expression )*
    ;

constant_expression
    | conditional_expression
    ;

declaration
    | declaration_specifiers ';'
    | declaration_specifiers init_declarator_list ';'
    ;

declaration_specifier
    | storage_class_specifier
    | type_specifier
    | type_qualifier
    ;

declaration_specifiers
    | declspec: declaration_specifier ( declaration_specifier )*
    ;

# NOTE: this is its own rule, to make sure it always generates a ParseMatch
equals
    | '='
    ;

init_declarator
    | declarator ( equals initializer )?
    ;

init_declarator_list
    | init_declarator ( ',' init_declarator )*
    ;

storage_class_specifier
    | [ 'typedef' 'extern' 'static' 'auto' 'register' ]
    ;

type_specifier
    | [ 'void' 'char' 'short' 'int' 'long' 'float' 'double' 'signed' 'unsigned' ]
    | struct_or_union_specifier
    | enum_specifier
    | TYPE_NAME
    ;

struct_or_union_or_enum_tag
    | IDENTIFIER
    ;

struct_or_union_specifier
    | struct_or_union ( struct_or_union_or_enum_tag )? '{' struct_declaration_list '}'
    | struct_or_union struct_or_union_or_enum_tag
    ;

struct_or_union
    | [ 'struct' 'union' ]
    ;

struct_declaration_list
    | struct_declaration ( struct_declaration )*
    ;

struct_declaration
    | specifier_qualifier_list struct_declarator_list ';'
    ;

specifier_qualifier
    | type_specifier
    | type_qualifier
    ;

specifier_qualifier_list
    | specifier_qualifier ( specifier_qualifier )*
    ;

struct_declarator_list
    | struct_declarator ( ',' struct_declarator )*
    ;

struct_declarator
    | declarator ( ':' constant_expression )?
    | ':' constant_expression
    ;

enum_specifier
    | 'enum' struct_or_union_or_enum_tag ( '{' enumerator_list '}' )?
    | 'enum' '{' enumerator_list '}'
    ;

enumerator_list
    | enumerator ( ',' enumerator )*
    ;

enumerator
    | IDENTIFIER ( equals constant_expression )?
    ;

type_qualifier
    | [ 'const' 'volatile' ]
    ;

declarator_suffix
    | array:   '[' ( constant_expression )? ']'
    | params:  '(' ( parameter_type_list )? ')'
    | idents:  '(' identifier_list ')'
    ;

direct_declarator
    | declare: IDENTIFIER
    | '(' declarator ')'
    ;

pointer
    | pointer: '*' ( type_qualifier )* ( pointer )?
    ;

declarator
    | ( pointer )? direct_declarator ( declarator_suffix )*
    ;

# NOTE: this is its own rule, to make sure it always generates a ParseMatch
ellipsis
    | '...'
    ;

parameter_type_list
    | parameter_list ( ',' ellipsis )?
    ;

parameter_list
    | parameter_declaration ( ',' parameter_declaration )*
    ;

parameter_declaration
    | declaration_specifiers declarator
    | declaration_specifiers abstract_declarator
    | declaration_specifiers
    ;

identifier_list
    | IDENTIFIER ( ',' IDENTIFIER )*
    ;

type_name
    | specifier_qualifier_list ( abstract_declarator )?
    ;

abstract_declarator_suffix
    | array:  '[' ( constant_expression )? ']'
    | params: '(' ( parameter_type_list )? ')'
    ;

abstract_declarator
    | pointer ( abstract_declarator )?
    | abstract_declarator_suffix ( abstract_declarator_suffix )*
    | '(' abstract_declarator ')'
    ;

initializer
    | assignment_expression
    | '{' initializer_list ( ',' )? '}'
    ;

initializer_list
    | initializer ( ',' initializer )*
    ;

statement
    | labeled_statement
    | compound_statement
    | expression_statement
    | selection_statement
    | iteration_statement
    | jump_statement
    ;

labeled_statement
    | label:    IDENTIFIER ':' statement
    | case:     'case' constant_expression ':' statement
    | default:  'default' ':' statement
    ;

compound_statement
    | block:  '{' ( declaration_list )? ( statement_list )? '}'
    ;

declaration_list
    | declaration ( declaration )*
    ;

statement_list
    | statement ( statement )*
    ;

expression_statement
    | ( expression )? ';'
    ;

else_statement
    | else:  'else' statement
    ;

selection_statement
    | if:      'if' '(' expression ')' statement ( else_statement )?
    | switch:  'switch' '(' expression ')' statement
    ;

iteration_statement
    | while:  'while' '(' expression ')' statement
    | do:     'do' statement 'while' '(' expression ')' ';'
    | for:    'for' '(' expression_statement expression_statement ( expression )? ')' statement
    ;

label
    | IDENTIFIER
    ;

jump_statement
    | goto:      'goto' label ';'
    | continue:  'continue' ';'
    | break:     'break' ';'
    | return:    'return' ( expression )? ';'
    ;

external_declaration
    | function_definition
    | declaration
    ;

function_definition
    | ( declaration_specifiers )? declarator ( declaration_list )? compound_statement
    ;

repl_command
    | translation_unit
    | expression
    ;

translation_unit
    | external_declaration ( external_declaration )*
    ;
