← Back to branch summary

~ubuntu-branches/debian/sid/kdevelop/sid

« back to all changes in this revision

Viewing changes to languages/pascal/PascalParser.hpp

  • Committer: Bazaar Package Importer
  • Author(s): Jeremy Lainé
  • Date: 2010-05-05 07:21:55 UTC
  • mfrom: (1.2.3 upstream) (5.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100505072155-h78lx19pu04sbhtn
Tags: 4:4.0.0-2
http://bugs.debian.org/579947
http://bugs.debian.org/481832
http://bugs.debian.org/562410
http://bugs.debian.org/546961
* Upload to unstable (Closes: #579947, #481832).
* Acknowledge obsolete NMU fixes (Closes: #562410, #546961).

Show diffs side-by-side

added added

removed removed

Lines of Context:
languages/pascal/PascalParser.hpp
1
 
#ifndef INC_PascalParser_hpp_
2
 
#define INC_PascalParser_hpp_
3
 
 
4
 
#line 29 "pascal.g"
5
 
 
6
 
        #include "problemreporter.h"
7
 
        #include "PascalAST.hpp"
8
 
 
9
 
        #include <qlistview.h>
10
 
        #include <kdebug.h>
11
 
 
12
 
        #define SET_POSITION(ast,t)\
13
 
        { \
14
 
                RefPascalAST(ast)->setLine( t->getLine() );\
15
 
                RefPascalAST(ast)->setColumn( t->getColumn() ); \
16
 
        }
17
 
 
18
 
#line 19 "PascalParser.hpp"
19
 
#include <antlr/config.hpp>
20
 
/* $ANTLR 2.7.7 (20061129): "pascal.g" -> "PascalParser.hpp"$ */
21
 
#include <antlr/TokenStream.hpp>
22
 
#include <antlr/TokenBuffer.hpp>
23
 
#include "PascalTokenTypes.hpp"
24
 
#include <antlr/LLkParser.hpp>
25
 
 
26
 
class CUSTOM_API PascalParser : public ANTLR_USE_NAMESPACE(antlr)LLkParser, public PascalTokenTypes
27
 
{
28
 
#line 90 "pascal.g"
29
 
 
30
 
private:
31
 
        unsigned int m_numberOfErrors;
32
 
        ProblemReporter* m_problemReporter;
33
 
 
34
 
public:
35
 
        void resetErrors()                              { m_numberOfErrors = 0; }
36
 
        unsigned int numberOfErrors() const             { return m_numberOfErrors; }
37
 
        void setProblemReporter( ProblemReporter* r )   { m_problemReporter = r; }
38
 
 
39
 
        void reportError( const ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex ){
40
 
                m_problemReporter->reportError( ex.getMessage().c_str(),
41
 
                                                ex.getFilename().c_str(),
42
 
                                                ex.getLine(),
43
 
                                                ex.getColumn() );
44
 
                ++m_numberOfErrors;
45
 
        }
46
 
 
47
 
        void reportError( const ANTLR_USE_NAMESPACE(std)string& errorMessage ){
48
 
                m_problemReporter->reportError( errorMessage.c_str(),
49
 
                                                getFilename().c_str(),
50
 
                                                LT(1)->getLine(),
51
 
                                                LT(1)->getColumn() );
52
 
                ++m_numberOfErrors;
53
 
        }
54
 
 
55
 
        void reportMessage( const ANTLR_USE_NAMESPACE(std)string& message ){
56
 
                m_problemReporter->reportMessage( message.c_str(),
57
 
                                                getFilename().c_str(),
58
 
                                                LT(1)->getLine(),
59
 
                                                LT(1)->getColumn() );
60
 
        }
61
 
#line 30 "PascalParser.hpp"
62
 
public:
63
 
        void initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory );
64
 
protected:
65
 
        PascalParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k);
66
 
public:
67
 
        PascalParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf);
68
 
protected:
69
 
        PascalParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k);
70
 
public:
71
 
        PascalParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer);
72
 
        PascalParser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state);
73
 
        int getNumTokens() const
74
 
        {
75
 
                return PascalParser::NUM_TOKENS;
76
 
        }
77
 
        const char* getTokenName( int type ) const
78
 
        {
79
 
                if( type > getNumTokens() ) return 0;
80
 
                return PascalParser::tokenNames[type];
81
 
        }
82
 
        const char* const* getTokenNames() const
83
 
        {
84
 
                return PascalParser::tokenNames;
85
 
        }
86
 
        public: void compilationUnit();
87
 
        public: void program();
88
 
        public: void library();
89
 
        public: void unit();
90
 
        public: void programHeading();
91
 
        public: void usesClause();
92
 
        public: void block();
93
 
        public: void identifier();
94
 
        public: void libraryBlock();
95
 
        public: void exportsClause();
96
 
        public: void declarationPart();
97
 
        public: void statementPart();
98
 
        public: void exportsList();
99
 
        public: void exportsEntry();
100
 
        public: void integerConstant();
101
 
        public: void stringConstant();
102
 
        public: void identifierList();
103
 
        public: void interfacePart();
104
 
        public: void implementationPart();
105
 
        public: void initializationPart();
106
 
        public: void finalizationPart();
107
 
        public: void realizationPart();
108
 
        public: void constantDeclarationPart();
109
 
        public: void typeDeclarationPart();
110
 
        public: void procedureHeadersPart();
111
 
        public: void statement();
112
 
        public: void labelDeclarationPart();
113
 
        public: void resourcestringDeclarationPart();
114
 
        public: void variableDeclarationPart();
115
 
        public: void procedureAndFunctionDeclarationPart();
116
 
        public: void label();
117
 
        public: void constantDeclaration();
118
 
        public: void typedConstantDeclaration();
119
 
        public: void stringConstantDeclaration();
120
 
        public: void string();
121
 
        public: void typeDeclaration();
122
 
        public: void variableDeclaration();
123
 
        public: void type();
124
 
        public: void procedureAndFunctionDeclaration();
125
 
        public: void procedureDeclaration();
126
 
        public: void functionDeclaration();
127
 
        public: void constructorDeclaration();
128
 
        public: void destructorDeclaration();
129
 
        public: void compoundStatement();
130
 
        public: void procedureHeader();
131
 
        public: void subroutineBlock();
132
 
        public: void functionHeader();
133
 
        public: void qualifiedMethodIdentifier();
134
 
        public: void formalParameterList();
135
 
        public: void modifiers();
136
 
        public: void externalDirective();
137
 
        public: void functionHeaderEnding();
138
 
        public: void parameterDeclaration();
139
 
        public: void valueParameter();
140
 
        public: void variableParameter();
141
 
        public: void constantParameter();
142
 
        public: void untypedParameterPart();
143
 
        public: void callModifiers();
144
 
        public: void expression();
145
 
        public: void typedConstant();
146
 
        public: void constant();
147
 
        public: void recordConstant();
148
 
        public: void arrayConstant();
149
 
        public: void proceduralConstant();
150
 
        public: void addressConstant();
151
 
        public: void simpleType();
152
 
        public: void subrangeTypeOrTypeIdentifier();
153
 
        public: void enumeratedType();
154
 
        public: void stringType();
155
 
        public: void structuredType();
156
 
        public: void pointerType();
157
 
        public: void proceduralType();
158
 
        public: void ordinalType();
159
 
        public: void realType();
160
 
        public: void typeIdentifier();
161
 
        public: void subrangeType();
162
 
        public: void assignedEnumList();
163
 
        public: void unsignedInteger();
164
 
        public: void arrayType();
165
 
        public: void recordType();
166
 
        public: void objectType();
167
 
        public: void classType();
168
 
        public: void setType();
169
 
        public: void fileType();
170
 
        public: void arrayIndexType();
171
 
        public: void arraySubrangeType();
172
 
        public: void fieldList();
173
 
        public: void fixedField();
174
 
        public: void variantPart();
175
 
        public: void variant();
176
 
        public: void proceduralTypePart1();
177
 
        public: void heritage();
178
 
        public: void componentList();
179
 
        public: void objectVisibilitySpecifier();
180
 
        public: void fieldDefinition();
181
 
        public: void methodDefinition();
182
 
        public: void constructorHeader();
183
 
        public: void destructorHeader();
184
 
        public: void methodDirectives();
185
 
        public: void classComponentList();
186
 
        public: void classVisibilitySpecifier();
187
 
        public: void classMethodDefinition();
188
 
        public: void propertyDefinition();
189
 
        public: void classMethodDirectives();
190
 
        public: void directiveVariants();
191
 
        public: void propertyInterface();
192
 
        public: void propertySpecifiers();
193
 
        public: void propertyParameterList();
194
 
        public: void readSpecifier();
195
 
        public: void writeSpecifier();
196
 
        public: void defaultSpecifier();
197
 
        public: void fieldOrMethod();
198
 
        public: void simpleExpression();
199
 
        public: void expressionSign();
200
 
        public: void term();
201
 
        public: void factor();
202
 
        public: void identifierOrValueTypecastOrFunctionCall();
203
 
        public: void unsignedConstant();
204
 
        public: void setConstructor();
205
 
        public: void addressFactor();
206
 
        public: void expressions();
207
 
        public: void functionCall();
208
 
        public: void actualParameterList();
209
 
        public: void setGroup();
210
 
        public: void valueTypecast();
211
 
        public: void simpleStatement();
212
 
        public: void structuredStatement();
213
 
        public: void assignmentStatement();
214
 
        public: void procedureStatement();
215
 
        public: void gotoStatement();
216
 
        public: void raiseStatement();
217
 
        public: void identifierOrArrayIdentifier();
218
 
        public: void assignmentOperator();
219
 
        public: void repetitiveStatement();
220
 
        public: void conditionalStatement();
221
 
        public: void exceptionStatement();
222
 
        public: void withStatement();
223
 
        public: void ifStatement();
224
 
        public: void caseStatement();
225
 
        public: void forStatement();
226
 
        public: void repeatStatement();
227
 
        public: void whileStatement();
228
 
        public: void caseListElement();
229
 
        public: void constList();
230
 
        public: void forList();
231
 
        public: void initialValue();
232
 
        public: void finalValue();
233
 
        public: void recordVariableList();
234
 
        public: void variable();
235
 
        public: void operatorDefinition();
236
 
        public: void assignmentOperatorDefinition();
237
 
        public: void arithmeticOperatorDefinition();
238
 
        public: void comparisonOperatorDefinition();
239
 
        public: void tryStatement();
240
 
        public: void statements();
241
 
        public: void exceptOrFinallyPart();
242
 
        public: void exceptionHandlers();
243
 
        public: void exceptionHandler();
244
 
        public: void sign();
245
 
        public: void constantChr();
246
 
        public: void unsignedNumber();
247
 
        public: void unsignedReal();
248
 
public:
249
 
        ANTLR_USE_NAMESPACE(antlr)RefAST getAST()
250
 
        {
251
 
                return ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST);
252
 
        }
253
 
        
254
 
protected:
255
 
        RefPascalAST returnAST;
256
 
private:
257
 
        static const char* tokenNames[];
258
 
#ifndef NO_STATIC_CONSTS
259
 
        static const int NUM_TOKENS = 190;
260
 
#else
261
 
        enum {
262
 
                NUM_TOKENS = 190
263
 
        };
264
 
#endif
265
 
        
266
 
        static const unsigned long _tokenSet_0_data_[];
267
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_0;
268
 
        static const unsigned long _tokenSet_1_data_[];
269
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_1;
270
 
        static const unsigned long _tokenSet_2_data_[];
271
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_2;
272
 
        static const unsigned long _tokenSet_3_data_[];
273
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_3;
274
 
        static const unsigned long _tokenSet_4_data_[];
275
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_4;
276
 
        static const unsigned long _tokenSet_5_data_[];
277
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_5;
278
 
        static const unsigned long _tokenSet_6_data_[];
279
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_6;
280
 
        static const unsigned long _tokenSet_7_data_[];
281
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_7;
282
 
        static const unsigned long _tokenSet_8_data_[];
283
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_8;
284
 
        static const unsigned long _tokenSet_9_data_[];
285
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_9;
286
 
        static const unsigned long _tokenSet_10_data_[];
287
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_10;
288
 
        static const unsigned long _tokenSet_11_data_[];
289
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_11;
290
 
        static const unsigned long _tokenSet_12_data_[];
291
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_12;
292
 
        static const unsigned long _tokenSet_13_data_[];
293
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_13;
294
 
        static const unsigned long _tokenSet_14_data_[];
295
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_14;
296
 
        static const unsigned long _tokenSet_15_data_[];
297
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_15;
298
 
        static const unsigned long _tokenSet_16_data_[];
299
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_16;
300
 
        static const unsigned long _tokenSet_17_data_[];
301
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_17;
302
 
        static const unsigned long _tokenSet_18_data_[];
303
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_18;
304
 
        static const unsigned long _tokenSet_19_data_[];
305
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_19;
306
 
        static const unsigned long _tokenSet_20_data_[];
307
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_20;
308
 
        static const unsigned long _tokenSet_21_data_[];
309
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_21;
310
 
        static const unsigned long _tokenSet_22_data_[];
311
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_22;
312
 
        static const unsigned long _tokenSet_23_data_[];
313
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_23;
314
 
        static const unsigned long _tokenSet_24_data_[];
315
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_24;
316
 
        static const unsigned long _tokenSet_25_data_[];
317
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_25;
318
 
        static const unsigned long _tokenSet_26_data_[];
319
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_26;
320
 
        static const unsigned long _tokenSet_27_data_[];
321
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_27;
322
 
        static const unsigned long _tokenSet_28_data_[];
323
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_28;
324
 
        static const unsigned long _tokenSet_29_data_[];
325
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_29;
326
 
        static const unsigned long _tokenSet_30_data_[];
327
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_30;
328
 
        static const unsigned long _tokenSet_31_data_[];
329
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_31;
330
 
        static const unsigned long _tokenSet_32_data_[];
331
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_32;
332
 
        static const unsigned long _tokenSet_33_data_[];
333
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_33;
334
 
        static const unsigned long _tokenSet_34_data_[];
335
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_34;
336
 
        static const unsigned long _tokenSet_35_data_[];
337
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_35;
338
 
        static const unsigned long _tokenSet_36_data_[];
339
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_36;
340
 
        static const unsigned long _tokenSet_37_data_[];
341
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_37;
342
 
        static const unsigned long _tokenSet_38_data_[];
343
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_38;
344
 
        static const unsigned long _tokenSet_39_data_[];
345
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_39;
346
 
        static const unsigned long _tokenSet_40_data_[];
347
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_40;
348
 
        static const unsigned long _tokenSet_41_data_[];
349
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_41;
350
 
        static const unsigned long _tokenSet_42_data_[];
351
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_42;
352
 
        static const unsigned long _tokenSet_43_data_[];
353
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_43;
354
 
        static const unsigned long _tokenSet_44_data_[];
355
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_44;
356
 
        static const unsigned long _tokenSet_45_data_[];
357
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_45;
358
 
        static const unsigned long _tokenSet_46_data_[];
359
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_46;
360
 
        static const unsigned long _tokenSet_47_data_[];
361
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_47;
362
 
        static const unsigned long _tokenSet_48_data_[];
363
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_48;
364
 
        static const unsigned long _tokenSet_49_data_[];
365
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_49;
366
 
        static const unsigned long _tokenSet_50_data_[];
367
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_50;
368
 
        static const unsigned long _tokenSet_51_data_[];
369
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_51;
370
 
        static const unsigned long _tokenSet_52_data_[];
371
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_52;
372
 
        static const unsigned long _tokenSet_53_data_[];
373
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_53;
374
 
        static const unsigned long _tokenSet_54_data_[];
375
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_54;
376
 
        static const unsigned long _tokenSet_55_data_[];
377
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_55;
378
 
        static const unsigned long _tokenSet_56_data_[];
379
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_56;
380
 
        static const unsigned long _tokenSet_57_data_[];
381
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_57;
382
 
        static const unsigned long _tokenSet_58_data_[];
383
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_58;
384
 
        static const unsigned long _tokenSet_59_data_[];
385
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_59;
386
 
        static const unsigned long _tokenSet_60_data_[];
387
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_60;
388
 
        static const unsigned long _tokenSet_61_data_[];
389
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_61;
390
 
        static const unsigned long _tokenSet_62_data_[];
391
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_62;
392
 
        static const unsigned long _tokenSet_63_data_[];
393
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_63;
394
 
        static const unsigned long _tokenSet_64_data_[];
395
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_64;
396
 
        static const unsigned long _tokenSet_65_data_[];
397
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_65;
398
 
        static const unsigned long _tokenSet_66_data_[];
399
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_66;
400
 
        static const unsigned long _tokenSet_67_data_[];
401
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_67;
402
 
        static const unsigned long _tokenSet_68_data_[];
403
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_68;
404
 
        static const unsigned long _tokenSet_69_data_[];
405
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_69;
406
 
        static const unsigned long _tokenSet_70_data_[];
407
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_70;
408
 
        static const unsigned long _tokenSet_71_data_[];
409
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_71;
410
 
        static const unsigned long _tokenSet_72_data_[];
411
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_72;
412
 
        static const unsigned long _tokenSet_73_data_[];
413
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_73;
414
 
        static const unsigned long _tokenSet_74_data_[];
415
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_74;
416
 
        static const unsigned long _tokenSet_75_data_[];
417
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_75;
418
 
        static const unsigned long _tokenSet_76_data_[];
419
 
        static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_76;
420
 
};
421
 
 
422
 
#endif /*INC_PascalParser_hpp_*/