loom

1
/*  Описание грамматики базового языка сценариев SIMODO
2

3
    SIMODO Base Language.
4

5
    MIT License
6

7
    Copyright (c) 2021-2024 МГТУ им. Н.Э. Баумана, кафедра ИУ-6, Михаил Фетисов,
8

9
    https://bmstu.codes/lsx/simodo/stars
10
*/
11

12
main программа;
13

14
include "include/expression";
15
include "include/json5-array";
16
include "include/json5-object"; 
17

18
lex {
19
    lex.setNewLineSubstitution(";");
20
}
21

22
программа
23
    = список_операторов         { ast.addNode(ast.sbl.host, ast.sbl.op.CheckState, 0); }
24
    ;
25

26
/*  Дополняем выражение структурами данных, расширяющие грамматику выражений
27
******************************************************************************/
28
выражение
29
    = структура_массива
30
    = структура_объекта
31
    ;
32

33
элемент_списка_выражений 
34
    = определение_безымянной_функции
35
    = "&" выражение             { ast.addNode(ast.sbl.host, ast.sbl.op.Reference, 0); }
36
    ;
37

38
выражение_или_определение_безымянной_функции
39
    = выражение
40
    = определение_безымянной_функции
41
    = "&" выражение             { ast.addNode(ast.sbl.host, ast.sbl.op.Reference, 0); }
42
    ;
43
    
44
значение_элемента_объекта
45
    = определение_безымянной_функции
46
    = "&" выражение             { ast.addNode(ast.sbl.host, ast.sbl.op.Reference, 0); }
47
    ;
48

49
элемент_массива
50
    = определение_безымянной_функции
51
    = "&" выражение             { ast.addNode(ast.sbl.host, ast.sbl.op.Reference, 0); }
52
    ;
53

54
разделитель_элемента_объекта
55
    = "="
56
    ;
57
    
58
/*  Дополняем единицы измерения для базовых констант
59
******************************************************************************/
60
величина
61
/// \note Просто наименование е.и. без скобок конфликтует с объявлением типа на
62
/// следующей строке
63
/// \todo Нужно перенести разбор е.и. в лексику! Но для этого нужно будет дорабатывать библиотеку лексики.
64
//    = базовая_константа название_единицы_измерения
65
//                                { ast.goParent(); }
66
    = базовая_константа "(" единица_измерения ")" 
67
                                { ast.goParent(); }
68
    ;
69
    единица_измерения 
70
        = название_единицы_измерения >
71
        = название_единицы_измерения знак_отношения единица_измерения
72
        ;
73
        название_единицы_измерения
74
            = ID                { ast.addNode(ast.sbl.host, ast.sbl1.op.MeasureUnit, 0); }
75
            ;
76
        знак_отношения
77
            = "*"               { ast.addNode(ast.sbl.host, ast.sbl1.op.MeasureRatio, 0); }
78
            = "/"               { ast.addNode(ast.sbl.host, ast.sbl1.op.MeasureRatio, 0); }
79
            ;
80
    
81
/*  Начальные определения операторов
82
******************************************************************************/
83
список_операторов
84
    = оператор
85
    = список_операторов ";" оператор
86
    ;
87

88
оператор
89
    = оператор_описания
90
    = оператор_выполнения
91
    ;
92
    
93
/*  Оператор вывода на консоль
94
******************************************************************************/
95
оператор_выполнения
96
    = оператор_вывода_на_консоль
97
    ;
98

99
оператор_вывода_на_консоль
100
    = "print" выражение         { ast.addNode(ast.sbl.host, ast.sbl.op.Print, 0); }
101
    = "print" "all" выражение   { ast.addNode(ast.sbl.host, ast.sbl.op.Print, 1); }
102
    ;
103

104
/*  Оператор объявления переменной/типа
105
******************************************************************************/
106
оператор_описания
107
    = объявления_и_определения  { ast.addNode(ast.sbl.host, ast.sbl.op.Announcements_Completed, 0); }
108
    ;
109

110
объявления_и_определения
111
    = начало_перечня_контрактов определение_контракта
112
    = начало_перечня_контрактов определение_типа
113
    = начало_перечня_контрактов определение_типа инициализация_переменной
114
    = начало_перечня_контрактов определение_типа ":" список_определений_переменных
115
    = начало_перечня_контрактов ":" список_определений_переменных
116
    = начало_перечня_контрактов перечень_контрактов определение_контракта
117
    = начало_перечня_контрактов перечень_контрактов определение_типа
118
    = начало_перечня_контрактов перечень_контрактов определение_типа инициализация_переменной
119
    = начало_перечня_контрактов перечень_контрактов определение_типа ":" список_определений_переменных
120
    = начало_перечня_контрактов перечень_контрактов ":" список_определений_переменных
121
    ;
122

123
начало_перечня_контрактов 
124
    = ключевое_слово_начала_перечня_контрактов контракт
125
    = импорт                    { ast.addNode(ast.sbl.host, ast.sbl.op.Announcement, 0); }
126
    = "#" структура_объекта     { ast.addNode(ast.sbl.host, ast.sbl.op.Announcement, 0); }
127
    ;
128
    
129
ключевое_слово_начала_перечня_контрактов
130
    = "def" 
131
    = "define" 
132
    ;
133
    
134
перечень_контрактов
135
    = контракт 
136
    = перечень_контрактов контракт
137
    ;
138

139
контракт
140
    = адрес                     { ast.addNode(ast.sbl.host, ast.sbl.op.Announcement, 0); }
141
    = импорт                    { ast.addNode(ast.sbl.host, ast.sbl.op.Announcement, 0); }
142
    = "#" структура_объекта     { ast.addNode(ast.sbl.host, ast.sbl.op.Announcement, 0); }
143
    ;
144

145
импорт
146
    = импорт_обязательная_часть >
147
                                { ast.goParent(); }
148
    = импорт_обязательная_часть выражение
149
                                { ast.goParent(); }
150
    ;
151

152
импорт_обязательная_часть
153
    = "import" ANNOTATION       { ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.Import, 1); }
154
    = "import" ID               { ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.Import, 1); }
155
    ;
156
    
157
определение_типа
158
    = "type" ID                 { ast.addNode(ast.sbl.host, ast.sbl.op.Type, 1); }
159
    ;
160
    
161
определение_контракта
162
    = "contract" ID             { ast.addNode(ast.sbl.host, ast.sbl.op.Contract, 1); }
163
    ;
164
    
165
список_определений_переменных
166
    = объявление_или_определение_переменной
167
    = список_определений_переменных "," объявление_или_определение_переменной
168
    ;
169

170
объявление_или_определение_переменной
171
    = объявление_переменной
172
    = объявление_переменной инициализация_переменной
173
/// \todo Определение группы переменных нарушает семантику использования определяемой
174
/// переменной в выражении инициализации. Нужно поправить.
175
    = объявление_группы_переменных инициализация_переменной
176
//                                { ast.addNode(ast.sbl.host, ast.sbl.op.PostInitialize, 0); }
177
    ;
178

179
объявление_переменной
180
    = ID                        { ast.addNode(ast.sbl.host, ast.sbl.op.Declaration, 0); }
181
    ;
182
    
183
инициализация_переменной
184
    = знак_инициализации выражение_или_определение_безымянной_функции
185
                                { ast.goParent(); ast.addNode(ast.sbl.host, ast.sbl.op.PostInitialize, 0); }
186
    ;
187

188
знак_инициализации
189
    = "="                       { ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.Initialize, 0); }
190
    ;
191

192
/// \note Присвоение группе переменных с префиксом "[" конфликтует с операцией определения
193
/// индекса в массиве, если префикс находится с новой строки, а предыдущая строка
194
/// заканчивается на имя переменной.
195
///*  Оператор присвоения для группы переменных
196
//******************************************************************************/
197
//оператор_описания
198
//    = присвоение_группе_переменных
199
//    ;
200

201
//присвоение_группе_переменных
202
//    = объявление_группы_переменных инициализация_переменной_для_группы
203
//                                { ast.goParent(); ast.goParent(); }
204
//    ;
205

206
объявление_группы_переменных
207
    = начало_группы список_объявлений_элементов_группы "]"
208
                                { ast.goParent(); }
209
    ;
210

211
начало_группы
212
    = "["                       {
213
                                    ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.GroupInitialize, 0);
214
//                                    ast.addNode_StepInto(ast.sbl.host, ast.sbl1.op.GroupDeclaration, 0);
215
                                }
216
    ;
217

218
список_объявлений_элементов_группы
219
    = объявление_переменной_группы
220
    = первый_пропуск объявление_переменной_группы
221
    = ","                       { ast.addNode(ast.sbl.host, ast.sbl.op.Declaration, 0); }
222
    = список_объявлений_элементов_группы объявление_переменной_или_пропуск
223
    ;
224
    первый_пропуск
225
        = ","                   { ast.addNode(ast.sbl.host, ast.sbl.op.Declaration, 0); }
226
        ;
227

228
объявление_переменной_или_пропуск
229
    = "," объявление_переменной_группы
230
    = ","                       { ast.addNode(ast.sbl.host, ast.sbl.op.Declaration, 0); }
231
    ;
232

233
объявление_переменной_группы
234
    = ID                        { ast.addNode(ast.sbl.host, ast.sbl.op.Declaration, 0); }
235
    ;
236

237
//инициализация_переменной_для_группы
238
//    = начало_инициализация_переменной_для_группы выражение
239
//    ;
240

241
//начало_инициализация_переменной_для_группы
242
//    = "="                       { ast.addNode_StepInto(ast.sbl.host, ast.sbl1.op.GroupDefinition, 0); }
243
//    ;
244

245
/*  Определение безымянной функций
246
******************************************************************************/
247

248
определение_безымянной_функции
249
    = начало_объявления_функции часть_объявления_функции тело_функции
250
                                { 
251
                                    ast.goParent(); 
252
                                    ast.addNode(ast.sbl.host, ast.sbl.op.FunctionDefinitionEnd, 2);
253
                                }
254
    = начало_объявления_функции перечень_замыканий часть_объявления_функции тело_функции
255
                                { 
256
                                    ast.goParent(); 
257
                                    ast.addNode(ast.sbl.host, ast.sbl.op.FunctionDefinitionEnd, 3);
258
                                }
259
    ;
260
    
261
начало_объявления_функции
262
    = ключевое_слово_для_функции{ ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.FunctionDefinition, 0); }
263
    ;
264

265
ключевое_слово_для_функции
266
    = "function"                
267
    = "fn"                      
268
    ;
269

270
перечень_замыканий
271
    = начало_перечня_замыканий список_замыканий "]"
272
                                { ast.goParent(); }
273
    = начало_перечня_замыканий "]"
274
                                { ast.goParent(); }
275
    ;
276
    начало_перечня_замыканий
277
        = "["                   { ast.addNode_StepInto(ast.sbl.host, ast.sbl1.op.Function_Closure, 0); }
278
        ;
279
    список_замыканий
280
        = замыкание
281
        = список_замыканий "," замыкание
282
        ;
283
        замыкание
284
            = адрес_переменной_в_замыкании
285
                                { ast.goParent(); }
286
            ;
287

288
адрес_переменной_в_замыкании
289
    = ID                        { ast.addNode_StepInto(ast.sbl.host, ast.sbl1.op.Function_Closure_Id, 0); }
290
    = "*"                       { ast.addNode_StepInto(ast.sbl.host, ast.sbl1.op.Function_Closure_Id, 0); }
291
    ;
292

293
часть_объявления_функции
294
    = определение_аргументов возвращаемый_тип
295
    = определение_аргументов
296
    ;
297

298
определение_аргументов
299
    = начало_определения_аргументов список_аргументов ")"
300
                                { ast.goParent(); }
301
    = "(" ")"
302
    ;
303

304
начало_определения_аргументов
305
    = "("                       {
306
                                    ast.addNode_StepInto(ast.sbl.host, ast.sbl1.op.Function_Params, 0);
307
                                }
308
    ;
309

310
список_аргументов
311
    = определение_аргумента
312
    = список_аргументов разделитель_списка_аргументов определение_аргумента
313
    ;
314

315
разделитель_списка_аргументов
316
    = ","
317
    ;
318

319
определение_аргумента
320
/// \note Пока выключил безымянные параметры
321
//    = перечень_контрактов ":"   { 
322
//                                    ast.addNode(ast.sbl.host, ast.sbl1.op.Function_Parameter_Id, 0);
323
//                                    ast.addNode(ast.sbl.host, ast.sbl.op.Announcements_Completed, 0);
324
//
325
    = перечень_контрактов ":" объявление_переменной
326
                                { ast.addNode(ast.sbl.host, ast.sbl.op.Announcements_Completed, 0); }
327
    ;
328

329
возвращаемый_тип
330
    = начало_возвращаемых_типов описание_возвращаемого_типа 
331
                                { ast.goParent(); }
332
    ;
333

334
начало_возвращаемых_типов
335
    = "->"                      { ast.addNode_StepInto(ast.sbl.host, ast.sbl1.op.Function_Return_Type, 0); }
336
    ;
337

338
описание_возвращаемого_типа
339
    = перечень_контрактов 
340
    ;
341

342
тело_функции
343
    = начало_тела_функции список_операторов "}"
344
                                { ast.addNode(ast.sbl.host, ast.op.None, 2); ast.goParent(); }
345
    = начало_тела_функции "}"
346
                                { ast.addNode(ast.sbl.host, ast.op.None, 1); ast.goParent(); }
347
    ;
348
    начало_тела_функции
349
        = "{"                   { ast.addNode_StepInto(ast.sbl.host, ast.sbl1.op.Function_Body, 0); }
350
        ;
351

352
/*  Определение для простой функции (без контрактов)
353
******************************************************************************/
354

355
оператор_описания
356
    = определение_простой_функции
357
    ;
358
    
359
определение_простой_функции
360
    = начало_определения_простой_функции завершение_определения_простой_функции
361
                                { 
362
                                    ast.goParent(); 
363
                                    ast.addNode(ast.sbl.host, ast.sbl.op.FunctionDefinitionEnd, 1);
364
                                    ast.goParent(); 
365
                                    ast.addNode(ast.sbl.host, ast.sbl.op.PostInitialize, 1);
366
                                    ast.addNode(ast.sbl.host, ast.sbl.op.Announcements_Completed, 1);
367
                                    ast.addNode(ast.sbl.host, ast.sbl.op.FunctionTethered, 1);
368
                                }
369
    ;
370

371
начало_определения_простой_функции
372
    = ключевое_слово_для_функции ID
373
                                { 
374
                                    ast.addNode(ast.sbl.host, ast.sbl.op.AutoDeclaration, 1);
375
                                    ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.Initialize, 0);
376
                                    ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.FunctionDefinition, 0);
377
                                }
378
    ;
379
    
380
завершение_определения_простой_функции
381
    = часть_объявления_функции тело_функции
382
//    = перечень_замыканий часть_объявления_функции тело_функции
383
    ;
384
    
385
/*  Оператор вызова процедуры
386
******************************************************************************/
387
оператор_выполнения
388
    = вызов_процедуры
389
    ;
390
    вызов_процедуры
391
/// \note В данной концепции необходимо начинать оператор с ключевого слова, иначе конфликтует с объявлением переменной    
392
        = адрес                 // Вызов процедуры с ожиданием её завершения
393
                                { ast.addNode(ast.sbl.host, ast.sbl.op.ProcedureCheck, 0); }
394
        = "call" адрес          // Вызов процедуры с ожиданием её завершения
395
                                { ast.addNode(ast.sbl.host, ast.sbl.op.ProcedureCheck, 1); }
396
        ;
397
        
398
/*  Оператор присваивания
399
******************************************************************************/
400
оператор_выполнения
401
    = оператор_присваивания
402
    ;
403
    оператор_присваивания
404
        = адрес знак_присваивания выражение_или_определение_безымянной_функции
405
                                { ast.goParent(); }
406
        = адрес знак_присваивания_с_итерацией выражение_или_определение_безымянной_функции
407
                                { ast.goParent(); }
408
        ;
409
    знак_присваивания
410
        = "="                   { ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.Assignment, 0); }
411
        ;
412
    знак_присваивания_с_итерацией
413
        = "+="                  { ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.AssignmentAddition, 0); }
414
        = "-="                  { ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.AssignmentSubtraction, 0); }
415
        = "*="                  { ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.AssignmentMultiplication, 0); }
416
        = "/="                  { ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.AssignmentDivision, 0); }
417
        = "%="                  { ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.AssignmentModulo, 0); }
418
        ;
419

420
/*  Условный оператор
421
******************************************************************************/
422
оператор_выполнения
423
    = условный_оператор
424
    ;
425
    условный_оператор
426
        = условие_if оператор_выполнения >
427
                                { ast.goParent(); ast.goParent(); }
428
        = условие_if оператор_выполнения условие_else
429
                                { ast.goParent(); ast.goParent(); }
430
        ;
431
        условие_if
432
            = "if" выражение    {
433
                                    ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.If, 0);
434
                                    ast.addNode_StepInto(ast.sbl.host, ast.sbl1.op.If_True_Body, 0);
435
                                }
436
            ;
437
        условие_else
438
            = слово_else оператор_выполнения
439
            ;
440
            слово_else
441
                = "else"        { 
442
                                    ast.goParent(); 
443
                                    ast.addNode_StepInto(ast.sbl.host, ast.sbl1.op.If_Else_Body, 0); 
444
                                }
445
                ;
446

447
/*  Оператор цикла for
448
******************************************************************************/
449
оператор_выполнения
450
    = цикл_for
451
    ;
452

453
цикл_for
454
    = начало_цикла_for объявление_переменной_цикла_for источник_итераций_for оператор_выполнения
455
                                { ast.goParent(); ast.goParent(); }
456
    ;
457
    
458
начало_цикла_for
459
    = "for"                     { 
460
                                    ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.For, 0);
461
                                    ast.addNode_StepInto(ast.sbl.host, ast.sbl1.op.For_Variable, 0);
462
                                }
463
    ;
464
    
465
объявление_переменной_цикла_for
466
    = перечень_контрактов ":" объявление_переменной
467
                                {
468
                                    ast.addNode(ast.sbl.host, ast.sbl.op.Announcements_Completed, 0);
469
                                    ast.goParent(); 
470
                                }
471
    ;
472
    
473
источник_итераций_for
474
    = начало_определения_источника_for выражение
475
                                { 
476
                                    ast.goParent(); 
477
                                    ast.addNode_StepInto(ast.sbl.host, ast.sbl1.op.Cycle_Body, 0);
478
                                }
479
    ;
480
    
481
начало_определения_источника_for
482
    = "in"                      { ast.addNode_StepInto(ast.sbl.host, ast.sbl1.op.For_Source, 0); }
483
    ;
484

485
/*  Оператор цикла while
486
******************************************************************************/
487
оператор_выполнения
488
    = цикл_while
489
    ;
490
    цикл_while
491
        = слово_while условие_while оператор_выполнения
492
                                {
493
                                    ast.goParent();
494
                                    ast.goParent();
495
                                }
496
        ;
497
        слово_while
498
            = "while"           {
499
                                    ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.While, 0);
500
                                    ast.addNode_StepInto(ast.sbl.host, ast.sbl1.op.While_Condition, 0);
501
                                }
502
            ;
503
        условие_while
504
            = выражение         { ast.goParent(); ast.addNode_StepInto(ast.sbl.host, ast.sbl1.op.Cycle_Body, 0); }
505
            ;
506

507
/*  Оператор цикла do-while
508
******************************************************************************/
509
оператор_выполнения
510
    = цикл_do_while
511
    ;
512
    цикл_do_while
513
        = слово_do оператор_DoWhile "while" выражение
514
                                { ast.goParent(); ast.goParent(); }
515
        ;
516
        слово_do
517
            = "do"              {
518
                                    ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.DoWhile, 0);
519
                                    ast.addNode_StepInto(ast.sbl.host, ast.sbl1.op.Cycle_Body, 0);
520
                                }
521
            ;
522
        оператор_DoWhile
523
            = оператор_выполнения
524
                                { ast.goParent(); ast.addNode_StepInto(ast.sbl.host, ast.sbl1.op.While_Condition, 0); }
525
            ;
526

527
/*  Оператор управления
528
******************************************************************************/
529
оператор_выполнения
530
    = оператор_управления
531
    ;
532
    оператор_управления
533
        = "break"               { ast.addNode(ast.sbl.host, ast.sbl.op.Break, 0); }
534
        = "continue"            { ast.addNode(ast.sbl.host, ast.sbl.op.Continue, 0); }
535
        ;
536

537
/*  Оператор возврата
538
******************************************************************************/
539
оператор_выполнения
540
    = оператор_return
541
    ;
542
    оператор_return
543
        = "return"              { ast.addNode(ast.sbl.host, ast.sbl.op.Return, 0); }
544
        = "return" выражение_или_определение_безымянной_функции
545
                                { ast.addNode(ast.sbl.host, ast.sbl.op.ReturnExpression, 0); }
546
        ;
547
//    слово_return
548
//        = "return"              { ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.Return, 0); }
549
//        ;
550

551
/*  Блок операторов
552
******************************************************************************/
553
оператор_выполнения
554
    = блок_операторов
555
    ;
556
    блок_операторов
557
        = начало_блока_операторов список_операторов "}"
558
                                { ast.addNode(ast.sbl.host, ast.sbl.op.None, 2); ast.goParent(); }
559
        = начало_блока_операторов "}"
560
                                { ast.addNode(ast.sbl.host, ast.sbl.op.None, 1); ast.goParent(); }
561
        ;
562
        начало_блока_операторов
563
            = "{"               { ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.Block, 0); }
564
            ;
565

566
/*  Оператор объявления зоны видимости для контракта
567
******************************************************************************/
568
оператор_описания
569
    = объявление_глобальной_зоны_видимости
570
    ;
571

572
объявление_глобальной_зоны_видимости
573
    = начало_объявления_глобальной_зоны_видимости список_имён_контрактов
574
                                { ast.goParent(); }
575
    ;
576

577
начало_объявления_глобальной_зоны_видимости
578
    = "common"                  { ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.Apply, 0); }
579
    ;
580

581
список_имён_контрактов
582
    = имя_контракта
583
    = список_имён_контрактов "," имя_контракта
584
    ;
585
    
586
имя_контракта
587
    = ID                        { ast.addNode(ast.sbl.host, ast.sbl.op.None, 0); }
588
    ;
589

590
//оператор_выполнения
591
//    = определение_зоны_видимости
592
//    ;
593

594
//определение_зоны_видимости
595
//    = начало_определения_зоны_видимости перечень_контрактов_для_определения_зоны_видимости блок_операторов
596
//                                { ast.goParent(); }
597
//    ;
598

599
//начало_определения_зоны_видимости
600
//    = "using"                   { ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.Using, 0); }
601
//    ;
602

603
//перечень_контрактов_для_определения_зоны_видимости
604
//    = список_контрактов         { ast.goParent(); }
605
//    ;
606
   
607
///////////////////////////////////////////////////////////////////////////////
608
// Многопоточность с использованием языковых конструкций
609
/// \todo Нужно будет реализовать с использованием модуля loom и контрактов
610
///////////////////////////////////////////////////////////////////////////////
611

612
/*  Объявление нити, запуск потока и получение состояния
613
******************************************************************************/
614
оператор_выполнения
615
    = объявление_нити
616
    = запуск_потока_нити
617
    = ожидание_нити
618
    = передача_состояния_нити
619
    = получение_состояния_нити
620
/// \todo Закрытие нити добавляет сложности в реализацию согласованности, кроме того, 
621
/// эту операцию сложно контролировать при анализе. Поэтому не реализуем пока.
622
//    = закрытие_нити
623
    ;
624

625
    объявление_нити
626
        = начало_объявления_нити адрес
627
                                    { ast.goParent(); }
628
        ;
629
        /// \note Ключевое слово fiber было бы логичнее, но мы его резервируем для одноимённого контракта
630
        начало_объявления_нити
631
            = "make_fiber"          { ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.FiberMake, 0); }
632
            ;
633
    запуск_потока_нити
634
        = начало_запуска_потока_нити адрес
635
                                    { ast.goParent(); }
636
        ;
637
        начало_запуска_потока_нити
638
            = "flow"                { ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.FiberFlow, 0); }
639
            ;
640
    ожидание_нити
641
        = начало_ожидания_нити адрес{ ast.goParent(); ast.addNode(ast.sbl.host, ast.sbl.op.Pop, 0); }
642
        ;
643
        начало_ожидания_нити
644
            = "wait"                { ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.FiberWait, 0); }
645
            ;
646
    передача_состояния_нити
647
        = начало_передачи_состояния_нити адрес
648
                                    { ast.goParent(); ast.addNode(ast.sbl.host, ast.sbl.op.FiberPush, 0); }
649
        ;
650
        начало_передачи_состояния_нити
651
            = "push"                { ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.FiberWait, 0); }
652
            ;
653
    получение_состояния_нити
654
        = начало_получения_состояния_нити адрес
655
                                    { ast.goParent(); ast.addNode(ast.sbl.host, ast.sbl.op.FiberPull, 0); }
656
        ;
657
        начало_получения_состояния_нити
658
            = "pull"                { ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.FiberWait, 0); }
659
            ;
660
//    закрытие_нити
661
//        = начало_закрытия_нити адрес
662
//                                    { ast.goParent(); }
663
//        ;
664
//        начало_закрытия_нити
665
//            = "cut"                 { ast.addNode_StepInto(ast.sbl.host, ast.sbl.op.FiberCut, 0); }
666
//            ;
667