loom

1
// Описание грамматики выражений
2

3
lex {
4
    lex.addMarkup("\"", "\"", "\\", lex.LexemeType.Annotation);
5

6
    lex.clearMasks();
7
    lex.addMask("@BUILDING_NUMBER_MASK", lex.LexemeType.Number, 10);
8
}
9

10
выражение
11
    = тернарная_операция
12
    = выражение тернарная_операция_знак_1 выражение тернарная_операция_знак_2 выражение >
13
                                    { ast.goParent(); }
14
    ;
15
    тернарная_операция_знак_1
16
        = "?"                       { ast.addNode_StepInto(ast.op.Ternary_True, 0); }
17
        ;
18
    тернарная_операция_знак_2
19
        = ":"                       { ast.addNode_Parent_StepInto(ast.op.Ternary_False, 0); }
20
        ;
21
тернарная_операция
22
    = оператор_ИЛИ
23
    = тернарная_операция "||" оператор_ИЛИ
24
                                    { ast.addNode(ast.op.Logical_Or, 1); }
25
    ;
26
оператор_ИЛИ
27
    = оператор_И
28
    = оператор_ИЛИ "&&" оператор_И
29
                                    { ast.addNode(ast.op.Logical_And, 1); }
30
    ;
31
оператор_И
32
    = оператор_сравнения
33
    = оператор_И "==" оператор_сравнения
34
                                    { ast.addNode(ast.op.Compare_Equal, 1); }
35
    = оператор_И "!=" оператор_сравнения
36
                                    { ast.addNode(ast.op.Compare_NotEqual, 1); }
37
    = оператор_И "<" оператор_сравнения
38
                                    { ast.addNode(ast.op.Compare_Less, 1); }
39
    = оператор_И "<=" оператор_сравнения
40
                                    { ast.addNode(ast.op.Compare_LessOrEqual, 1); }
41
    = оператор_И ">" оператор_сравнения
42
                                    { ast.addNode(ast.op.Compare_More, 1); }
43
    = оператор_И ">=" оператор_сравнения
44
                                    { ast.addNode(ast.op.Compare_MoreOrEqual, 1); }
45
    ;
46
оператор_сравнения
47
    = арифметический_оператор
48
    = оператор_сравнения "+" арифметический_оператор
49
                                    { ast.addNode(ast.op.Arithmetic_Addition, 1); }
50
    = оператор_сравнения "-" арифметический_оператор
51
                                    { ast.addNode(ast.op.Arithmetic_Substruction, 1); }
52
    ;
53
арифметический_оператор
54
    = возведение_в_степень
55
    = арифметический_оператор "*" возведение_в_степень
56
                                    { ast.addNode(ast.op.Arithmetic_Multiplication, 1); }
57
    = арифметический_оператор "/" возведение_в_степень
58
                                    { ast.addNode(ast.op.Arithmetic_Division, 1); }
59
    = арифметический_оператор "%" возведение_в_степень
60
                                    { ast.addNode(ast.op.Arithmetic_Modulo, 1); }
61
    ;
62
возведение_в_степень
63
    = унарный_оператор
64
    = возведение_в_степень "^" унарный_оператор
65
                                    { ast.addNode(ast.op.Arithmetic_Power, 1); }
66
    ;
67
унарный_оператор
68
    = величина
69
    = "+" величина                  { ast.addNode(ast.op.Unary_Plus, 0); }
70
    = "-" величина                  { ast.addNode(ast.op.Unary_Minus, 0); }
71
    = "!" величина                  { ast.addNode(ast.op.Unary_Not, 0); }
72
    ;
73
величина
74
    = NUMBER                        { ast.addNode(ast.op.Push_Constant, 0); }
75
    = ANNOTATION                    { ast.addNode(ast.op.Push_Constant, 0); }
76
    = "true"                        { ast.addNode(ast.op.Push_Constant, 0); }
77
    = "false"                       { ast.addNode(ast.op.Push_Constant, 0); }
78
    = "(" выражение ")"
79
    = итерация
80
    = адрес
81
    ;
82
итерация
83
    = "++" адрес                    { ast.addNode_Branch(ast.op.Iteration_PrefixPlus, 0); }
84
    = "--" адрес                    { ast.addNode_Branch(ast.op.Iteration_PrefixMinus, 0); }
85
    = адрес "++"                    { ast.addNode_Branch(ast.op.Iteration_PosfixPlus, 1); }
86
    = адрес "--"                    { ast.addNode_Branch(ast.op.Iteration_PosfixMinus, 1); }
87
    ;
88
адрес
89
    = имя_переменной                { ast.goParent(); }
90
    = функция                       { ast.goParent(); }
91
    = адрес знак_элемента_кортежа адрес >
92
                                    { ast.goParent(); }
93
    = адрес знак_адреса_в_массиве список_выражений "]"
94
                                    { ast.goParent(); ast.goParent(); }
95
    ;
96
    имя_переменной
97
        = ID                        { ast.addNode_StepInto(ast.op.Push_Id, 0); }
98
        ;
99
    знак_элемента_кортежа
100
        = "."                       {
101
                                        ast.addNode_Branch_StepInto(ast.op.Address_Tuple, 0);
102
                                        ast.goParent();
103
                                    }
104
        ;
105
    знак_адреса_в_массиве
106
        = "["                       {
107
                                        ast.addNode_Branch_StepInto(ast.op.Address_Array, 0);
108
                                    }
109
        ;
110
функция
111
    = имя_функции "(" список_выражений ")"
112
    = имя_функции "(" ")"
113
    ;
114
    имя_функции
115
        = ID                        { ast.addNode_StepInto(ast.op.Function_Call, 0); }
116
        ;
117
список_выражений
118
    = выражение
119
    = список_выражений "," выражение
120
    ;
121

122