← Back to branch summary

~ubuntu-branches/ubuntu/maverick/newsbeuter/maverick

« back to all changes in this revision

Viewing changes to filter/Parser.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Nico Golde
  • Date: 2009-04-21 14:06:18 UTC
  • mfrom: (4.1.7 sid)
  • Revision ID: james.westby@ubuntu.com-20090421140618-osnjk19bgkebyg9h
Tags: 2.0-1
* New upstream release.
  - Remove dependeny on mrss and nxml and add libxml2, newsbeuter
    now comes with its own parser.
  - Remove debian/patches and quilt dependency.
* Bump to policy 3.8.1, no changes needed.
* debian/copyright: adjust years.
* Remove dh_clean -k call as it is deprecated -> dh_prep.
* Change newsbeuter homepage, it now has an official one.
* Fix watch file url, new upstream code location.
* Add bookmark-scuttle.sh to installed contrib files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
filter/Parser.cpp
67
67
                        Get();
68
68
                } else if (la->kind == 5) {
69
69
                        Get();
70
 
                } else SynErr(20);
 
70
                } else if (la->kind == 6) {
 
71
                        Get();
 
72
                } else SynErr(22);
71
73
                lit = coco_string_create_char(t->val); 
72
74
}
73
75
 
78
80
 
79
81
void Parser::matchop(int &op) {
80
82
                switch (la->kind) {
81
 
                case 6: {
82
 
                        Get();
83
 
                        op = MATCHOP_EQ; 
84
 
                        break;
85
 
                }
86
83
                case 7: {
87
84
                        Get();
88
85
                        op = MATCHOP_EQ; 
90
87
                }
91
88
                case 8: {
92
89
                        Get();
 
90
                        op = MATCHOP_EQ; 
 
91
                        break;
 
92
                }
 
93
                case 9: {
 
94
                        Get();
93
95
                        op = MATCHOP_NE; 
94
96
                        break;
95
97
                }
96
 
                case 9: {
 
98
                case 10: {
97
99
                        Get();
98
100
                        op = MATCHOP_RXEQ; 
99
101
                        break;
100
102
                }
101
 
                case 10: {
 
103
                case 11: {
102
104
                        Get();
103
105
                        op = MATCHOP_RXNE; 
104
106
                        break;
105
107
                }
106
 
                case 11: {
 
108
                case 12: {
107
109
                        Get();
108
110
                        op = MATCHOP_LT; 
109
111
                        break;
110
112
                }
111
 
                case 12: {
 
113
                case 13: {
112
114
                        Get();
113
115
                        op = MATCHOP_GT; 
114
116
                        break;
115
117
                }
116
 
                case 13: {
 
118
                case 14: {
117
119
                        Get();
118
120
                        op = MATCHOP_LE; 
119
121
                        break;
120
122
                }
121
 
                case 14: {
 
123
                case 15: {
122
124
                        Get();
123
125
                        op = MATCHOP_GE; 
124
126
                        break;
125
127
                }
126
 
                case 15: {
 
128
                case 16: {
127
129
                        Get();
128
130
                        op = MATCHOP_CONTAINS; 
129
131
                        break;
130
132
                }
131
 
                case 16: {
 
133
                case 17: {
132
134
                        Get();
133
135
                        op = MATCHOP_CONTAINSNOT; 
134
136
                        break;
135
137
                }
136
 
                default: SynErr(21); break;
 
138
                case 18: {
 
139
                        Get();
 
140
                        op = MATCHOP_BETWEEN; 
 
141
                        break;
 
142
                }
 
143
                default: SynErr(23); break;
137
144
                }
138
145
}
139
146
 
140
147
void Parser::logop(int &lop) {
141
 
                if (la->kind == 17) {
 
148
                if (la->kind == 19) {
142
149
                        Get();
143
150
                        lop = LOGOP_AND; 
144
 
                } else if (la->kind == 18) {
 
151
                } else if (la->kind == 20) {
145
152
                        Get();
146
153
                        lop = LOGOP_OR; 
147
 
                } else SynErr(22);
 
154
                } else SynErr(24);
148
155
}
149
156
 
150
157
void Parser::matchexpr() {
169
176
                        matchexpr();
170
177
                } else if (la->kind == 1) {
171
178
                        blockexpr();
172
 
                } else SynErr(23);
173
 
                while (la->kind == 17 || la->kind == 18) {
 
179
                } else SynErr(25);
 
180
                while (la->kind == 19 || la->kind == 20) {
174
181
                        logop(lop);
175
182
                        gen->add_logop(lop); 
176
183
                        if (la->kind == 3) {
177
184
                                matchexpr();
178
185
                        } else if (la->kind == 1) {
179
186
                                blockexpr();
180
 
                        } else SynErr(24);
 
187
                        } else SynErr(26);
181
188
                }
182
189
}
183
190
 
198
205
}
199
206
 
200
207
Parser::Parser(Scanner *scanner) {
201
 
        maxT = 19;
 
208
        _EOF = 0;
 
209
        _openblock = 1;
 
210
        _closeblock = 2;
 
211
        _ident = 3;
 
212
        _stringliteral = 4;
 
213
        _numliteral = 5;
 
214
        _rangeliteral = 6;
 
215
        maxT = 21;
202
216
 
203
217
        minErrDist = 2;
204
218
        errDist = minErrDist;
210
224
        const bool T = true;
211
225
        const bool x = false;
212
226
 
213
 
        static bool set[1][21] = {
214
 
                {T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x}
 
227
        static bool set[1][23] = {
 
228
                {T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x}
215
229
        };
216
230
 
217
231
 
237
251
                        case 3: s = coco_string_create(L"ident expected"); break;
238
252
                        case 4: s = coco_string_create(L"stringliteral expected"); break;
239
253
                        case 5: s = coco_string_create(L"numliteral expected"); break;
240
 
                        case 6: s = coco_string_create(L"\"==\" expected"); break;
241
 
                        case 7: s = coco_string_create(L"\"=\" expected"); break;
242
 
                        case 8: s = coco_string_create(L"\"!=\" expected"); break;
243
 
                        case 9: s = coco_string_create(L"\"=~\" expected"); break;
244
 
                        case 10: s = coco_string_create(L"\"!~\" expected"); break;
245
 
                        case 11: s = coco_string_create(L"\"<\" expected"); break;
246
 
                        case 12: s = coco_string_create(L"\">\" expected"); break;
247
 
                        case 13: s = coco_string_create(L"\"<=\" expected"); break;
248
 
                        case 14: s = coco_string_create(L"\">=\" expected"); break;
249
 
                        case 15: s = coco_string_create(L"\"#\" expected"); break;
250
 
                        case 16: s = coco_string_create(L"\"!#\" expected"); break;
251
 
                        case 17: s = coco_string_create(L"\"and\" expected"); break;
252
 
                        case 18: s = coco_string_create(L"\"or\" expected"); break;
253
 
                        case 19: s = coco_string_create(L"??? expected"); break;
254
 
                        case 20: s = coco_string_create(L"invalid stringlit"); break;
255
 
                        case 21: s = coco_string_create(L"invalid matchop"); break;
256
 
                        case 22: s = coco_string_create(L"invalid logop"); break;
257
 
                        case 23: s = coco_string_create(L"invalid expr"); break;
258
 
                        case 24: s = coco_string_create(L"invalid expr"); break;
 
254
                        case 6: s = coco_string_create(L"rangeliteral expected"); break;
 
255
                        case 7: s = coco_string_create(L"\"==\" expected"); break;
 
256
                        case 8: s = coco_string_create(L"\"=\" expected"); break;
 
257
                        case 9: s = coco_string_create(L"\"!=\" expected"); break;
 
258
                        case 10: s = coco_string_create(L"\"=~\" expected"); break;
 
259
                        case 11: s = coco_string_create(L"\"!~\" expected"); break;
 
260
                        case 12: s = coco_string_create(L"\"<\" expected"); break;
 
261
                        case 13: s = coco_string_create(L"\">\" expected"); break;
 
262
                        case 14: s = coco_string_create(L"\"<=\" expected"); break;
 
263
                        case 15: s = coco_string_create(L"\">=\" expected"); break;
 
264
                        case 16: s = coco_string_create(L"\"#\" expected"); break;
 
265
                        case 17: s = coco_string_create(L"\"!#\" expected"); break;
 
266
                        case 18: s = coco_string_create(L"\"between\" expected"); break;
 
267
                        case 19: s = coco_string_create(L"\"and\" expected"); break;
 
268
                        case 20: s = coco_string_create(L"\"or\" expected"); break;
 
269
                        case 21: s = coco_string_create(L"??? expected"); break;
 
270
                        case 22: s = coco_string_create(L"invalid stringlit"); break;
 
271
                        case 23: s = coco_string_create(L"invalid matchop"); break;
 
272
                        case 24: s = coco_string_create(L"invalid logop"); break;
 
273
                        case 25: s = coco_string_create(L"invalid expr"); break;
 
274
                        case 26: s = coco_string_create(L"invalid expr"); break;
259
275
 
260
276
                default:
261
277
                {
265
281
                }
266
282
                break;
267
283
        }
 
284
        errors.push_back(std::wstring(s));
268
285
        coco_string_delete(s);
269
286
        count++;
270
287
}