呵呵，雕栏玉砌应犹在
今天是伟大祖国第七十二个国庆，就不吟什么
“异域风光不敢看”了，饶了你们这帮
“七痨八伤肾虚膝软的撈鬆孬种”一日吧。
今天想起一件比较后悔的事，就是当年上学时没问问
Kim（人名）教授：
“出于什么动机我们要从CFG中去除右边为空的生成规则 P→ε ”。虽然现在觉得自己想明白了，但没有办法印证我的想法是对的，网上也查不到答案，
没人提出这个问题。也许他们认为这个
自然的，自古以来就是
然的。哪位同学懂，请说说你的答案使我确定一下我想得对吧。
说件在华南工学院的糗事：记得当年学
“帕撕卡语言”时，课本上将指针的符号印成
“↑”。当时华南工学院计算机系都
没计算机，计算机系纯
“纸上谈‘机’”，好不容易才有机会能摸一下
“苹果二”，找遍键盘都没找到
“↑”，当时想死的心都有。记得老师不知从哪里搞了个
“苹果二”上的
“帕撕卡语言编译器”两张360K的五吋软盘在
驱动器上
换来换去才可以。我就没办法将这个所谓
“编译器”运行起来。华南工学院对我们
挺刻薄的，
两张软盘还要自己出钱买。还
贵得要死，10几块钱人民币一张，真不知老师有没有在我们身上
刮肉。反正当时我们穷得要死。软盘是双面的，但
“苹果二”上的
驱动器却是单面的。所以老师还给我们出个主意，在另一边也剪一个缺口以便将软盘翻过来塞进
驱动器也不会禁止写（五吋软盘与三吋软盘不一样，缺口封上表示
“写保护”）。这样整个操作就
更复杂了。像我这样的天才就根本搞不过来。操，什么世道！中国科学院在华南工学院一角存有一台带六十个终端
“霍尼威尔DPS8”中型机，是在中美
“蜜月期”美国指使
“世界银行”给的
“无息贷款”买的。但我们根本没机会摸。记得在刚将机器装好时确曾给我们玩了几下让他们试机，其实当时我们根本不会玩。还
骗我们花了好几块钱买了个他们翻译的
《操作手册》（
比《高等数学》的课本贵）。完全是
冤枉钱因为
后来“霍尼威尔DPS8”中型机就不给我们用了。黑啊。后来到了学
《数据结构》时，又给我们几个小时的机时（当时的操作系统会在你从Login就开始计时，时间用完就得另买时间，不给钱就不给用了。不但用CPU要收钱，用内存用磁盘空间都收费。打印也要收钱）。一个程序都没走起来时间就用完了，毕竟几年都没摸过计算机，手生得很，几个小时的时光在膀胱都还没来得及装满一泡尿前就蹓走，完了。还有就是进门还要换拖鞋，
我真怀疑我的香港脚就是那时染上的。最好笑的是那些
“专家”（操作员？）还故作神秘地说
“换拖鞋已经是管得松了。兄弟我在米国受训时，入门还要‘吹风’吹掉身上的灰尘”。我当时心想没叫你沐浴后换衣服算管得松了。
来美国后才知道哪个“吹风”叫“风帘机”，计算机中心就根本没有，人家用的是玻璃门。超市倒是有这玩艺。而且它也根本不是为了
“吹掉身上的灰尘”。
一群猪一样的货色还好意思到美国
“受训”。后来谣传说DPS8来的时候还附带了一台DPS6小型机，白送给华南工学院计算机系了。还说得
“有的鼻子有眼，有的没有”，还可以带十来个终端什么云云。反正学校没正式公布这个消息，我没见过这个机器，也不知道放这个机器的房子在哪里。反正学
《计算机操作系统》时
杨学伟（人名）搞到两台IBM-PC/AT286装了个Xenix(是这个音，希望我没串错字)胡弄我们。他一个机械系的，屁都不懂就给我们讲
《计算机操作系统》，还让我们做
“信号灯”实验。屁都说不清楚，前半学期胡说些 C 语言。后半学期照着书唸。反正当时我还以为
“信号灯”就是
“全局变量”。搞了半天没搞出
“信号灯”的效果。
倒是真见到没有“信号灯”的效果，各位同学打印的内容混在一起（估计是因为大家用同一帐号Login，不同帐号打印理应由SPOOLING系统分开不会混在一起的，
杨学伟（人名）知道啥SPOOLING，只会照着书唸）。啥没学到，几晚的实验课只用计算机打印了个当年日历。打印纸倒是不用收钱。但却不是有孔一页页那种。而是像
擦屁股纸那样一大卷的。打着打着就走歪了（太重，打印机进纸机械的磨擦力带不动）。他还敢怨我们浪费纸张。看来说华南工学院计算机系有个
“霍尼威尔DPS6”小型机根本就是当时的业余五毛吹嘘祖国繁荣兴旺的小作品。否则
杨学伟（人名）也不会让我们到IBM-PC/AT286上乱搞。
唉，一切都像梦一场。伟大祖国到底有没有几个
“学习成绩‘很’好”的嘛。起来走两步嘛（
华南工学院计算机系代系歌：
起来，学习成绩很好的同学，离开那个轮椅走上两步，中华民族到了没有计算机的时候）。不至于
华为（人名）（唸
话为，小说
《红岩》里
江姐（人名）的契弟，渣滓洞监狱疯子
华子良（人名）与华莹山游击队女匪首
双枪老太婆（人名）的儿子，重庆大学大学生。什么世道嘛，中华民国时期那么少人能有机会上大学，居然还让敌人的儿子占了一个学位，还策反拐跑了一个资产阶级的女儿，女大学生
孙明霞（人名）。真不明白有没有
工农子弟被资产阶级小姐给策反的。当时上大学没有
“政审”这一关么？当时中共有个文艺规定，文艺作品里共产党不允许有
女特务或
女公安侦察员，国民党的对手角色必须是女的。这样为了开展工作，
即使上了床，也是共产党吃国民党的豆腐。
不明白为什么明明是男的损失精液，却是吃了别人，与
《聊斋》的说法完全相反）被禁运就改行
养猪了。两万个清华计算机系大学毕业生，养猪肯定是养不过一百个华南农学院畜牧系的毕业生的嘛。呵呵。只要美国
再坚持最后五分钟不开禁，
华为（人名）的队伍都要散了改投
杰克马（人名）门下去享受他们前几世修来的996写网页的
福份了。吖，
一眨眼之间，中美都从“蜜月”走到“掟煲”了。
饭桶们（人名）也都垂垂老矣，能饭倒是
尚能饭，但估计离
顷之三遗矢也不会太远了吧。
今天就说这些吧。下边给两个CFGs，
大家对比一下有啥不同吧。那个帕撕卡的语法含有 P→ε 我也发现了，
不算今天的答案。还有更本质的不同。
要说出为啥会这样。祝大家避疫愉快，平安渡过。希望疫情解除后大家还能完璧归来，全须全眼，没被科学家用纳米脂肪粒
“骇客”过你们的细胞。
一句话，保持数据和代码intact最重要。
屁馥喇嘛（人名）懂不懂mRNA技术。想与你合伙做
香水生意。我们可以将
麝香、龙涎香的mRNA模板做成针剂出售，打一针能香九个月以上。到时不但屎尿香，放屁都香。香水针剂的名字我都想好了，叫
“抹香猴”。北方说
“包子有肉不在褶上”，广东说
“有麝自然香”。同一个意思。
Context-free Grammar for Standard Pascal
1. <Program>::=
<ProgramHeader> <Declarations> <CompoundStatement> .
2. <ProgramHeader>::=
program id ;
| program id ( <IdList> ) ;
3. <Declarations>::=
<ConstantDefinitions> <TypeDefinitions> <VariableDeclarations> <ProcedureDeclarations>
4. <ConstantDefinitions>::=
ε
| const <ConstantDefinitionList>
5. <ConstantDefinitionList>::=
<ConstDef>
| <ConstDef> <ConstantDefinitionList>
6. <ConstDef>::=
id = constant ;
7. <TypeDefinitions>::=
ε
| type <TypeDefinitionList>
8. <TypeDefinitionList>::=
<TypeDef>
| <TypeDef> <TypeDefinitionList>
9. <TypeDef>::=
id = <TypeSpecifier> ;
10. <VariableDeclarations>::=
ε
| var <VariableDeclarationList>
11. <VariableDeclarationList>::=
<VarDec>
| <VarDec> <VariableDeclarationList>
12. <VarDec>::=
<IdList> : <TypeSpecifier> ;
13. <ProcedureDeclarations>::=
ε
| <ProcDec> <ProcedureDeclarations>
14. <ProcDec>::=
<ProcHeader> forward ;
| <ProcHeader> <Declarations> <CompoundStatement> ;
| <FuncHeader> forward ;
| <FuncHeader> <Declarations> <CompoundStatement> ;
15. <ProcHeader>::=
procedure id <Arguments> ;
16. <FuncHeader>::=
function id <Arguments> : <TypeSpecifier> ;
17. <Arguments>::=
ε
| ( <ArgumentList> )
18. <ArgumentList>::=
<Arg>
| <Arg> ; <ArgumentList>
19. <Arg>::=
<IdList> : <TypeSpecifier>
| var <IdList> : <TypeSpecifer>
20. <CompoundStatement>::=
begin <StatementList> end
21. <StatementList>::=
<Statement>
| <Statement> ; <StatementList>
22. <Statement>::=
ε
| <CompoundStatement>
| <AssignmentStatement>
| <ProcedureCall>
| <ForStatement>
| <WhileStatement>
| <IfStatement>
| <CaseStatement>
| <RepeatStatement>
23. <AssignmentStatement>::=
<Variable> := <Expression>
24. <ProcedureCall>::=
id <Actuals>
25. <ForStatement>::=
for id := <Expression> to <Expression> do <Statement>
| for id := <Expression> downto <Expression> do <Statement>
26. <WhileStatement>::=
while <Expression> do <Statement>
27. <IfStatement>::=
if <Expression> then <Statement>
| if <Expression> then <Statement> else <Statement>
28. <RepeatStatement>::=
repeat <StatementList> until <Expression>
29. <CaseStatement>::=
case <Expression> of <CaseList> end
30. <CaseList>::=
<Case>
| <Case> ; <CaseList>
31. <Case>::=
<ConstantList> : <Statement>
32. <ConstantList>::=
constant
| constant , <ConstantList>
33. <Expression>::=
<SimpleExpression>
| <SimpleExpression> = <SimpleExpression>
| <SimpleExpression> <> <SimpleExpression>
| <SimpleExpression> < <SimpleExpression>
| <SimpleExpression> <= <SimpleExpression>
| <SimpleExpression> > <SimpleExpression>
| <SimpleExpression> >= <SimpleExpression>
34. <SimpleExpression>::=
<Term>
| <SimpleExpression> + <Term>
| <SimpleExpression> - <Term>
| <SimpleExpression> or <Term>
35. <Term>::=
<Factor>
| <Term> * <Factor>
| <Term> / <Factor>
| <Term> div <Factor>
| <Term> mod <Factor>
| <Term> and <Factor>
36. <Factor>::=
( <Expression> )
| + <Factor>
| - <Factor>
| not <Factor>
| <FunctionCall>
| constant
| <Variable>
37. <FunctionCall>::=
id <Actuals>
38. <Actuals>::=
ε
| ( <ExpressionList> )
39. <ExpressionList>::=
<Expresssion>
| <Expression> , <ExpressionList>
40. <Variable>::=
id
| <Variable> . id
| <Variable> ^
| <Variable> [ <ExpressionList> ]
41. <TypeSpecifier>::=
id
| ^ <TypeSpecifier>
| ( <IdList> )
| constant .. constant
| array [ <DimensionList> ] of <TypeSpecifier>
| record <FieldList> end
| file of <TypeSpecifier>
42. <DimensionList>::=
<Dimension>
| <Dimension> , <DimensionList>
43. <Dimension>::=
constant .. constant
| id
44. <FieldList>::=
<Field>
| <Field> ; <FieldList>
45. <Field>::=
<IdList> : <TypeSpecifier>
46. <IdList>::=
id
| id , <IdList>
==============================================================================
C grammar from n1124_pdf
Annex A
(informative)
Language syntax summary
1 NOTE The notation is described in 6.1.
1. <token>::=
<keyword>
| <identifier>
| <constant>
| <string-literal>
| <punctuator>
2. <preprocessing-token>::=
<header-name>
| <identifier>
| <pp-number>
| <character-constant>
| <string-literal>
| <punctuator>
| each non-white-space character that cannot be one of the above
3. <keyword>::= one of
auto
break
case
char
const
continue
default
do
double
else
enum
extern
float
for
goto
if
inline
int
long
register
restrict
return
short
signed
sizeof
static
struct
switch
typedef
union
unsigned
void
volatile
while
_Bool
_Complex
_Imaginary
4. <identifier>::=
<identifier-nondigit>
| <identifier> <identifier-nondigit>
| <identifier> <digit>
5. <identifier-nondigit>::=
<nondigit>
| <universal-character-name>
| other implementation-defined characters
6. <nondigit>::= one of
_ a b c d e f g h i j k l m
n o p q r s t u v w x y z
A B C D E F G H I J K L M
N O P Q R S T U V W X Y Z
7. <digit>::= one of
0 1 2 3 4 5 6 7 8 9
8. <universal-character-name>::=
u <hex-quad>
| U <hex-quad> <hex-quad>
9. <hex-quad>::=
<hexadecimal-digit> <hexadecimal-digit>
| <hexadecimal-digit> <hexadecimal-digit>
10. <constant>::=
<integer-constant>
| <floating-constant>
| <enumeration-constant>
| <character-constant>
11. <integer-constant>::=
<decimal-constant> <integer-suffix>_opt
| <octal-constant> <integer-suffix>_opt
| <hexadecimal-constant> <integer-suffix>_opt
12. <decimal-constant>::=
<nonzero-digit>
| <decimal-constant> <digit>
13. <octal-constant>::=
0
| <octal-constant> <octal-digit>
14. <hexadecimal-constant>::=
<hexadecimal-prefix> <hexadecimal-digit>
| <hexadecimal-constant> <hexadecimal-digit>
15. <hexadecimal-prefix>::= one of
0x 0X
16. <nonzero-digit>::= one of
1 2 3 4 5 6 7 8 9
17. <octal-digit>::= one of
0 1 2 3 4 5 6 7
18. <hexadecimal-digit>::= one of
0 1 2 3 4 5 6 7 8 9
a b c d e f
A B C D E F
19. <integer-suffix>::=
<unsigned-suffix> <long-suffix>_opt
| <unsigned-suffix> <long-long-suffix>
| <long-suffix> <unsigned-suffix>_opt
| <long-long-suffix> <unsigned-suffix>_opt
20. <unsigned-suffix>::= one of
u U
21. <long-suffix>::= one of
l L
22. <long-long-suffix>::= one of
ll LL
23. <floating-constant>::=
<decimal-floating-constant>
| <hexadecimal-floating-constant>
24. <decimal-floating-constant>::=
<fractional-constant> <exponent-part>_opt <floating-suffix>_opt
| <digit-sequence> <exponent-part> <floating-suffix>_opt
25. <hexadecimal-floating-constant>::=
<hexadecimal-prefix> <hexadecimal-fractional-constant>
| <binary-exponent-part> <floating-suffix>_opt
| <hexadecimal-prefix> <hexadecimal-digit-sequence>
| <binary-exponent-part> <floating-suffix>_opt
26. <fractional-constant>::=
<digit-sequence>_opt . <digit-sequence>
| <digit-sequence> .
27. <exponent-part>::=
e <sign>_opt <digit-sequence>
| E <sign>_opt <digit-sequence>
28. <sign>::= one of
+ -
29. <digit-sequence>::=
<digit>
| <digit-sequence> <digit>
30. <hexadecimal-fractional-constant>::=
<hexadecimal-digit-sequence>_opt .
| <hexadecimal-digit-sequence>
| <hexadecimal-digit-sequence> .
31. <binary-exponent-part>::=
p <sign>_opt <digit-sequence>
| P <sign>_opt <digit-sequence>
32. <hexadecimal-digit-sequence>::=
<hexadecimal-digit>
| <hexadecimal-digit-sequence> <hexadecimal-digit>
33. <floating-suffix>::= one of
flFL
34. <enumeration-constant>::=
<identifier>
35. <character-constant>::=
' <c-char-sequence> '
| L' <c-char-sequence> '
36. <c-char-sequence>::=
<c-char>
| <c-char-sequence> <c-char>
37. <c-char>::=
any member of the source character set except the single-quote ', backslash , or <new-line> character
| <escape-sequence>
38. <escape-sequence>::=
<simple-escape-sequence>
| <octal-escape-sequence>
| <hexadecimal-escape-sequence>
| <universal-character-name>
39. <simple-escape-sequence>::= one of
' " ?
a b f n r t v
40. <octal-escape-sequence>::=
<octal-digit>
| <octal-digit> <octal-digit>
| <octal-digit> <octal-digit> <octal-digit>
41. <hexadecimal-escape-sequence>::=
x <hexadecimal-digit>
| <hexadecimal-escape-sequence> <hexadecimal-digit>
42. <string-literal>::=
" <s-char-sequence>_opt "
| L" <s-char-sequence>_opt "
43. <s-char-sequence>::=
<s-char>
| <s-char-sequence> <s-char>
44. <s-char>::=
any member of the source character set except the double-quote ", backslash , or <new-line> character
| <escape-sequence>
45. <punctuator>::= one of
[ ] ( ) { } . ->
++ -- & * + - ~ !
/ % << >> < > <= >= == != ^ | && ||
? : ; ...
= *= /= %= += -= <<= >>= &= ^= |=
, # ##
<: :> <% %> %: %:%:
46. <header-name>::=
< <h-char-sequence> >
| " <q-char-sequence> "
47. <h-char-sequence>::=
<h-char>
| <h-char-sequence> <h-char>
48. <h-char>::=
any member of the source character set except the <new-line> character and >
49. <q-char-sequence>::=
<q-char>
| <q-char-sequence> <q-char>
50. <q-char>::=
any member of the source character set except the <new-line> character and "
51. <pp-number>::=
<digit>
| . <digit>
| <pp-number> <digit>
| <pp-number> <identifier-nondigit>
| <pp-number> e <sign>
| <pp-number> E <sign>
| <pp-number> p <sign>
| <pp-number> P <sign>
| <pp-number> .
52. <primary-expression>::=
<identifier>
| <constant>
| <string-literal>
| ( <expression> )
53. <postfix-expression>::=
<primary-expression>
| <postfix-expression> [ <expression> ]
| <postfix-expression> ( <argument-expression-list>_opt )
| <postfix-expression> . <identifier>
| <postfix-expression> -> <identifier>
| <postfix-expression> ++
| <postfix-expression> --
| ( <type-name> ) { <initializer-list> }
| ( <type-name> ) { <initializer-list> , }
54. <argument-expression-list>::=
<assignment-expression>
| <argument-expression-list> , <assignment-expression>
55. <unary-expression>::=
<postfix-expression>
| ++ <unary-expression>
| -- <unary-expression>
| <unary-operator> <cast-expression>
| sizeof <unary-expression>
| sizeof ( <type-name> )
56. <unary-operator>::= one of
& * + - ~ !
57. <cast-expression>::=
<unary-expression>
| ( <type-name> ) <cast-expression>
58. <multiplicative-expression>::=
<cast-expression>
| <multiplicative-expression> * <cast-expression>
| <multiplicative-expression> / <cast-expression>
| <multiplicative-expression> % <cast-expression>
59. <additive-expression>::=
<multiplicative-expression>
| <additive-expression> + <multiplicative-expression>
| <additive-expression> - <multiplicative-expression>
60. <shift-expression>::=
<additive-expression>
| <shift-expression> << <additive-expression>
| <shift-expression> >> <additive-expression>
61. <relational-expression>::=
<shift-expression>
| <relational-expression> < <shift-expression>
| <relational-expression> > <shift-expression>
| <relational-expression> <= <shift-expression>
| <relational-expression> >= <shift-expression>
62. <equality-expression>::=
<relational-expression>
| <equality-expression> == <relational-expression>
| <equality-expression> != <relational-expression>
63. <AND-expression>::=
<equality-expression>
| <AND-expression> & <equality-expression>
64. <exclusive-OR-expression>::=
<AND-expression>
| <exclusive-OR-expression> ^ <AND-expression>
65. <inclusive-OR-expression>::=
<exclusive-OR-expression>
| <inclusive-OR-expression> | <exclusive-OR-expression>
66. <logical-AND-expression>::=
<inclusive-OR-expression>
| <logical-AND-expression> && <inclusive-OR-expression>
67. <logical-OR-expression>::=
<logical-AND-expression>
| <logical-OR-expression> || <logical-AND-expression>
68. <conditional-expression>::=
<logical-OR-expression>
| <logical-OR-expression> ? <expression> : <conditional-expression>
69. <assignment-expression>::=
<conditional-expression>
| <unary-expression> <assignment-operator> <assignment-expression>
70. <assignment-operator>::= one of
= *= /= %= += -= <<= >>= &= ^= |=
71. <expression>::=
<assignment-expression>
| <expression> , <assignment-expression>
72. <constant-expression>::=
<conditional-expression>
73. <declaration>::=
<declaration-specifiers> <init-declarator-list>_opt ;
74. <declaration-specifiers>::=
<storage-class-specifier> <declaration-specifiers>_opt
| <type-specifier> <declaration-specifiers>_opt
| <type-qualifier> <declaration-specifiers>_opt
| <function-specifier> <declaration-specifiers>_opt
75. <init-declarator-list>::=
<init-declarator>
| <init-declarator-list> , <init-declarator>
76. <init-declarator>::=
<declarator>
| <declarator> = <initializer>
77. <storage-class-specifier>::=
typedef
| extern
| static
| auto
| register
78. <type-specifier>::=
void
| char
| short
| int
| long
| float
| double
| signed
| unsigned
| _Bool
| _Complex
| <struct-or-union-specifier>
| <enum-specifier>
| <typedef-name>
79. <struct-or-union-specifier>::=
<struct-or-union> <identifier>_opt { <struct-declaration-list> }
| <struct-or-union> <identifier>
80. <struct-or-union>::=
struct
| union
81. <struct-declaration-list>::=
<struct-declaration>
| <struct-declaration-list> <struct-declaration>
82. <struct-declaration>::=
<specifier-qualifier-list> <struct-declarator-list> ;
83. <specifier-qualifier-list>::=
<type-specifier> <specifier-qualifier-list>_opt
| <type-qualifier> <specifier-qualifier-list>_opt
84. <struct-declarator-list>::=
<struct-declarator>
| <struct-declarator-list> , <struct-declarator>
85. <struct-declarator>::=
<declarator>
| <declarator>_opt : <constant-expression>
86. <enum-specifier>::=
enum <identifier>_opt { <enumerator-list> }
| enum <identifier>_opt { <enumerator-list> , }
| enum <identifier>
87. <enumerator-list>::=
<enumerator>
| <enumerator-list> , <enumerator>
88. <enumerator>::=
<enumeration-constant>
| <enumeration-constant> = <constant-expression>
89. <type-qualifier>::=
const
| restrict
| volatile
90. <function-specifier>::=
inline
91. <declarator>::=
<pointer>_opt <direct-declarator>
92. <direct-declarator>::=
<identifier>
| ( <declarator> )
| <direct-declarator> [ <type-qualifier-list>_opt <assignment-expression>_opt ]
| <direct-declarator> [ static <type-qualifier-list>_opt <assignment-expression> ]
| <direct-declarator> [ <type-qualifier-list> static <assignment-expression> ]
| <direct-declarator> [ <type-qualifier-list>_opt * ]
| <direct-declarator> ( <parameter-type-list> )
| <direct-declarator> ( <identifier-list>_opt )
93. <pointer>::=
* <type-qualifier-list>_opt
| * <type-qualifier-list>_opt <pointer>
94. <type-qualifier-list>::=
<type-qualifier>
| <type-qualifier-list> <type-qualifier>
95. <parameter-type-list>::=
<parameter-list>
| <parameter-list> , ...
96. <parameter-list>::=
<parameter-declaration>
| <parameter-list> , <parameter-declaration>
97. <parameter-declaration>::=
<declaration-specifiers> <declarator>
| <declaration-specifiers> <abstract-declarator>_opt
98. <identifier-list>::=
<identifier>
| <identifier-list> , <identifier>
99. <type-name>::=
<specifier-qualifier-list> <abstract-declarator>_opt
100. <abstract-declarator>::=
<pointer>
| <pointer>_opt <direct-abstract-declarator>
101. <direct-abstract-declarator>::=
( <abstract-declarator> )
| <direct-abstract-declarator>_opt [ <assignment-expression>_opt ]
| <direct-abstract-declarator>_opt [*]
| <direct-abstract-declarator>_opt ( <parameter-type-list>_opt )
102. <typedef-name>::=
<identifier>
103. <initializer>::=
<assignment-expression>
| { <initializer-list> }
| { <initializer-list> , }
104. <initializer-list>::=
<designation>_opt <initializer>
| <initializer-list> , <designation>_opt <initializer>
105. <designation>::=
<designator-list> =
106. <designator-list>::=
<designator>
| <designator-list> <designator>
107. <designator>::=
[ <constant-expression> ]
| . <identifier>
108. <statement>::=
<labeled-statement>
| <compound-statement>
| <expression-statement>
| <selection-statement>
| <iteration-statement>
| <jump-statement>
109. <labeled-statement>::=
<identifier> : <statement>
| case <constant-expression> : <statement>
| default : <statement>
110. <compound-statement>::=
{ <block-item-list>_opt }
111. <block-item-list>::=
<block-item>
| <block-item-list> <block-item>
112. <block-item>::=
<declaration>
| <statement>
113. <expression-statement>::=
<expression>_opt ;
114. <selection-statement>::=
if ( <expression> ) <statement>
| if ( <expression> ) <statement> else <statement>
| switch ( <expression> ) <statement>
115. <iteration-statement>::=
while ( <expression> ) <statement>
| do <statement> while ( <expression> ) ;
| for ( <expression>_opt ; <expression>_opt ; <expression>_opt ) <statement>
| for ( <declaration> <expression>_opt ; <expression>_opt ) <statement>
116. <jump-statement>::=
goto <identifier> ;
| continue ;
| break ;
| return <expression>_opt ;
117. <translation-unit>::=
<external-declaration>
| <translation-unit> <external-declaration>
118. <external-declaration>::=
<function-definition>
| <declaration>
119. <function-definition>::=
<declaration-specifiers> <declarator> <declaration-list>_opt <compound-statement>
120. <declaration-list>::=
<declaration>
| <declaration-list> <declaration>
121. <preprocessing-file>::=
<group>_opt
122. <group>::=
<group-part>
| <group> <group-part>
123. <group-part>::=
<if-section>
| <control-line>
| <text-line>
| # <non-directive>
124. <if-section>::=
<if-group> <elif-groups>_opt <else-group>_opt <endif-line>
125. <if-group>::=
# if <constant-expression> <new-line> <group>_opt
| # ifdef <identifier> <new-line> <group>_opt
| # ifndef <identifier> <new-line> <group>_opt
126. <elif-groups>::=
<elif-group>
| <elif-groups> <elif-group>
127. <elif-group>::=
# elif <constant-expression> <new-line> <group>_opt
128. <else-group>::=
# else <new-line> <group>_opt
129. <endif-line>::=
# endif <new-line>
130. <control-line>::=
# include <pp-tokens> <new-line>
| # define <identifier> <replacement-list> <new-line>
| # define <identifier> <lparen> <identifier-list>_opt ) <replacement-list> <new-line>
| # define <identifier> <lparen> ... ) <replacement-list> <new-line>
| # define <identifier> <lparen> <identifier-list> , ... ) <replacement-list> <new-line>
| # undef <identifier> <new-line>
| # line <pp-tokens> <new-line>
| # error <pp-tokens>_opt <new-line>
| # pragma <pp-tokens>_opt <new-line>
| # <new-line>
131. <text-line>::=
<pp-tokens>_opt <new-line>
132. <non-directive>::=
<pp-tokens> <new-line>
133. <lparen>::=
a ( character not immediately preceded by white-space
134. <replacement-list>::=
<pp-tokens>_opt
135. <pp-tokens>::=
<preprocessing-token>
| <pp-tokens> <preprocessing-token>
136. <new-line>::=
the new-line character
