loom

1
/*  Описание грамматики языка сценариев (ЯС)
2

3
    Базовый вариант без списковых выражений и возвратов, объявления структур, функций и т.д.
4
*/
5

6
lex {
7
    lex.addMarkup("/*", "*/", "", lex.LexemeType.Comment);
8
    lex.addMarkup("//", "", "", lex.LexemeType.Comment);
9
}
10

11

12
include "expression";
13

14
main список_операторов_ЯС;
15

16
список_операторов_ЯС
17
    = оператор_ЯС
18
    = список_операторов_ЯС оператор_ЯС
19
    ;
20
    оператор_ЯС
21
        = пустой_оператор
22
        = оператор_use
23
        = оператор_using
24
        = объявление_функции
25
        = определение_функции
26
        = объявление_переменной
27
        = объявление_массива
28
        = определение_переменной
29
        = оператор_присваивания
30
        = вызов_процедуры
31
        = оператор_управления
32
        = оператор_return
33
        = условный_оператор
34
        = цикл_while
35
        = цикл_do_while
36
        = цикл_for
37
//      = оператор_ветвления
38
        = блок_операторов
39
        = оператор_итерации
40
        ;
41
        пустой_оператор
42
            = ";"
43
                                    { ast.addNode(ast.op.Statement_Blank, 0); }
44
            ;
45
        оператор_use
46
            = use_as_type_выражение ";"
47
            ;
48
        оператор_using
49
            = "using" ID ";"        { ast.addNode(ast.op.Statement_Using, 1); }
50
            ;
51
        объявление_переменной
52
//            = тип имя_переменной1 ";"
53
//                                    { ast.goParent(); }
54
            = имя_типа имя_переменной1 ";"
55
                                    { ast.goParent(); }
56
            ;
57
            имя_типа
58
                = ID                { ast.addNode(ast.op.Statement_Type, 0); }
59
                ;
60
        объявление_массива
61
//            = тип имя_переменной1 размерность_массива ";"
62
//                                    { ast.goParent(); }
63
            = имя_типа имя_переменной1 размерность_массива ";"
64
                                    { ast.goParent(); }
65
            ;
66
            размерность_массива
67
                = знак_начала_размерности_массива перечень_размерностей_массива "]"
68
                                    { ast.goParent(); }
69
                = знак_начала_размерности_массива "]"
70
                                    { ast.goParent(); }
71
                ;
72
                знак_начала_размерности_массива
73
                    = "["           { ast.addNode_StepInto(ast.op.None, 0); }
74
                    ;
75
                перечень_размерностей_массива
76
                    = выражение
77
                    = перечень_размерностей_массива "," выражение
78
                    ;
79
        определение_переменной
80
//            = тип имя_переменной1 присваивание_при_объявлении_переменной правая_часть_объявления ";"
81
//                                    { ast.goParent(); }
82
//            = тип имя_переменной1 размерность_массива присваивание_при_объявлении_переменной правая_часть_объявления ";"
83
//                                    { ast.goParent(); }
84
            = имя_типа имя_переменной1 присваивание_при_объявлении_переменной правая_часть_объявления ";"
85
                                    { ast.goParent(); }
86
            = имя_типа имя_переменной1 размерность_массива присваивание_при_объявлении_переменной правая_часть_объявления ";"
87
                                    { ast.goParent(); }
88
            ;
89
            имя_переменной1
90
                = ID                { ast.addNode_ShiftInto(ast.op.Statement_Id, 0); }
91
                ;
92
        //TODO: Semantic: Для функций нужно проверять, чтобы их объявления и определения были в самом верхнем уровне вложенности блоков
93
        объявление_функции
94
            = декларативная_часть ";"
95
                                    { ast.goParent(); }
96
            ;
97
        определение_функции
98
            = декларативная_часть тело_функции
99
                                    { ast.goParent(); }
100
            ;
101
            декларативная_часть
102
                = имя_типа имя_функции1 список_аргументов
103
                ;
104
            список_аргументов
105
                = начало_списка_аргументов конец_списка_аргументов
106
                = начало_списка_аргументов объявление_аргументов_функции конец_списка_аргументов
107
                ;
108
//            тип
109
//                = "int"             { ast.addNode(ast.op.Statement_Type, 0); }
110
//                = "float"           { ast.addNode(ast.op.Statement_Type, 0); }
111
//                = "bool"            { ast.addNode(ast.op.Statement_Type, 0); }
112
//                = "string"          { ast.addNode(ast.op.Statement_Type, 0); }
113
//                //TODO: Semantic: Нужно проверять, чтобы у переменной не было типа void, а у функции auto
114
//                = "void"            { ast.addNode(ast.op.Statement_Type, 0); }
115
//                = "auto"            { ast.addNode(ast.op.Statement_Type, 0); }
116
//                ;
117
            имя_функции1
118
                = ID                { ast.addNode_ShiftInto(ast.op.Statement_Id, 0); }
119
                ;
120
            присваивание_при_объявлении_переменной
121
                = "="               { ast.addNode_StepInto(ast.op.Statement_Assign, 0); }
122
                ;
123
            правая_часть_объявления
124
                = выражение         { ast.goParent(); }
125
                = элементы_массива  { ast.goParent(); }
126
                = элементы_кортежа  { ast.goParent(); }
127
                ;
128
            начало_списка_аргументов
129
                = "("               { ast.addNode_StepInto(ast.op.Function_Declaration, 0); }
130
                ;
131
            конец_списка_аргументов
132
                = ")"               { ast.goParent(); }
133
                ;
134
            объявление_аргументов_функции
135
                = аргумент_функции
136
                = объявление_аргументов_функции "," аргумент_функции
137
                ;
138
            аргумент_функции
139
//                = тип
140
//                = тип ID            { ast.addNode_Branch(ast.op.None, 1); }
141
                = ID                { ast.addNode(ast.op.Statement_Type, 0); }
142
                = ID ID             { ast.addNode(ast.op.Statement_Type, 0); ast.addNode_Branch(ast.op.None, 1); }
143
//                = ID "[" "]"        { ast.addNode(ast.op.Statement_Type, 0); ast.addNode(ast.op.Address_Array, 1); }
144
//                = ID ID "[" "]"     {
145
//                                        ast.addNode(ast.op.Statement_Type, 0);
146
//                                        ast.addNode(ast.op.Address_Array, 2);
147
//                                        ast.addNode_Branch(ast.op.None, 1);
148
//                                    }
149
//                = ID "[" "]" ID     {
150
//                                        ast.addNode(ast.op.Statement_Type, 0);
151
//                                        ast.addNode(ast.op.Address_Array, 1);
152
//                                        ast.addNode_Branch(ast.op.None, 3);
153
//                                    }
154
                ;
155
            тело_функции
156
                = начало_тела_функции список_операторов_ЯС "}"
157
                                    { ast.addNode(ast.op.None, 2); ast.goParent(); }
158
                = начало_тела_функции "}"
159
                                    { ast.addNode(ast.op.None, 1); ast.goParent(); }
160
                ;
161
                начало_тела_функции
162
                    = "{"           { ast.addNode_StepInto(ast.op.Function_Body, 0); }
163
                    ;
164

165
        оператор_присваивания
166
            = адрес символ_присваивания выражение ";"
167
                                    {
168
                                        ast.goParent();
169
                                        ast.goParent();
170
                                    }
171
            ;
172
            символ_присваивания
173
                = "="               { ast.addNode_Assignment(ast.op.Statement_Assign, 0); }
174
                = "+="              { ast.addNode_Assignment(ast.op.Statement_Assign_Addition, 0); }
175
                = "-="              { ast.addNode_Assignment(ast.op.Statement_Assign_Substruction, 0); }
176
                = "*="              { ast.addNode_Assignment(ast.op.Statement_Assign_Multiplication, 0); }
177
                = "/="              { ast.addNode_Assignment(ast.op.Statement_Assign_Division, 0); }
178
                = "%="              { ast.addNode_Assignment(ast.op.Statement_Assign_Modulo, 0); }
179
                ;
180

181
        вызов_процедуры
182
            = адрес ";"
183
                                    { ast.resetOperation_ProcedureCalling(); }
184
            ;
185

186
        оператор_управления
187
            = "break" ";"
188
                                    { ast.addNode(ast.op.Statement_Break, 0); }
189
            = "continue" ";"
190
                                    { ast.addNode(ast.op.Statement_Continue, 0); }
191
            ;
192

193
        оператор_return
194
            = слово_return ";"
195
                                    { ast.goParent(); }
196
            = слово_return выражение ";"
197
                                    { ast.goParent(); }
198
            ;
199
            слово_return
200
                = "return"
201
                                    { ast.addNode_StepInto(ast.op.Statement_Return, 0); }
202
                ;
203

204
        условный_оператор
205
            = "if" "(" условие_if ")" оператор_ЯС >
206
                                    { ast.goParent(); }
207
            = "if" "(" условие_if ")" оператор_ЯС условие_else
208
                                    { ast.goParent(); }
209
            ;
210
            условие_if
211
                = выражение         { ast.addNode_StepInto(ast.op.Statement_If_True, 0); }
212
                ;
213
            условие_else
214
                = слово_else оператор_ЯС
215
                ;
216
                слово_else
217
                    = "else"            { ast.addNode_Parent_StepInto(ast.op.Statement_If_False, 0); }
218
                    ;
219

220
        цикл_while
221
            = слово_while "(" условие_while ")" оператор_ЯС
222
                                    {
223
                                        ast.goParent();
224
                                        ast.goParent();
225
                                    }
226
            ;
227
            слово_while
228
                = "while"           {
229
                                        ast.addNode_StepInto(ast.op.Statement_While, 0);
230
                                        ast.addNode_StepInto(ast.op.None, 0);
231
                                    }
232
                ;
233
            условие_while
234
                = выражение         { ast.addNode_Parent_StepInto(ast.op.Statement_While_Body, 0); }
235
                ;
236

237
        цикл_do_while
238
            = слово_do оператор_DoWhile "while" "(" выражение ")" ";"
239
                                    {
240
                                        ast.goParent();
241
                                        ast.goParent();
242
                                    }
243
            ;
244
            слово_do
245
                = "do"              {
246
                                        ast.addNode_StepInto(ast.op.Statement_DoWhile, 0);
247
                                        ast.addNode_StepInto(ast.op.Statement_DoWhile_Body, 0);
248
                                    }
249
                ;
250
            оператор_DoWhile
251
                = оператор_ЯС       { ast.addNode_Parent_StepInto(ast.op.None, 0); }
252
                ;
253

254
        цикл_for
255
            = слово_for "(" цикл_for_переменная_цикла цикл_for_проверка цикл_for_итерация оператор_for
256
                                    {
257
                                        ast.goParent();
258
                                        ast.goParent();
259
                                    }
260
            ;
261
            слово_for
262
                = "for"             {
263
                                        ast.addNode_StepInto(ast.op.Statement_For, 0);
264
                                        ast.addNode_StepInto(ast.op.None, 0);
265
                                    }
266
                ;
267
            цикл_for_переменная_цикла
268
                = определение_переменной
269
                                    { ast.addNode_Parent_StepInto(ast.op.None, 0); }
270
                = оператор_присваивания
271
                                    { ast.addNode_Parent_StepInto(ast.op.None, 0); }
272
                = ";"
273
                                    { ast.addNode_Parent_StepInto(ast.op.None, 0); }
274
                ;
275
            цикл_for_проверка
276
                = выражение ";"
277
                                    { ast.addNode_Parent_StepInto(ast.op.None, 0); }
278
                = ";"
279
                                    { ast.addNode_Parent_StepInto(ast.op.None, 0); }
280
                ;
281
            цикл_for_итерация
282
                = итерация ")"      { ast.addNode_Parent_StepInto(ast.op.Statement_For_Body, 0); }
283
                = ")"               { ast.addNode_Parent_StepInto(ast.op.Statement_For_Body, 0); }
284
                ;
285
            оператор_for
286
                = оператор_ЯС
287
                ;
288
//      оператор_ветвления
289
//          = "switch" "(" выражение_switch ")" "{" перечень_случаев_switch "}"
290
//          = "switch" "(" выражение_switch ")" "{" перечень_случаев_switch дефолтный_случай_switch "}"
291
//          ;
292
//          выражение_switch
293
//              = выражение
294
//              ;
295
//          перечень_случаев_switch
296
//              = случай_switch
297
//              = перечень_случаев_switch случай_switch
298
//              ;
299
//          случай_switch
300
//              = "case" константа_case ":" список_операторов_ЯС
301
//              ;
302
//          дефолтный_случай_switch
303
//              = "default" ":" список_операторов_ЯС
304
//              ;
305
//          константа_case
306
//              = NUMBER
307
//              = ANNOTATION
308
//              = ID
309
//              ;
310

311
        блок_операторов
312
            = начало_блока_операторов список_операторов_ЯС "}"
313
                                    { ast.addNode(ast.op.None, 2); ast.goParent(); }
314
            = начало_блока_операторов "}"
315
                                    { ast.addNode(ast.op.None, 1); ast.goParent(); }
316
            ;
317
            начало_блока_операторов
318
                = "{"               { ast.addNode_StepInto(ast.op.Statement_Block, 0); }
319
                ;
320

321
        оператор_итерации
322
            = итерация ";"
323
                                    { ast.addNode(ast.op.InternalPop, 1); }
324
            ;
325

326
            элементы_массива
327
    = знак_начала_массива перечень_элементов_массива "]" {
328
                                ast.goParent();
329
                            }
330
    = знак_начала_массива "]" {
331
                                ast.goParent();
332
                            }
333
    ;
334
    знак_начала_массива
335
        = "["               {
336
                                ast.addNode_StepInto(ast.op.DataStructure_Array, 0);
337
                            }
338
        ;
339
    перечень_элементов_массива
340
        = список_значений_массива
341
        = список_значений_массива ","
342
        ;
343
        список_значений_массива
344
            = элемент_массива
345
            = список_значений_массива "," элемент_массива
346
            ;
347
            элемент_массива
348
                = элементы_массива
349
                = элементы_кортежа
350
                = выражение
351
                ;
352

353
элементы_кортежа
354
    = знак_начала_кортежа перечень_элементов_кортежа "}" {
355
                                ast.goParent();
356
                            }
357
    = знак_начала_кортежа "}" {
358
                                ast.goParent();
359
                            }
360
    ;
361
    знак_начала_кортежа
362
        = "{"               {
363
                                ast.addNode_StepInto(ast.op.DataStructure_Tuple, 0);
364
                            }
365
        ;
366
    перечень_элементов_кортежа
367
        = список_элементов_кортежа
368
        = список_элементов_кортежа ","
369
        ;
370
        список_элементов_кортежа
371
            = элемент_кортежа
372
            = список_элементов_кортежа "," элемент_кортежа
373
            ;
374
            элемент_кортежа
375
                = наименование_элемента_кортежа ":" значение_элемента_кортежа {
376
                                ast.goParent();
377
                            }
378
                ;
379
                наименование_элемента_кортежа
380
                    = ANNOTATION {
381
                                ast.addNode_StepInto(ast.op.None, 0);
382
                            }
383
                    = ID    {
384
                                ast.addNode_StepInto(ast.op.None, 0);
385
                            }
386
                    ;
387
                значение_элемента_кортежа
388
                    = элементы_массива
389
                    = элементы_кортежа
390
                    = выражение
391
                    ;
392

393
use_as_type_выражение
394
    = use_as_type_часть_с_типом
395
                                { ast.goParent(); }
396

397
// приводит к ошибке при определённой последовательности расположении операторов use as type
398
    = use_as_type_часть_с_типом ID
399
                                { ast.addNode(ast.op.Statement_Id, 1); ast.goParent(); }
400
    ;
401
    use_as_type_часть_с_типом
402
        = начало_оператора_use имя_модуля "as" "type" ID
403
                                { ast.addNode(ast.op.Statement_Type, 4); }
404
        ;
405
        начало_оператора_use
406
            = "use"             { ast.addNode_StepInto(ast.op.Statement_UseAsType, 0); }
407
            ;
408
        имя_модуля
409
            = ANNOTATION        { ast.addNode(ast.op.None, 0); }
410
            = ANNOTATION "(" ANNOTATION ")"
411
                                { ast.addNode_StepInto(ast.op.None, 0); ast.addNode(ast.op.None, 2); ast.goParent(); }
412
            ;
413