loom

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

3
{
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.goParent(); ast.addNode_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
//                                    { ast.goParent(); }
81
    = адрес
82
//                                    { ast.goParent(); }
83
    ;
84
итерация
85
    = "++" адрес                    { ast.addNode(ast.op.Iteration_PrefixPlus, 0); }
86
    = "--" адрес                    { ast.addNode(ast.op.Iteration_PrefixMinus, 0); }
87
    = адрес "++"                    { ast.addNode(ast.op.Iteration_PosfixPlus, 1); }
88
    = адрес "--"                    { ast.addNode(ast.op.Iteration_PosfixMinus, 1); }
89
    ;
90
адрес
91
    = атом
92
                                    { ast.goParent(); }
93
    = адрес знак_элемента_кортежа атом
94
//                                    { ast.goParent(); }
95
    = адрес знак_адреса_в_массиве список_выражений "]"
96
//                                    { ast.goParent(); }
97
    ;
98
//    элемент_кортежа
99
//        = знак_элемента_кортежа атом
100
//                                    { ast.goParent(); }
101
//        ;
102
    знак_элемента_кортежа
103
        = "."                       {
104
//                                        ast.addNode_Branch_StepInto(ast.op.Address_Tuple, 0);
105
//                                        ast.goParent();
106
                                        ast.addNode_Branch(ast.op.Address_Tuple, 0);
107
                                    }
108
        ;
109
    знак_адреса_в_массиве
110
        = "["                       {
111
//                                        ast.addNode_Branch_StepInto(ast.op.Address_Array, 0);
112
//                                        ast.goParent();
113
                                        ast.addNode_Branch(ast.op.Address_Array, 0);
114
                                    }
115
        ;
116
атом
117
    = ID                            { ast.addNode_StepInto(ast.op.Push_Id, 0); }
118
    = имя_функции "(" список_выражений ")"
119
//                                    { ast.goParent(); }
120
    = имя_функции "(" ")"
121
//                                    { ast.goParent(); }
122
    ;
123
    имя_функции
124
        = ID                        { ast.addNode_StepInto(ast.op.Function_Call, 0); }
125
        ;
126
список_выражений
127
    = выражение
128
    = список_выражений "," выражение
129
    ;
130

131