-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathchapter-2.txt
149 lines (93 loc) · 6 KB
/
chapter-2.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
Chapter 2. Grammars
Table of Contents
2.1. Context-Free Grammars
2.2. The Lexical Grammar
2.3. The Syntactic Grammar
2.4. Grammar Notation
This chapter describes the context-free grammars used in this specification to define the lexical and syntactic structure of a program.
2.1. Context-Free Grammars
A context-free grammar consists of a number of productions. Each production has an abstract symbol called a nonterminal as its left-hand side, and a sequence of one or more nonterminal and terminal symbols as its right-hand side. For each grammar, the terminal symbols are drawn from a specified alphabet.
Starting from a sentence consisting of a single distinguished nonterminal, called the goal symbol, a given context-free grammar specifies a language, namely, the set of possible sequences of terminal symbols that can result from repeatedly replacing any nonterminal in the sequence with a right-hand side of a production for which the nonterminal is the left-hand side.
2.2. The Lexical Grammar
A lexical grammar for the Java programming language is given in §3 (Lexical Structure). This grammar has as its terminal symbols the characters of the Unicode character set. It defines a set of productions, starting from the goal symbol Input (§3.5), that describe how sequences of Unicode characters (§3.1) are translated into a sequence of input elements (§3.2).
These input elements, with white space (§3.6) and comments (§3.7) discarded, form the terminal symbols for the syntactic grammar for the Java programming language and are called tokens (§3.5). These tokens are the identifiers (§3.8), keywords (§3.9), literals (§3.10), separators (§3.11), and operators (§3.12) of the Java programming language.
2.3. The Syntactic Grammar
The syntactic grammar for the Java programming language is given in Chapters 4, 6-10, 14, and 15. This grammar has as its terminal symbols the tokens defined by the lexical grammar. It defines a set of productions, starting from the goal symbol CompilationUnit (§7.3), that describe how sequences of tokens can form syntactically correct programs.
For convenience, the syntactic grammar is presented all together in Chapter 19.
2.4. Grammar Notation
Terminal symbols are shown in fixed width font in the productions of the lexical and syntactic grammars, and throughout this specification whenever the text is directly referring to such a terminal symbol. These are to appear in a program exactly as written.
Nonterminal symbols are shown in italic type. The definition of a nonterminal is introduced by the name of the nonterminal being defined, followed by a colon. One or more alternative definitions for the nonterminal then follow on succeeding lines.
For example, the syntactic production:
IfThenStatement:
if ( Expression ) Statement
states that the nonterminal IfThenStatement represents the token if, followed by a left parenthesis token, followed by an Expression, followed by a right parenthesis token, followed by a Statement.
The syntax {x} on the right-hand side of a production denotes zero or more occurrences of x.
For example, the syntactic production:
ArgumentList:
Argument {, Argument}
states that an ArgumentList consists of an Argument, followed by zero or more occurrences of a comma and an Argument. The result is that an ArgumentList may contain any positive number of arguments.
The syntax [x] on the right-hand side of a production denotes zero or one occurrences of x. That is, x is an optional symbol. The alternative which contains the optional symbol actually defines two alternatives: one that omits the optional symbol and one that includes it.
This means that:
BreakStatement:
break [Identifier] ;
is a convenient abbreviation for:
BreakStatement:
break ;
break Identifier ;
As another example, it means that:
BasicForStatement:
for ( [ForInit] ; [Expression] ; [ForUpdate] ) Statement
is a convenient abbreviation for:
BasicForStatement:
for ( ; [Expression] ; [ForUpdate] ) Statement
for ( ForInit ; [Expression] ; [ForUpdate] ) Statement
which in turn is an abbreviation for:
BasicForStatement:
for ( ; ; [ForUpdate] ) Statement
for ( ; Expression ; [ForUpdate] ) Statement
for ( ForInit ; ; [ForUpdate] ) Statement
for ( ForInit ; Expression ; [ForUpdate] ) Statement
which in turn is an abbreviation for:
BasicForStatement:
for ( ; ; ) Statement
for ( ; ; ForUpdate ) Statement
for ( ; Expression ; ) Statement
for ( ; Expression ; ForUpdate ) Statement
for ( ForInit ; ; ) Statement
for ( ForInit ; ; ForUpdate ) Statement
for ( ForInit ; Expression ; ) Statement
for ( ForInit ; Expression ; ForUpdate ) Statement
so the nonterminal BasicForStatement actually has eight alternative right-hand sides.
A very long right-hand side may be continued on a second line by clearly indenting the second line.
For example, the syntactic grammar contains this production:
NormalClassDeclaration:
{ClassModifier} class TypeIdentifier [TypeParameters] [ClassExtends] [ClassImplements] [ClassPermits] ClassBody
which defines one right-hand side for the nonterminal NormalClassDeclaration.
The phrase (one of) on the right-hand side of a production signifies that each of the symbols on the following line or lines is an alternative definition.
For example, the lexical grammar contains the production:
ZeroToThree:
(one of)
0 1 2 3
which is merely a convenient abbreviation for:
ZeroToThree:
0
1
2
3
When an alternative in a production appears to be a token, it represents the sequence of characters that would make up such a token.
Thus, the production:
BooleanLiteral:
(one of)
true false
is shorthand for:
BooleanLiteral:
t r u e
f a l s e
The right-hand side of a production may specify that certain expansions are not permitted by using the phrase "but not" and then indicating the expansions to be excluded.
For example:
Identifier:
IdentifierChars but not a ReservedKeyword or BooleanLiteral or NullLiteral
Finally, a few nonterminals are defined by a narrative phrase in roman type where it would be impractical to list all the alternatives.
For example:
RawInputCharacter:
any Unicode character