blob: 284a3de3ab4860d63bd90dc47982cfa47b3a2bf1 (
plain)
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
|
# 第17b章の文法
[English](17-grammar.md) | 日本語
```antlrv4
grammar SimpleLanguage;
// Name lookup, assignable operands, type compatibility, and access permissions
// are checked by the compiler in addition to these syntax rules.
program : statement* EOF ;
block : '{' statement* '}' ;
statement
: block
| returnStatement
| ifStatement
| whileStatement
| forStatement
| breakStatement
| continueStatement
| structDeclaration
| declaration ';'
| assignment ';'
| ';'
;
returnStatement : 'return' assignment ';' ;
ifStatement : 'if' '(' assignment ')' statement ('else' statement)? ;
whileStatement : 'while' '(' assignment ')' statement ;
breakStatement : 'break' ';' ;
continueStatement : 'continue' ';' ;
forStatement
: 'for' '(' (declaration | assignment)? ';' assignment? ';' assignment? ')' statement
;
structDeclaration : 'struct' IDENTIFIER block ';' ;
declaration : declarationType binding (',' binding)* ;
declarationType : type | 'var' | 'val' ;
binding : bindingModifier? IDENTIFIER ('=' initializer)? ;
bindingModifier : '!' | '~' ;
initializer : assignment ;
// The prefix qualifies the named struct reference, not an enclosing array.
// Each [] / [~] suffix qualifies its own array layer. ? requires a reference.
type
: primitiveType typeSuffix*
| accessModifier? typeName typeSuffix*
;
accessModifier : '!' | '~' ;
typeSuffix : '?' | '[]' | '[~]' ;
typeName : IDENTIFIER ;
primitiveType
: 'int' | 'i8' | 'i16' | 'i32' | 'i64'
| 'u1' | 'u8' | 'u16' | 'u32' | 'byte' | 'bool'
| 'flt' | 'f32' | 'f64'
;
assignment : expression (assignmentOperator assignment)? ;
assignmentOperator
: '=' | '+=' | '-=' | '*=' | '/=' | '&=' | '|=' | '^='
| '<<=' | '>>=' | '>>>='
;
expression : bitwiseExpression ('?' assignment (':' assignment)?)? ;
bitwiseExpression
: comparisonExpression (('&' | '|' | '^') comparisonExpression)*
;
comparisonExpression
: shiftExpression (('==' | '!=' | '<' | '<=' | '>' | '>=') shiftExpression)*
;
shiftExpression
: additiveExpression (('<<' | '>>' | '>>>') additiveExpression)*
;
additiveExpression
: multiplicativeExpression (('+' | '-') multiplicativeExpression)*
;
multiplicativeExpression
: unaryExpression (('*' | '/') unaryExpression)*
;
unaryExpression
: ('-' | '!') unaryExpression
| updateOperator IDENTIFIER
| postfixExpression
;
// Prefix updates require a local name; postfix updates also allow fields
// and array elements. All updates require an assignable operand.
updateOperator : '++' | '--' ;
postfixExpression : primaryExpression postfixSuffix* updateOperator? ;
postfixSuffix : '.' IDENTIFIER | '[' assignment ']' | '#' ;
primaryExpression
: INTEGER_LITERAL
| FLOAT_LITERAL
| 'true'
| 'false'
| 'null'
| IDENTIFIER
| '(' assignment ')'
| newExpression
;
// Struct initialization uses a block; array allocation supplies a length.
newExpression : 'new' type ('[' assignment ']' | block)? ;
INTEGER_LITERAL : '0' | [1-9] DIGIT* ;
FLOAT_LITERAL : DIGIT+ ('.' DIGIT* ('e' DIGIT+)? | 'e' DIGIT+) ;
IDENTIFIER : NON_DIGIT (NON_DIGIT | DIGIT)* ;
fragment NON_DIGIT : [a-zA-Z_] ;
fragment DIGIT : [0-9] ;
WHITESPACE : [ \t\r\n]+ -> skip ;
LINE_COMMENT : '//' ~[\r\n]* -> skip ;
```
|
