C99文法

# 外部定义
翻译单元 = { 函数定义 | 声明 }
函数定义 = 声明说明符 说明符 [声明列表] 复合语句
声明列表 = 声明 {声明}

# 表达式
表达式 = 赋值表达式 {',' 赋值表达式}

常量表达式 = 条件表达式
赋值表达式 = 条件表达式 | 一元表达式 赋值操作符 赋值表达式
赋值操作符 = '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '&=' | 'ˆ=' | '|='

条件表达式 = 逻辑或表达式 | 逻辑或表达式 '?' 表达式 ':' 条件表达式
逻辑或表达式 = 逻辑与表达式 {'||' 逻辑与表达式}
逻辑与表达式 = 位或表达式 {'&&' 位或表达式}
位或表达式 = 位异或表达式 {'|' 位异或表达式}
位异或表达式 = 位与表达式 {'ˆ' 位与表达式}
位与表达式 = 相等表达式 {'&' 相等表达式}
相等表达式 = 关系表达式 {('==' | '!=') 关系表达式}
关系表达式 = 移位表达式 {('<' | '>' | '>=' | '<=') 移位表达式}
移位表达式 = 加法表达式 {('<<' | '>>') 加法表达式}
加法表达式 = 乘法表达式 {('+' | '-') 乘法表达式}
乘法表达式 = 类型转换表达式 {('*' | '/' | '%') 类型转换表达式}
类型转换表达式 = 一元表达式 | '(' 类型 ')' 类型转换表达式
一元表达式 = 后缀表达式
           | ('++' | '--') 一元表达式
           | 一元操作符 类型转换表达式
           | 'sizeof' 一元表达式
           | 'sizeof' '(' 类型 ')'

一元操作符 = '&' | '*' | '+' | '-' | '˜' | '!'
argument表达式列表 = 赋值表达式 {',' 赋值表达式}

后缀表达式尾 = '[' 表达式 ']' 后缀表达式尾
            | '(' [argument表达式列表] ')' 后缀表达式尾
            | '.' 标识符 后缀表达式尾
            | '->' 标识符 后缀表达式尾
            | '++' 后缀表达式尾
            | '--' 后缀表达式尾
            | 空

后缀表达式 = 主表达式 后缀表达式尾 | '(' 类型 ')' '{' 初始化列表 [',']'}' 后缀表达式尾
主表达式 = 标识符 | 常量 | 字符串序列 | '(' 表达式 ')'

# 声明 
声明 = 声明说明符 [初始化声明列表] ';'
声明说明符 = (存储类说明符 | 类型说明符 | 类型限定符) [声明说明符]

初始化声明列表 = 初始化说明符 {',' 初始化说明符}
初始化说明符 = 说明符 ['=' 初始化器]
存储类说明符 = 'typedef' | 'extern' | 'static' | 'auto' | 'register'
类型说明符 = 'void' | 'char' | 'short' | 'int' | 'long' 
          | 'float' | 'double' | 'signed' | 'unsigned'
          | '_Bool' | '_Complex' | '_Imaginary'
          | ('struct' | 'union') [标识符] '{'  结构体声明 {结构体声明} '}'
          | 枚举说明符
               
结构体声明 = {(类型说明符 | 类型限定符)} 结构体说明符列表 ';'
结构体说明符列表 = 结构体说明符 {',' 结构体说明符}
结构体说明符 = 说明符 | [说明符] ':' 常量表达式
枚举说明符 = 'enum' ([标识符] '{' 枚举列表 [',']'}' | 标识符)     
枚举列表 = 枚举常量 ['=' 常量表达式] {',' 枚举常量 ['=' 常量表达式]}
类型限定符 = 'const' | 'restrict' | 'volatile'
说明符 = [指针] 直接说明符 

直接说明符 = 标识符 直接说明符尾 | '(' 说明符 ')' 直接说明符尾 
直接说明符尾 = '[' [类型限定符列表] [赋值表达式] ']' 直接说明符尾
            | '[' 'static' [类型限定符列表] 赋值表达式 ']' 直接说明符尾
            | '[' 类型限定符列表 'static' 赋值表达式 ']' 直接说明符尾
            | '[' [类型限定符列表] '*' ']' 直接说明符尾
            | '(' 参数类型列表 ')' 直接说明符尾
            | '(' [标识符列表] ')' 直接说明符尾
            | 空

指针 = '*' [类型限定符列表] [指针]
类型限定符列表 = 类型限定符 {类型限定符}
参数类型列表 = 参数列表 | 参数列表 ',' '...'
参数列表 = 参数声明 {',' 参数声明}
参数声明 = 声明说明符 说明符 | 声明说明符 [抽象说明符]
标识符列表 = 标识符 {',' 标识符}

# 类型
类型 = {(类型说明符 | 类型限定符)} [抽象说明符]

抽象说明符 = 指针 | [指针] 直接抽象说明符
直接抽象说明符 = '(' 抽象说明符 ')' 直接抽象说明符尾
              | '[' [赋值表达式] ']' 直接抽象说明符尾
              | '[' '*' ']' 直接抽象说明符尾
              | '(' [参数类型列表] ')' 直接抽象说明符尾

直接抽象说明符尾 = '[' [赋值表达式] ']' 直接抽象说明符尾
                | '[' '*' ']' 直接抽象说明符尾
                | '(' [参数类型列表] ')' 直接抽象说明符尾
                | 空

# 初始化
初始化器 = 赋值表达式 | '{' 初始化列表 [','] '}'
初始化列表 = [标志符列表 '='] 初始化器 {',' [标志符列表 '='] 初始化器}
标志符列表 = 标志符 {标志符}
标志符 = '[' 常量表达式 ']'  | '.' 标识符

# 语句和块
语句 = labeled语句 | 复合语句 | if语句 | switch语句
     | for语句 | while语句 | do语句 | 表达式语句 
     | goto语句 | continue语句 | return语句 | break语句
     | case语句 | default语句

case语句 = 'case' 常量表达式 ':' 语句 
default语句 = 'default' ':' 语句
labeled语句 = 标识符 ':' 语句
复合语句 = '{' {(声明 | 语句)} '}' 
表达式语句 = ';' | 表达式 ';'
if语句 = 'if' '(' 表达式 ')' 语句 ['else' 语句 ]
switch语句 = 'switch' '(' 表达式 ')' 语句
while语句 = 'while' '(' 表达式 ')' 语句 
do语句 = 'do' 语句 'while' '(' 表达式 ')' ';' 
for语句 = 'for' '(' ([表达式] | 声明 [表达式]) ';' [表达式] ';' [表达式] ')' 语句 
goto语句 = 'goto' 标识符 ';'
return语句 = 'return' [表达式] ';'
continue语句 = 'continue' ';'
break语句 = 'break' ';'