← Back to branch summary

~tfr/happy/trunk

« back to all changes in this revision

Viewing changes to src/grammar.cpp

  • Committer: Thibault Francois
  • Date: 2011-01-07 23:48:48 UTC
  • Revision ID: tfr@openerp.com-20110107234848-jgts7xbmgcb8tqec
[ADD] Object_id in grammar : consider as Id for now

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/grammar.cpp
9
9
 
10
10
 
11
11
string type[] = {
12
 
        "ERROR", "Programme", "Block_fun", "Fun",
13
 
        "fun", "Id", "Block_arg", "Instr", "Block_instr", "of", 
14
 
        "If", "While", "Call", "Assignement", "Return", "Skip",
15
 
        "set", "if", "while", "return", "skip", "Expr",
16
 
        "string", "int", "float", "midfix", "Op", "lambda", "Lambda"
 
12
    "ERROR", "Programme", "Block_fun", "Fun",
 
13
    "fun", "Id", "Object_id", "Block_arg", "Instr", "Block_instr", "of", 
 
14
    "If", "While", "Call", "Assignement", "Return", "Skip",
 
15
    "set", "if", "while", "return", "skip", "Expr",
 
16
    "string", "int", "float", "midfix", "Op", "lambda", "Lambda"
17
17
};
18
18
 
19
 
const int type_length = 29;
 
19
const int type_length = 30;
20
20
const int nb_element_block = 2;
21
21
int element1_2[nb_element_block];
22
22
 
30
30
 
31
31
 
32
32
sets create_sets(string tab[], int size) {
33
 
        sets s;
34
 
        for(int i = 0; i < size; i++) {
35
 
                s.insert(get_set_code(tab[i]));
36
 
        }
37
 
        //s.print();
38
 
        return s;
 
33
    sets s;
 
34
    for(int i = 0; i < size; i++) {
 
35
        s.insert(get_set_code(tab[i]));
 
36
    }
 
37
    //s.print();
 
38
    return s;
39
39
}
40
40
 
41
 
void initMap() {        
42
 
        for(int i = 0; i < type_length; i++) {
43
 
                type_map[type[i]] = i;
44
 
        }
 
41
void initMap() {    
 
42
    for(int i = 0; i < type_length; i++) {
 
43
        type_map[type[i]] = i;
 
44
    }
45
45
}
46
46
 
47
47
void initRule1() {
48
 
        /* Init Rule 1.1 */
49
 
        regle1[get_set_code("fun")] = get_set_code("Fun"); 
50
 
        regle1[get_set_code("skip")] = get_set_code("Skip");
51
 
        regle1[get_set_code("return")] = get_set_code("Return");
52
 
        regle1[get_set_code("set")] = get_set_code("Assignement");
53
 
        regle1[get_set_code("if")] = get_set_code("If");
54
 
        regle1[get_set_code("while")] = get_set_code("While");
55
 
        regle1[get_set_code("Id")] = get_set_code("Call");
56
 
        regle1[get_set_code("of")] = get_set_code("Block_arg");
57
 
        regle1[get_set_code("midfix")] = get_set_code("Op");
58
 
        regle1[get_set_code("lambda")] = get_set_code("Lambda");
59
 
        
60
 
        /* Init rule 1.2 for blocks syntax */ 
61
 
        element1_2[0] = get_set_code("Block_fun");
62
 
        element1_2[1] =get_set_code("Block_instr");
63
 
        
64
 
        regle1_2[get_set_code("Block_fun")] = get_set_code("Block_fun");
65
 
        regle1_2[get_set_code("Block_instr")] = get_set_code("Block_instr");
 
48
    /* Init Rule 1.1 */
 
49
    regle1[get_set_code("fun")] = get_set_code("Fun"); 
 
50
    regle1[get_set_code("skip")] = get_set_code("Skip");
 
51
    regle1[get_set_code("return")] = get_set_code("Return");
 
52
    regle1[get_set_code("set")] = get_set_code("Assignement");
 
53
    regle1[get_set_code("if")] = get_set_code("If");
 
54
    regle1[get_set_code("while")] = get_set_code("While");
 
55
    regle1[get_set_code("Id")] = get_set_code("Call");
 
56
    regle1[get_set_code("Object_id")] = get_set_code("Call");
 
57
    regle1[get_set_code("of")] = get_set_code("Block_arg");
 
58
    regle1[get_set_code("midfix")] = get_set_code("Op");
 
59
    regle1[get_set_code("lambda")] = get_set_code("Lambda");
 
60
    
 
61
    /* Init rule 1.2 for blocks syntax */ 
 
62
    element1_2[0] = get_set_code("Block_fun");
 
63
    element1_2[1] =get_set_code("Block_instr");
 
64
    
 
65
    regle1_2[get_set_code("Block_fun")] = get_set_code("Block_fun");
 
66
    regle1_2[get_set_code("Block_instr")] = get_set_code("Block_instr");
66
67
}
67
68
 
68
69
/**
70
71
 * -1 pour N
71
72
 */
72
73
void initRule2() {
73
 
        string tab1[] = {"Fun", "Block_fun"};
74
 
        string tab2[] = {"fun"};
75
 
        string tab3[] = {"Id"};
76
 
        string tab4[] = {"Block_arg"};
77
 
        string tab5[] = {"Instr", "Block_instr"};
78
 
        string tab6[] = {"skip"};
79
 
        string tab7[] = {"of"};
80
 
        string tab8[] = {"set"};
81
 
        string tab9[] = {"Expr"};
82
 
        string tab10[] = {"if"};
83
 
        string tab11[] = {"while"};
84
 
        string tab12[] = {"return"};
85
 
        string tab13[] = {"midfix"};
86
 
        string tab14[] = {"lambda"};
 
74
    string tab1[] = {"Fun", "Block_fun"};
 
75
    string tab2[] = {"fun"};
 
76
    string tab3[] = {"Id"};
 
77
    string tab4[] = {"Block_arg"};
 
78
    string tab5[] = {"Instr", "Block_instr"};
 
79
    string tab6[] = {"skip"};
 
80
    string tab7[] = {"of"};
 
81
    string tab8[] = {"set"};
 
82
    string tab9[] = {"Expr"};
 
83
    string tab10[] = {"if"};
 
84
    string tab11[] = {"while"};
 
85
    string tab12[] = {"return"};
 
86
    string tab13[] = {"midfix"};
 
87
    string tab14[] = {"lambda"};
87
88
 
88
 
        
89
 
        vector<Paire> v1;
90
 
        v1.push_back(Paire(-1, create_sets(tab1, 2)));
91
 
        rule2[get_set_code("Programme")] = v1;
92
 
        rule2[get_set_code("Block_fun")] = v1;
93
 
        
94
 
        vector<Paire> v2;
95
 
        v2.push_back(Paire(1, create_sets(tab2, 1)));
96
 
        v2.push_back(Paire(1, create_sets(tab3, 1)));
97
 
        v2.push_back(Paire(1, create_sets(tab4, 1)));
98
 
        v2.push_back(Paire(1, create_sets(tab5, 2)));
99
 
        rule2[get_set_code("Fun")] = v2;
100
 
        
101
 
        
102
 
        vector<Paire> v3;
103
 
        v3.push_back(Paire(1, create_sets(tab6,1)));
104
 
        rule2[get_set_code("Skip")] = v3;
105
 
        
106
 
        vector<Paire> v4;
107
 
        v4.push_back(Paire(1, create_sets(tab7,1)));
108
 
        v4.push_back(Paire(0, create_sets(tab3,1)));
109
 
        rule2[get_set_code("Block_arg")] = v4;
110
 
        
111
 
        vector<Paire> v5;
112
 
        v5.push_back(Paire(-1, create_sets(tab5, 2)));
113
 
        rule2[get_set_code("Block_instr")] = v5;
114
 
        
115
 
        vector<Paire> v6;
116
 
        v6.push_back(Paire(1, create_sets(tab8, 1)));
117
 
        v6.push_back(Paire(1, create_sets(tab3, 1)));
118
 
        v6.push_back(Paire(1, create_sets(tab9, 1)));
119
 
        rule2[get_set_code("Assignement")] = v6;
120
 
        
121
 
        vector<Paire> v7;
122
 
        v7.push_back(Paire(1, create_sets(tab3, 1)));
123
 
        v7.push_back(Paire(0, create_sets(tab9, 1)));
124
 
        rule2[get_set_code("Call")] = v7;
125
 
        
126
 
        vector<Paire> v8;
127
 
        v8.push_back(Paire(1, create_sets(tab10, 1)));
128
 
        v8.push_back(Paire(1, create_sets(tab9, 1)));
129
 
        v8.push_back(Paire(2, create_sets(tab5, 2)));
130
 
        rule2[get_set_code("If")] = v8;
131
 
        
132
 
        
133
 
        vector<Paire> v9;
134
 
        v9.push_back(Paire(1, create_sets(tab11, 1)));
135
 
        v9.push_back(Paire(1, create_sets(tab9, 1)));
136
 
        v9.push_back(Paire(1, create_sets(tab5, 2)));
137
 
        rule2[get_set_code("While")] = v9;
138
 
        
139
 
        
140
 
        vector<Paire> v10;
141
 
        v10.push_back(Paire(1, create_sets(tab12, 1)));
142
 
        v10.push_back(Paire(1, create_sets(tab9, 1)));
143
 
        rule2[get_set_code("Return")] = v10;
144
 
        
145
 
        vector<Paire> v11;
146
 
        v11.push_back(Paire(1, create_sets(tab13, 1)));
147
 
        v11.push_back(Paire(1, create_sets(tab9, 1)));
148
 
        v11.push_back(Paire(1, create_sets(tab3, 1)));
149
 
        v11.push_back(Paire(0, create_sets(tab9, 1)));
150
 
        rule2[get_set_code("Op")] = v11;
151
 
        
152
 
        vector<Paire> v12;
153
 
        v12.push_back(Paire(1, create_sets(tab14, 1)));
154
 
        v12.push_back(Paire(1, create_sets(tab4, 1)));
155
 
        v12.push_back(Paire(1, create_sets(tab5, 2)));
156
 
        rule2[get_set_code("Lambda")] = v12;
157
 
        
 
89
    
 
90
    vector<Paire> v1;
 
91
    v1.push_back(Paire(-1, create_sets(tab1, 2)));
 
92
    rule2[get_set_code("Programme")] = v1;
 
93
    rule2[get_set_code("Block_fun")] = v1;
 
94
    
 
95
    vector<Paire> v2;
 
96
    v2.push_back(Paire(1, create_sets(tab2, 1)));
 
97
    v2.push_back(Paire(1, create_sets(tab3, 1)));
 
98
    v2.push_back(Paire(1, create_sets(tab4, 1)));
 
99
    v2.push_back(Paire(1, create_sets(tab5, 2)));
 
100
    rule2[get_set_code("Fun")] = v2;
 
101
    
 
102
    
 
103
    vector<Paire> v3;
 
104
    v3.push_back(Paire(1, create_sets(tab6,1)));
 
105
    rule2[get_set_code("Skip")] = v3;
 
106
    
 
107
    vector<Paire> v4;
 
108
    v4.push_back(Paire(1, create_sets(tab7,1)));
 
109
    v4.push_back(Paire(0, create_sets(tab3,1)));
 
110
    rule2[get_set_code("Block_arg")] = v4;
 
111
    
 
112
    vector<Paire> v5;
 
113
    v5.push_back(Paire(-1, create_sets(tab5, 2)));
 
114
    rule2[get_set_code("Block_instr")] = v5;
 
115
    
 
116
    vector<Paire> v6;
 
117
    v6.push_back(Paire(1, create_sets(tab8, 1)));
 
118
    v6.push_back(Paire(1, create_sets(tab3, 1)));
 
119
    v6.push_back(Paire(1, create_sets(tab9, 1)));
 
120
    rule2[get_set_code("Assignement")] = v6;
 
121
    
 
122
    vector<Paire> v7;
 
123
    v7.push_back(Paire(1, create_sets(tab3, 1)));
 
124
    v7.push_back(Paire(0, create_sets(tab9, 1)));
 
125
    rule2[get_set_code("Call")] = v7;
 
126
    
 
127
    vector<Paire> v8;
 
128
    v8.push_back(Paire(1, create_sets(tab10, 1)));
 
129
    v8.push_back(Paire(1, create_sets(tab9, 1)));
 
130
    v8.push_back(Paire(2, create_sets(tab5, 2)));
 
131
    rule2[get_set_code("If")] = v8;
 
132
    
 
133
    
 
134
    vector<Paire> v9;
 
135
    v9.push_back(Paire(1, create_sets(tab11, 1)));
 
136
    v9.push_back(Paire(1, create_sets(tab9, 1)));
 
137
    v9.push_back(Paire(1, create_sets(tab5, 2)));
 
138
    rule2[get_set_code("While")] = v9;
 
139
    
 
140
    
 
141
    vector<Paire> v10;
 
142
    v10.push_back(Paire(1, create_sets(tab12, 1)));
 
143
    v10.push_back(Paire(1, create_sets(tab9, 1)));
 
144
    rule2[get_set_code("Return")] = v10;
 
145
    
 
146
    vector<Paire> v11;
 
147
    v11.push_back(Paire(1, create_sets(tab13, 1)));
 
148
    v11.push_back(Paire(1, create_sets(tab9, 1)));
 
149
    v11.push_back(Paire(1, create_sets(tab3, 1)));
 
150
    v11.push_back(Paire(0, create_sets(tab9, 1)));
 
151
    rule2[get_set_code("Op")] = v11;
 
152
    
 
153
    vector<Paire> v12;
 
154
    v12.push_back(Paire(1, create_sets(tab14, 1)));
 
155
    v12.push_back(Paire(1, create_sets(tab4, 1)));
 
156
    v12.push_back(Paire(1, create_sets(tab5, 2)));
 
157
    rule2[get_set_code("Lambda")] = v12;
 
158
    
158
159
}
159
160
 
160
161
void initRewriteRule() {
161
 
        string tab1[] = {"Instr", "Expr"};
162
 
        string tab2[] = {"Instr"};
163
 
        string tab3[] = {"Expr"};
164
 
        string tab4[] = {"Id", "Expr"};
165
 
        rewriteRule[get_set_code("Call")] = create_sets(tab1, 2);
166
 
        rewriteRule[get_set_code("Op")] = create_sets(tab1, 2);
167
 
        rewriteRule[get_set_code("Assignement")] = create_sets(tab1, 2);
168
 
        
169
 
        rewriteRule[get_set_code("If")] = create_sets(tab2, 1);
170
 
        rewriteRule[get_set_code("While")] = create_sets(tab2, 1);
171
 
        rewriteRule[get_set_code("Skip")] = create_sets(tab2, 1);
172
 
        rewriteRule[get_set_code("Return")] = create_sets(tab2, 1);
173
 
        
174
 
        rewriteRule[get_set_code("string")] = create_sets(tab3, 1);
175
 
        rewriteRule[get_set_code("float")] = create_sets(tab3, 1);
176
 
        rewriteRule[get_set_code("int")] = create_sets(tab3, 1);
177
 
        
178
 
        rewriteRule[get_set_code("Id")] = create_sets(tab4, 2);
179
 
        rewriteRule[get_set_code("Lambda")] = create_sets(tab3, 1);
 
162
    string tab1[] = {"Instr", "Expr"};
 
163
    string tab2[] = {"Instr"};
 
164
    string tab3[] = {"Expr"};
 
165
    string tab4[] = {"Id", "Expr"};
 
166
    rewriteRule[get_set_code("Call")] = create_sets(tab1, 2);
 
167
    rewriteRule[get_set_code("Op")] = create_sets(tab1, 2);
 
168
    rewriteRule[get_set_code("Assignement")] = create_sets(tab1, 2);
 
169
    
 
170
    rewriteRule[get_set_code("If")] = create_sets(tab2, 1);
 
171
    rewriteRule[get_set_code("While")] = create_sets(tab2, 1);
 
172
    rewriteRule[get_set_code("Skip")] = create_sets(tab2, 1);
 
173
    rewriteRule[get_set_code("Return")] = create_sets(tab2, 1);
 
174
    
 
175
    rewriteRule[get_set_code("string")] = create_sets(tab3, 1);
 
176
    rewriteRule[get_set_code("float")] = create_sets(tab3, 1);
 
177
    rewriteRule[get_set_code("int")] = create_sets(tab3, 1);
 
178
    
 
179
    rewriteRule[get_set_code("Id")] = create_sets(tab4, 2);
 
180
    rewriteRule[get_set_code("Object_id")] = create_sets(tab4, 2);
 
181
    rewriteRule[get_set_code("Lambda")] = create_sets(tab3, 1);
180
182
 
181
183
}
182
184
 
183
185
void init() {
184
 
                initMap();
185
 
                initRule1();
186
 
                initRule2();
187
 
                initRewriteRule();      
 
186
        initMap();
 
187
        initRule1();
 
188
        initRule2();
 
189
        initRewriteRule();  
188
190
}
189
191
 
190
192
int get_set_code(string t) {
191
 
        int result = type_map[t];
192
 
        if(!result) {
193
 
                if(t != "ERROR") 
194
 
                        cout << "ERROR : type " << t << " unknown" << endl;
195
 
        }
196
 
        return result;  
 
193
    int result = type_map[t];
 
194
    if(!result) {
 
195
        if(t != "ERROR") 
 
196
            cout << "ERROR : type " << t << " unknown" << endl;
 
197
    }
 
198
    return result;  
197
199
}
198
200
 
199
201
 
200
202
Paire::Paire(int nb, sets s) {
201
 
        this->s = s;
202
 
        this->nb = nb;
203
 
        
 
203
    this->s = s;
 
204
    this->nb = nb;
 
205
    
204
206
}
205
207
 
206
208
 
207
209
 
208
210
map<int, int> getRule1() {
209
 
        return regle1;
 
211
    return regle1;
210
212
} 
211
213
map<int, int> getRule1_2() {
212
 
        return regle1_2;
 
214
    return regle1_2;
213
215
}
214
216
map<int, vector<Paire> > getRule2() {
215
 
        return rule2;
 
217
    return rule2;
216
218
}
217
219
map<int, sets> getRule3() {
218
 
        return rewriteRule;
 
220
    return rewriteRule;
219
221
}
220
222
 
221
223
int applyRule1_2(sets s) {
222
 
        for(int i = 0; i < nb_element_block; i++) {
223
 
                if(s.item(element1_2[i])) {
224
 
                        return element1_2[i];  
225
 
                }
226
 
        }       
227
 
        return 0;
 
224
    for(int i = 0; i < nb_element_block; i++) {
 
225
        if(s.item(element1_2[i])) {
 
226
            return element1_2[i];  
 
227
        }
 
228
    }   
 
229
    return 0;
228
230
}