AST.h 107 KB
Newer Older
con's avatar
con committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
// Copyright (c) 2008 Roberto Raggi <roberto.raggi@gmail.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

#ifndef CPLUSPLUS_AST_H
#define CPLUSPLUS_AST_H

#include "CPlusPlusForwardDeclarations.h"
#include "ASTfwd.h"
Roberto Raggi's avatar
Roberto Raggi committed
26
#include "MemoryPool.h"
con's avatar
con committed
27

Roberto Raggi's avatar
Roberto Raggi committed
28
namespace CPlusPlus {
con's avatar
con committed
29

Roberto Raggi's avatar
Roberto Raggi committed
30
template <typename _Tp>
31
class CPLUSPLUS_EXPORT List: public Managed
Roberto Raggi's avatar
Roberto Raggi committed
32 33 34 35 36 37
{
    List(const List &other);
    void operator =(const List &other);

public:
    List()
38
        : value(_Tp()), next(0)
Roberto Raggi's avatar
Roberto Raggi committed
39 40
    { }

Roberto Raggi's avatar
Roberto Raggi committed
41 42 43 44
    List(const _Tp &value)
        : value(value), next(0)
    { }

45 46 47 48 49 50 51 52 53 54
    unsigned firstToken() const
    {
        if (value)
            return value->firstToken();

        // ### assert(0);
        return 0;
    }

    unsigned lastToken() const
55 56 57 58 59 60 61 62 63 64 65
    {
        _Tp lv = lastValue();

        if (lv)
            return lv->lastToken();

        // ### assert(0);
        return 0;
    }

    _Tp lastValue() const
66
    {
Roberto Raggi's avatar
Roberto Raggi committed
67
        _Tp lastValue = 0;
68 69 70

        for (const List *it = this; it; it = it->next) {
            if (it->value)
Roberto Raggi's avatar
Roberto Raggi committed
71
                lastValue = it->value;
72 73
        }

74
        return lastValue;
75
    }
76

Roberto Raggi's avatar
Roberto Raggi committed
77 78 79 80
    _Tp value;
    List *next;
};

Roberto Raggi's avatar
Roberto Raggi committed
81
class CPLUSPLUS_EXPORT AST: public Managed
con's avatar
con committed
82 83 84 85 86 87 88 89 90 91 92 93 94
{
    AST(const AST &other);
    void operator =(const AST &other);

public:
    AST();
    virtual ~AST();

    void accept(ASTVisitor *visitor);

    static void accept(AST *ast, ASTVisitor *visitor)
    { if (ast) ast->accept(visitor); }

95 96 97 98 99 100 101
    template <typename _Tp>
    static void accept(List<_Tp> *it, ASTVisitor *visitor)
    {
        for (; it; it = it->next)
            accept(it->value, visitor);
    }

102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121
    static bool match(AST *ast, AST *pattern, ASTMatcher *matcher);
    bool match(AST *pattern, ASTMatcher *matcher);

    template <typename _Tp>
    static bool match(List<_Tp> *it, List<_Tp> *patternIt, ASTMatcher *matcher)
    {
        while (it && patternIt) {
            if (! match(it->value, patternIt->value, matcher))
                return false;

            it = it->next;
            patternIt = patternIt->next;
        }

        if (! it && ! patternIt)
            return true;

        return false;
    }

con's avatar
con committed
122 123 124
    virtual unsigned firstToken() const = 0;
    virtual unsigned lastToken() const = 0;

125 126
    virtual AST *clone(MemoryPool *pool) const = 0;

127 128 129 130 131 132 133 134 135 136
    virtual AccessDeclarationAST *asAccessDeclaration() { return 0; }
    virtual ArrayAccessAST *asArrayAccess() { return 0; }
    virtual ArrayDeclaratorAST *asArrayDeclarator() { return 0; }
    virtual ArrayInitializerAST *asArrayInitializer() { return 0; }
    virtual AsmDefinitionAST *asAsmDefinition() { return 0; }
    virtual AttributeAST *asAttribute() { return 0; }
    virtual AttributeSpecifierAST *asAttributeSpecifier() { return 0; }
    virtual BaseSpecifierAST *asBaseSpecifier() { return 0; }
    virtual BinaryExpressionAST *asBinaryExpression() { return 0; }
    virtual BoolLiteralAST *asBoolLiteral() { return 0; }
Roberto Raggi's avatar
Roberto Raggi committed
137
    virtual BracedInitializerAST *asBracedInitializer() { return 0; }
138 139
    virtual BreakStatementAST *asBreakStatement() { return 0; }
    virtual CallAST *asCall() { return 0; }
140
    virtual CaptureAST *asCapture() { return 0; }
141 142 143 144
    virtual CaseStatementAST *asCaseStatement() { return 0; }
    virtual CastExpressionAST *asCastExpression() { return 0; }
    virtual CatchClauseAST *asCatchClause() { return 0; }
    virtual ClassSpecifierAST *asClassSpecifier() { return 0; }
145
    virtual CompoundExpressionAST *asCompoundExpression() { return 0; }
146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
    virtual CompoundLiteralAST *asCompoundLiteral() { return 0; }
    virtual CompoundStatementAST *asCompoundStatement() { return 0; }
    virtual ConditionAST *asCondition() { return 0; }
    virtual ConditionalExpressionAST *asConditionalExpression() { return 0; }
    virtual ContinueStatementAST *asContinueStatement() { return 0; }
    virtual ConversionFunctionIdAST *asConversionFunctionId() { return 0; }
    virtual CoreDeclaratorAST *asCoreDeclarator() { return 0; }
    virtual CppCastExpressionAST *asCppCastExpression() { return 0; }
    virtual CtorInitializerAST *asCtorInitializer() { return 0; }
    virtual DeclarationAST *asDeclaration() { return 0; }
    virtual DeclarationStatementAST *asDeclarationStatement() { return 0; }
    virtual DeclaratorAST *asDeclarator() { return 0; }
    virtual DeclaratorIdAST *asDeclaratorId() { return 0; }
    virtual DeleteExpressionAST *asDeleteExpression() { return 0; }
    virtual DestructorNameAST *asDestructorName() { return 0; }
    virtual DoStatementAST *asDoStatement() { return 0; }
    virtual ElaboratedTypeSpecifierAST *asElaboratedTypeSpecifier() { return 0; }
    virtual EmptyDeclarationAST *asEmptyDeclaration() { return 0; }
    virtual EnumSpecifierAST *asEnumSpecifier() { return 0; }
    virtual EnumeratorAST *asEnumerator() { return 0; }
    virtual ExceptionDeclarationAST *asExceptionDeclaration() { return 0; }
    virtual ExceptionSpecificationAST *asExceptionSpecification() { return 0; }
    virtual ExpressionAST *asExpression() { return 0; }
    virtual ExpressionOrDeclarationStatementAST *asExpressionOrDeclarationStatement() { return 0; }
    virtual ExpressionStatementAST *asExpressionStatement() { return 0; }
    virtual ForStatementAST *asForStatement() { return 0; }
172
    virtual ForeachStatementAST *asForeachStatement() { return 0; }
173 174 175
    virtual FunctionDeclaratorAST *asFunctionDeclarator() { return 0; }
    virtual FunctionDefinitionAST *asFunctionDefinition() { return 0; }
    virtual GotoStatementAST *asGotoStatement() { return 0; }
Roberto Raggi's avatar
Roberto Raggi committed
176
    virtual IdExpressionAST *asIdExpression() { return 0; }
177 178
    virtual IfStatementAST *asIfStatement() { return 0; }
    virtual LabeledStatementAST *asLabeledStatement() { return 0; }
179 180 181 182
    virtual LambdaCaptureAST *asLambdaCapture() { return 0; }
    virtual LambdaDeclaratorAST *asLambdaDeclarator() { return 0; }
    virtual LambdaExpressionAST *asLambdaExpression() { return 0; }
    virtual LambdaIntroducerAST *asLambdaIntroducer() { return 0; }
183 184 185 186 187 188 189 190 191 192 193
    virtual LinkageBodyAST *asLinkageBody() { return 0; }
    virtual LinkageSpecificationAST *asLinkageSpecification() { return 0; }
    virtual MemInitializerAST *asMemInitializer() { return 0; }
    virtual MemberAccessAST *asMemberAccess() { return 0; }
    virtual NameAST *asName() { return 0; }
    virtual NamedTypeSpecifierAST *asNamedTypeSpecifier() { return 0; }
    virtual NamespaceAST *asNamespace() { return 0; }
    virtual NamespaceAliasDefinitionAST *asNamespaceAliasDefinition() { return 0; }
    virtual NestedDeclaratorAST *asNestedDeclarator() { return 0; }
    virtual NestedExpressionAST *asNestedExpression() { return 0; }
    virtual NestedNameSpecifierAST *asNestedNameSpecifier() { return 0; }
194
    virtual NewArrayDeclaratorAST *asNewArrayDeclarator() { return 0; }
195 196
    virtual NewExpressionAST *asNewExpression() { return 0; }
    virtual NewInitializerAST *asNewInitializer() { return 0; }
197
    virtual NewPlacementAST *asNewPlacement() { return 0; }
198 199
    virtual NewTypeIdAST *asNewTypeId() { return 0; }
    virtual NumericLiteralAST *asNumericLiteral() { return 0; }
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
    virtual ObjCClassDeclarationAST *asObjCClassDeclaration() { return 0; }
    virtual ObjCClassForwardDeclarationAST *asObjCClassForwardDeclaration() { return 0; }
    virtual ObjCDynamicPropertiesDeclarationAST *asObjCDynamicPropertiesDeclaration() { return 0; }
    virtual ObjCEncodeExpressionAST *asObjCEncodeExpression() { return 0; }
    virtual ObjCFastEnumerationAST *asObjCFastEnumeration() { return 0; }
    virtual ObjCInstanceVariablesDeclarationAST *asObjCInstanceVariablesDeclaration() { return 0; }
    virtual ObjCMessageArgumentAST *asObjCMessageArgument() { return 0; }
    virtual ObjCMessageArgumentDeclarationAST *asObjCMessageArgumentDeclaration() { return 0; }
    virtual ObjCMessageExpressionAST *asObjCMessageExpression() { return 0; }
    virtual ObjCMethodDeclarationAST *asObjCMethodDeclaration() { return 0; }
    virtual ObjCMethodPrototypeAST *asObjCMethodPrototype() { return 0; }
    virtual ObjCPropertyAttributeAST *asObjCPropertyAttribute() { return 0; }
    virtual ObjCPropertyDeclarationAST *asObjCPropertyDeclaration() { return 0; }
    virtual ObjCProtocolDeclarationAST *asObjCProtocolDeclaration() { return 0; }
    virtual ObjCProtocolExpressionAST *asObjCProtocolExpression() { return 0; }
    virtual ObjCProtocolForwardDeclarationAST *asObjCProtocolForwardDeclaration() { return 0; }
    virtual ObjCProtocolRefsAST *asObjCProtocolRefs() { return 0; }
    virtual ObjCSelectorAST *asObjCSelector() { return 0; }
    virtual ObjCSelectorArgumentAST *asObjCSelectorArgument() { return 0; }
    virtual ObjCSelectorExpressionAST *asObjCSelectorExpression() { return 0; }
    virtual ObjCSynchronizedStatementAST *asObjCSynchronizedStatement() { return 0; }
    virtual ObjCSynthesizedPropertiesDeclarationAST *asObjCSynthesizedPropertiesDeclaration() { return 0; }
    virtual ObjCSynthesizedPropertyAST *asObjCSynthesizedProperty() { return 0; }
    virtual ObjCTypeNameAST *asObjCTypeName() { return 0; }
    virtual ObjCVisibilityDeclarationAST *asObjCVisibilityDeclaration() { return 0; }
225 226 227 228 229
    virtual OperatorAST *asOperator() { return 0; }
    virtual OperatorFunctionIdAST *asOperatorFunctionId() { return 0; }
    virtual ParameterDeclarationAST *asParameterDeclaration() { return 0; }
    virtual ParameterDeclarationClauseAST *asParameterDeclarationClause() { return 0; }
    virtual PointerAST *asPointer() { return 0; }
Leandro Melo's avatar
Leandro Melo committed
230
    virtual PointerLiteralAST *asPointerLiteral() { return 0; }
231 232 233 234 235
    virtual PointerToMemberAST *asPointerToMember() { return 0; }
    virtual PostIncrDecrAST *asPostIncrDecr() { return 0; }
    virtual PostfixAST *asPostfix() { return 0; }
    virtual PostfixDeclaratorAST *asPostfixDeclarator() { return 0; }
    virtual PtrOperatorAST *asPtrOperator() { return 0; }
236 237
    virtual QtEnumDeclarationAST *asQtEnumDeclaration() { return 0; }
    virtual QtFlagsDeclarationAST *asQtFlagsDeclaration() { return 0; }
238 239
    virtual QtInterfaceNameAST *asQtInterfaceName() { return 0; }
    virtual QtInterfacesDeclarationAST *asQtInterfacesDeclaration() { return 0; }
240
    virtual QtMemberDeclarationAST *asQtMemberDeclaration() { return 0; }
241
    virtual QtMethodAST *asQtMethod() { return 0; }
242 243
    virtual QtObjectTagAST *asQtObjectTag() { return 0; }
    virtual QtPrivateSlotAST *asQtPrivateSlot() { return 0; }
244
    virtual QtPropertyDeclarationAST *asQtPropertyDeclaration() { return 0; }
245
    virtual QtPropertyDeclarationItemAST *asQtPropertyDeclarationItem() { return 0; }
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
    virtual QualifiedNameAST *asQualifiedName() { return 0; }
    virtual ReferenceAST *asReference() { return 0; }
    virtual ReturnStatementAST *asReturnStatement() { return 0; }
    virtual SimpleDeclarationAST *asSimpleDeclaration() { return 0; }
    virtual SimpleNameAST *asSimpleName() { return 0; }
    virtual SimpleSpecifierAST *asSimpleSpecifier() { return 0; }
    virtual SizeofExpressionAST *asSizeofExpression() { return 0; }
    virtual SpecifierAST *asSpecifier() { return 0; }
    virtual StatementAST *asStatement() { return 0; }
    virtual StringLiteralAST *asStringLiteral() { return 0; }
    virtual SwitchStatementAST *asSwitchStatement() { return 0; }
    virtual TemplateDeclarationAST *asTemplateDeclaration() { return 0; }
    virtual TemplateIdAST *asTemplateId() { return 0; }
    virtual TemplateTypeParameterAST *asTemplateTypeParameter() { return 0; }
    virtual ThisExpressionAST *asThisExpression() { return 0; }
    virtual ThrowExpressionAST *asThrowExpression() { return 0; }
262
    virtual TrailingReturnTypeAST *asTrailingReturnType() { return 0; }
263 264 265 266 267 268 269 270 271 272 273 274
    virtual TranslationUnitAST *asTranslationUnit() { return 0; }
    virtual TryBlockStatementAST *asTryBlockStatement() { return 0; }
    virtual TypeConstructorCallAST *asTypeConstructorCall() { return 0; }
    virtual TypeIdAST *asTypeId() { return 0; }
    virtual TypeidExpressionAST *asTypeidExpression() { return 0; }
    virtual TypenameCallExpressionAST *asTypenameCallExpression() { return 0; }
    virtual TypenameTypeParameterAST *asTypenameTypeParameter() { return 0; }
    virtual TypeofSpecifierAST *asTypeofSpecifier() { return 0; }
    virtual UnaryExpressionAST *asUnaryExpression() { return 0; }
    virtual UsingAST *asUsing() { return 0; }
    virtual UsingDirectiveAST *asUsingDirective() { return 0; }
    virtual WhileStatementAST *asWhileStatement() { return 0; }
275

con's avatar
con committed
276 277
protected:
    virtual void accept0(ASTVisitor *visitor) = 0;
278
    virtual bool match0(AST *, ASTMatcher *) = 0;
con's avatar
con committed
279 280
};

281 282 283
class CPLUSPLUS_EXPORT StatementAST: public AST
{
public:
284 285 286
    StatementAST()
    {}

287
    virtual StatementAST *asStatement() { return this; }
288 289

    virtual StatementAST *clone(MemoryPool *pool) const = 0;
290 291 292 293 294
};

class CPLUSPLUS_EXPORT ExpressionAST: public AST
{
public:
295 296 297
    ExpressionAST()
    {}

298
    virtual ExpressionAST *asExpression() { return this; }
299 300

    virtual ExpressionAST *clone(MemoryPool *pool) const = 0;
301 302 303 304 305
};

class CPLUSPLUS_EXPORT DeclarationAST: public AST
{
public:
306 307 308
    DeclarationAST()
    {}

309
    virtual DeclarationAST *asDeclaration() { return this; }
310 311

    virtual DeclarationAST *clone(MemoryPool *pool) const = 0;
312 313
};

Roberto Raggi's avatar
Roberto Raggi committed
314
class CPLUSPLUS_EXPORT NameAST: public AST
315 316
{
public: // annotations
Roberto Raggi's avatar
Roberto Raggi committed
317
    const Name *name;
318 319

public:
320 321 322 323
    NameAST()
        : name(0)
    {}

324
    virtual NameAST *asName() { return this; }
325 326

    virtual NameAST *clone(MemoryPool *pool) const = 0;
327 328
};

con's avatar
con committed
329 330
class CPLUSPLUS_EXPORT SpecifierAST: public AST
{
331
public:
332 333 334
    SpecifierAST()
    {}

335
    virtual SpecifierAST *asSpecifier() { return this; }
336 337

    virtual SpecifierAST *clone(MemoryPool *pool) const = 0;
con's avatar
con committed
338 339
};

340 341 342
class CPLUSPLUS_EXPORT PtrOperatorAST: public AST
{
public:
343 344 345
    PtrOperatorAST()
    {}

346
    virtual PtrOperatorAST *asPtrOperator() { return this; }
347 348

    virtual PtrOperatorAST *clone(MemoryPool *pool) const = 0;
349 350
};

351
class CPLUSPLUS_EXPORT PostfixAST: public ExpressionAST
352 353
{
public:
354 355 356
    PostfixAST()
    {}

357
    virtual PostfixAST *asPostfix() { return this; }
358 359

    virtual PostfixAST *clone(MemoryPool *pool) const = 0;
360 361 362 363 364
};

class CPLUSPLUS_EXPORT CoreDeclaratorAST: public AST
{
public:
365 366 367
    CoreDeclaratorAST()
    {}

368
    virtual CoreDeclaratorAST *asCoreDeclarator() { return this; }
369 370

    virtual CoreDeclaratorAST *clone(MemoryPool *pool) const = 0;
371 372 373 374 375
};

class CPLUSPLUS_EXPORT PostfixDeclaratorAST: public AST
{
public:
376 377 378
    PostfixDeclaratorAST()
    {}

379
    virtual PostfixDeclaratorAST *asPostfixDeclarator() { return this; }
380 381

    virtual PostfixDeclaratorAST *clone(MemoryPool *pool) const = 0;
382 383
};

384
class CPLUSPLUS_EXPORT ObjCSelectorArgumentAST: public AST
385
{
386 387 388 389 390
public:
    unsigned name_token;
    unsigned colon_token;

public:
391 392 393 394 395
    ObjCSelectorArgumentAST()
        : name_token(0)
        , colon_token(0)
    {}

396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
    virtual ObjCSelectorArgumentAST *asObjCSelectorArgument() { return this; }

    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

    virtual ObjCSelectorArgumentAST *clone(MemoryPool *pool) const;

protected:
    virtual void accept0(ASTVisitor *visitor);
    virtual bool match0(AST *, ASTMatcher *);
};

class CPLUSPLUS_EXPORT ObjCSelectorAST: public NameAST
{
public:
    ObjCSelectorArgumentListAST *selector_argument_list;
412 413

public:
414 415 416 417
    ObjCSelectorAST()
        : selector_argument_list(0)
    {}

418
    virtual ObjCSelectorAST *asObjCSelector() { return this; }
419

420 421 422 423 424 425 426 427
    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

    virtual ObjCSelectorAST *clone(MemoryPool *pool) const;

protected:
    virtual void accept0(ASTVisitor *visitor);
    virtual bool match0(AST *, ASTMatcher *);
428 429
};

con's avatar
con committed
430 431 432 433 434 435
class CPLUSPLUS_EXPORT SimpleSpecifierAST: public SpecifierAST
{
public:
    unsigned specifier_token;

public:
436 437 438 439
    SimpleSpecifierAST()
        : specifier_token(0)
    {}

440
    virtual SimpleSpecifierAST *asSimpleSpecifier() { return this; }
441

con's avatar
con committed
442 443 444
    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

445 446
    virtual SimpleSpecifierAST *clone(MemoryPool *pool) const;

con's avatar
con committed
447 448
protected:
    virtual void accept0(ASTVisitor *visitor);
449
    virtual bool match0(AST *, ASTMatcher *);
con's avatar
con committed
450 451 452 453 454 455 456 457
};

class CPLUSPLUS_EXPORT AttributeSpecifierAST: public SpecifierAST
{
public:
    unsigned attribute_token;
    unsigned first_lparen_token;
    unsigned second_lparen_token;
Roberto Raggi's avatar
Roberto Raggi committed
458
    AttributeListAST *attribute_list;
con's avatar
con committed
459 460 461 462
    unsigned first_rparen_token;
    unsigned second_rparen_token;

public:
463 464 465 466 467 468 469 470 471
    AttributeSpecifierAST()
        : attribute_token(0)
        , first_lparen_token(0)
        , second_lparen_token(0)
        , attribute_list(0)
        , first_rparen_token(0)
        , second_rparen_token(0)
    {}

472
    virtual AttributeSpecifierAST *asAttributeSpecifier() { return this; }
473

con's avatar
con committed
474 475 476
    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

477 478
    virtual AttributeSpecifierAST *clone(MemoryPool *pool) const;

con's avatar
con committed
479 480
protected:
    virtual void accept0(ASTVisitor *visitor);
481
    virtual bool match0(AST *, ASTMatcher *);
con's avatar
con committed
482 483 484 485 486 487 488 489 490 491 492 493
};

class CPLUSPLUS_EXPORT AttributeAST: public AST
{
public:
    unsigned identifier_token;
    unsigned lparen_token;
    unsigned tag_token;
    ExpressionListAST *expression_list;
    unsigned rparen_token;

public:
494 495 496 497 498 499 500 501
    AttributeAST()
        : identifier_token(0)
        , lparen_token(0)
        , tag_token(0)
        , expression_list(0)
        , rparen_token(0)
    {}

502
    virtual AttributeAST *asAttribute() { return this; }
503

con's avatar
con committed
504 505 506
    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

507 508
    virtual AttributeAST *clone(MemoryPool *pool) const;

con's avatar
con committed
509 510
protected:
    virtual void accept0(ASTVisitor *visitor);
511
    virtual bool match0(AST *, ASTMatcher *);
con's avatar
con committed
512 513 514 515 516 517
};

class CPLUSPLUS_EXPORT TypeofSpecifierAST: public SpecifierAST
{
public:
    unsigned typeof_token;
518
    unsigned lparen_token;
con's avatar
con committed
519
    ExpressionAST *expression;
520
    unsigned rparen_token;
con's avatar
con committed
521 522

public:
523 524 525 526 527 528 529
    TypeofSpecifierAST()
        : typeof_token(0)
        , lparen_token(0)
        , expression(0)
        , rparen_token(0)
    {}

530
    virtual TypeofSpecifierAST *asTypeofSpecifier() { return this; }
531

con's avatar
con committed
532 533 534
    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

535 536
    virtual TypeofSpecifierAST *clone(MemoryPool *pool) const;

con's avatar
con committed
537 538
protected:
    virtual void accept0(ASTVisitor *visitor);
539
    virtual bool match0(AST *, ASTMatcher *);
con's avatar
con committed
540 541 542 543 544
};

class CPLUSPLUS_EXPORT DeclaratorAST: public AST
{
public:
Roberto Raggi's avatar
Roberto Raggi committed
545 546
    SpecifierListAST *attribute_list;
    PtrOperatorListAST *ptr_operator_list;
con's avatar
con committed
547
    CoreDeclaratorAST *core_declarator;
Roberto Raggi's avatar
Roberto Raggi committed
548 549
    PostfixDeclaratorListAST *postfix_declarator_list;
    SpecifierListAST *post_attribute_list;
550
    unsigned equal_token;
con's avatar
con committed
551 552 553
    ExpressionAST *initializer;

public:
554 555 556 557 558 559
    DeclaratorAST()
        : attribute_list(0)
        , ptr_operator_list(0)
        , core_declarator(0)
        , postfix_declarator_list(0)
        , post_attribute_list(0)
560
        , equal_token(0)
561 562 563
        , initializer(0)
    {}

564
    virtual DeclaratorAST *asDeclarator() { return this; }
565

con's avatar
con committed
566 567 568
    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

569 570
    virtual DeclaratorAST *clone(MemoryPool *pool) const;

con's avatar
con committed
571 572
protected:
    virtual void accept0(ASTVisitor *visitor);
573
    virtual bool match0(AST *, ASTMatcher *);
con's avatar
con committed
574 575 576 577 578
};

class CPLUSPLUS_EXPORT SimpleDeclarationAST: public DeclarationAST
{
public:
579
    unsigned qt_invokable_token;
Roberto Raggi's avatar
Roberto Raggi committed
580 581
    SpecifierListAST *decl_specifier_list;
    DeclaratorListAST *declarator_list;
con's avatar
con committed
582 583
    unsigned semicolon_token;

Roberto Raggi's avatar
Roberto Raggi committed
584
public:
585
    List<Symbol *> *symbols;
Roberto Raggi's avatar
Roberto Raggi committed
586

con's avatar
con committed
587
public:
588 589 590 591 592 593 594 595
    SimpleDeclarationAST()
        : qt_invokable_token(0)
        , decl_specifier_list(0)
        , declarator_list(0)
        , semicolon_token(0)
        , symbols(0)
    {}

596
    virtual SimpleDeclarationAST *asSimpleDeclaration() { return this; }
597

con's avatar
con committed
598 599 600
    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

601 602
    virtual SimpleDeclarationAST *clone(MemoryPool *pool) const;

con's avatar
con committed
603 604
protected:
    virtual void accept0(ASTVisitor *visitor);
605
    virtual bool match0(AST *, ASTMatcher *);
con's avatar
con committed
606 607 608 609 610 611 612 613
};

class CPLUSPLUS_EXPORT EmptyDeclarationAST: public DeclarationAST
{
public:
    unsigned semicolon_token;

public:
614 615 616 617
    EmptyDeclarationAST()
        : semicolon_token(0)
    {}

618
    virtual EmptyDeclarationAST *asEmptyDeclaration() { return this; }
619

con's avatar
con committed
620 621 622
    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

623 624
    virtual EmptyDeclarationAST *clone(MemoryPool *pool) const;

con's avatar
con committed
625 626
protected:
    virtual void accept0(ASTVisitor *visitor);
627
    virtual bool match0(AST *, ASTMatcher *);
con's avatar
con committed
628 629 630 631 632 633 634 635 636 637
};

class CPLUSPLUS_EXPORT AccessDeclarationAST: public DeclarationAST
{
public:
    unsigned access_specifier_token;
    unsigned slots_token;
    unsigned colon_token;

public:
638 639 640 641 642 643
    AccessDeclarationAST()
        : access_specifier_token(0)
        , slots_token(0)
        , colon_token(0)
    {}

644
    virtual AccessDeclarationAST *asAccessDeclaration() { return this; }
645

con's avatar
con committed
646 647 648
    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

649 650
    virtual AccessDeclarationAST *clone(MemoryPool *pool) const;

con's avatar
con committed
651 652
protected:
    virtual void accept0(ASTVisitor *visitor);
653
    virtual bool match0(AST *, ASTMatcher *);
con's avatar
con committed
654 655
};

656 657 658 659 660 661
class CPLUSPLUS_EXPORT QtObjectTagAST: public DeclarationAST
{
public:
    unsigned q_object_token;

public:
662 663 664 665
    QtObjectTagAST()
        : q_object_token(0)
    {}

666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686
    virtual QtObjectTagAST *asQtObjectTag() { return this; }

    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

    virtual QtObjectTagAST *clone(MemoryPool *pool) const;

protected:
    virtual void accept0(ASTVisitor *visitor);
    virtual bool match0(AST *, ASTMatcher *);
};

class CPLUSPLUS_EXPORT QtPrivateSlotAST: public DeclarationAST
{
public:
    unsigned q_private_slot_token;
    unsigned lparen_token;
    unsigned dptr_token;
    unsigned dptr_lparen_token;
    unsigned dptr_rparen_token;
    unsigned comma_token;
Roberto Raggi's avatar
Roberto Raggi committed
687
    SpecifierListAST *type_specifier_list;
688 689 690 691
    DeclaratorAST *declarator;
    unsigned rparen_token;

public:
692 693 694 695 696 697 698
    QtPrivateSlotAST()
        : q_private_slot_token(0)
        , lparen_token(0)
        , dptr_token(0)
        , dptr_lparen_token(0)
        , dptr_rparen_token(0)
        , comma_token(0)
Roberto Raggi's avatar
Roberto Raggi committed
699
        , type_specifier_list(0)
700 701 702 703
        , declarator(0)
        , rparen_token(0)
    {}

704 705 706 707 708 709 710 711 712 713 714 715
    virtual QtPrivateSlotAST *asQtPrivateSlot() { return this; }

    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

    virtual QtPrivateSlotAST *clone(MemoryPool *pool) const;

protected:
    virtual void accept0(ASTVisitor *visitor);
    virtual bool match0(AST *, ASTMatcher *);
};

716 717 718 719
class QtPropertyDeclarationItemAST: public AST
{
public:
    unsigned item_name_token;
720
    ExpressionAST *expression;
721 722

public:
723 724 725 726 727
    QtPropertyDeclarationItemAST()
        : item_name_token(0)
        , expression(0)
    {}

728 729 730 731 732
    virtual QtPropertyDeclarationItemAST *asQtPropertyDeclarationItem() { return this; }

    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

733
    virtual QtPropertyDeclarationItemAST *clone(MemoryPool *pool) const;
734 735 736 737 738 739

protected:
    virtual void accept0(ASTVisitor *visitor);
    virtual bool match0(AST *, ASTMatcher *);
};

740
class CPLUSPLUS_EXPORT QtPropertyDeclarationAST: public DeclarationAST
741 742 743 744
{
public:
    unsigned property_specifier_token;
    unsigned lparen_token;
745 746
    ExpressionAST *expression; // for Q_PRIVATE_PROPERTY(expression, ...)
    unsigned comma_token;
747
    ExpressionAST *type_id;
748
    NameAST *property_name;
Roberto Raggi's avatar
Roberto Raggi committed
749
    QtPropertyDeclarationItemListAST *property_declaration_item_list;
750 751 752
    unsigned rparen_token;

public:
753 754 755
    QtPropertyDeclarationAST()
        : property_specifier_token(0)
        , lparen_token(0)
756 757
        , expression(0)
        , comma_token(0)
758 759
        , type_id(0)
        , property_name(0)
Roberto Raggi's avatar
Roberto Raggi committed
760
        , property_declaration_item_list(0)
761 762 763
        , rparen_token(0)
    {}

764
    virtual QtPropertyDeclarationAST *asQtPropertyDeclaration() { return this; }
765 766 767 768

    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

769
    virtual QtPropertyDeclarationAST *clone(MemoryPool *pool) const;
Wolfgang Beck's avatar
Wolfgang Beck committed
770

771 772 773 774 775
protected:
    virtual void accept0(ASTVisitor *visitor);
    virtual bool match0(AST *, ASTMatcher *);
};

776
class CPLUSPLUS_EXPORT QtEnumDeclarationAST: public DeclarationAST
777 778 779 780
{
public:
    unsigned enum_specifier_token;
    unsigned lparen_token;
781
    NameListAST *enumerator_list;
782 783 784
    unsigned rparen_token;

public:
785 786 787 788 789 790 791
    QtEnumDeclarationAST()
        : enum_specifier_token(0)
        , lparen_token(0)
        , enumerator_list(0)
        , rparen_token(0)
    {}

792
    virtual QtEnumDeclarationAST *asQtEnumDeclaration() { return this; }
793 794 795 796

    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

797
    virtual QtEnumDeclarationAST *clone(MemoryPool *pool) const;
Wolfgang Beck's avatar
Wolfgang Beck committed
798

799 800 801 802 803
protected:
    virtual void accept0(ASTVisitor *visitor);
    virtual bool match0(AST *, ASTMatcher *);
};

804
class CPLUSPLUS_EXPORT QtFlagsDeclarationAST: public DeclarationAST
805 806 807 808
{
public:
    unsigned flags_specifier_token;
    unsigned lparen_token;
809
    NameListAST *flag_enums_list;
810 811 812
    unsigned rparen_token;

public:
813 814 815 816 817 818 819
    QtFlagsDeclarationAST()
        : flags_specifier_token(0)
        , lparen_token(0)
        , flag_enums_list(0)
        , rparen_token(0)
    {}

820
    virtual QtFlagsDeclarationAST *asQtFlagsDeclaration() { return this; }
821 822 823 824

    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

825
    virtual QtFlagsDeclarationAST *clone(MemoryPool *pool) const;
Wolfgang Beck's avatar
Wolfgang Beck committed
826

827 828 829 830 831
protected:
    virtual void accept0(ASTVisitor *visitor);
    virtual bool match0(AST *, ASTMatcher *);
};

832 833 834 835 836 837 838
class CPLUSPLUS_EXPORT QtInterfaceNameAST: public AST
{
public:
    NameAST *interface_name;
    NameListAST *constraint_list;

public:
839 840 841 842 843
    QtInterfaceNameAST()
        : interface_name(0)
        , constraint_list(0)
    {}

844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864
    virtual QtInterfaceNameAST *asQtInterfaceName() { return this; }

    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

    virtual QtInterfaceNameAST *clone(MemoryPool *pool) const;

protected:
    virtual void accept0(ASTVisitor *visitor);
    virtual bool match0(AST *, ASTMatcher *);
};

class CPLUSPLUS_EXPORT QtInterfacesDeclarationAST: public DeclarationAST
{
public:
    unsigned interfaces_token;
    unsigned lparen_token;
    QtInterfaceNameListAST *interface_name_list;
    unsigned rparen_token;

public:
865 866 867 868 869 870 871
    QtInterfacesDeclarationAST()
        : interfaces_token(0)
        , lparen_token(0)
        , interface_name_list(0)
        , rparen_token(0)
    {}

872 873 874 875 876 877 878 879 880 881 882 883
    virtual QtInterfacesDeclarationAST *asQtInterfacesDeclaration() { return this; }

    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

    virtual QtInterfacesDeclarationAST *clone(MemoryPool *pool) const;

protected:
    virtual void accept0(ASTVisitor *visitor);
    virtual bool match0(AST *, ASTMatcher *);
};

con's avatar
con committed
884 885 886 887
class CPLUSPLUS_EXPORT AsmDefinitionAST: public DeclarationAST
{
public:
    unsigned asm_token;
888
    unsigned volatile_token;
con's avatar
con committed
889
    unsigned lparen_token;
890 891
    // ### string literals
    // ### asm operand list
con's avatar
con committed
892 893 894 895
    unsigned rparen_token;
    unsigned semicolon_token;

public:
896 897 898 899 900 901 902 903
    AsmDefinitionAST()
        : asm_token(0)
        , volatile_token(0)
        , lparen_token(0)
        , rparen_token(0)
        , semicolon_token(0)
    {}

904
    virtual AsmDefinitionAST *asAsmDefinition() { return this; }
905

con's avatar
con committed
906 907 908
    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

909 910
    virtual AsmDefinitionAST *clone(MemoryPool *pool) const;

con's avatar
con committed
911 912
protected:
    virtual void accept0(ASTVisitor *visitor);
913
    virtual bool match0(AST *, ASTMatcher *);
con's avatar
con committed
914 915 916 917 918
};

class CPLUSPLUS_EXPORT BaseSpecifierAST: public AST
{
public:
Roberto Raggi's avatar
cleanup  
Roberto Raggi committed
919 920
    unsigned virtual_token;
    unsigned access_specifier_token;
con's avatar
con committed
921 922
    NameAST *name;

Roberto Raggi's avatar
Roberto Raggi committed
923
public: // annotations
Roberto Raggi's avatar
Roberto Raggi committed
924
    BaseClass *symbol;
Roberto Raggi's avatar
Roberto Raggi committed
925

con's avatar
con committed
926
public:
927 928 929 930 931 932 933
    BaseSpecifierAST()
        : virtual_token(0)
        , access_specifier_token(0)
        , name(0)
        , symbol(0)
    {}

934
    virtual BaseSpecifierAST *asBaseSpecifier() { return this; }
935

con's avatar
con committed
936 937 938
    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

939 940
    virtual BaseSpecifierAST *clone(MemoryPool *pool) const;

con's avatar
con committed
941 942
protected:
    virtual void accept0(ASTVisitor *visitor);
943
    virtual bool match0(AST *, ASTMatcher *);
con's avatar
con committed
944 945
};

Roberto Raggi's avatar
Roberto Raggi committed
946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967
class CPLUSPLUS_EXPORT IdExpressionAST: public ExpressionAST
{
public:
    NameAST *name;

public:
    IdExpressionAST()
        : name(0)
    {}

    virtual IdExpressionAST *asIdExpression() { return this; }

    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

    virtual IdExpressionAST *clone(MemoryPool *pool) const;

protected:
    virtual void accept0(ASTVisitor *visitor);
    virtual bool match0(AST *, ASTMatcher *);
};

968 969 970 971
class CPLUSPLUS_EXPORT CompoundExpressionAST: public ExpressionAST
{
public:
    unsigned lparen_token;
972
    CompoundStatementAST *statement;
973 974 975
    unsigned rparen_token;

public:
976 977
    CompoundExpressionAST()
        : lparen_token(0)
978
        , statement(0)
979 980 981
        , rparen_token(0)
    {}

982 983 984 985 986 987 988 989 990 991 992 993
    virtual CompoundExpressionAST *asCompoundExpression() { return this; }

    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

    virtual CompoundExpressionAST *clone(MemoryPool *pool) const;

protected:
    virtual void accept0(ASTVisitor *visitor);
    virtual bool match0(AST *, ASTMatcher *);
};

994 995 996 997 998 999 1000 1001 1002
class CPLUSPLUS_EXPORT CompoundLiteralAST: public ExpressionAST
{
public:
    unsigned lparen_token;
    ExpressionAST *type_id;
    unsigned rparen_token;
    ExpressionAST *initializer;

public:
1003 1004 1005 1006 1007 1008 1009
    CompoundLiteralAST()
        : lparen_token(0)
        , type_id(0)
        , rparen_token(0)
        , initializer(0)
    {}

1010
    virtual CompoundLiteralAST *asCompoundLiteral() { return this; }
1011

1012 1013 1014
    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

1015 1016
    virtual CompoundLiteralAST *clone(MemoryPool *pool) const;

1017 1018
protected:
    virtual void accept0(ASTVisitor *visitor);
1019
    virtual bool match0(AST *, ASTMatcher *);
1020 1021
};

con's avatar
con committed
1022 1023 1024 1025 1026 1027 1028 1029 1030
class CPLUSPLUS_EXPORT QtMethodAST: public ExpressionAST
{
public:
    unsigned method_token;
    unsigned lparen_token;
    DeclaratorAST *declarator;
    unsigned rparen_token;

public:
1031 1032 1033 1034 1035 1036 1037
    QtMethodAST()
        : method_token(0)
        , lparen_token(0)
        , declarator(0)
        , rparen_token(0)
    {}

1038
    virtual QtMethodAST *asQtMethod() { return this; }
1039

con's avatar
con committed
1040 1041 1042
    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

1043 1044
    virtual QtMethodAST *clone(MemoryPool *pool) const;

con's avatar
con committed
1045 1046
protected:
    virtual void accept0(ASTVisitor *visitor);
1047
    virtual bool match0(AST *, ASTMatcher *);
con's avatar
con committed
1048 1049
};

1050 1051 1052 1053 1054 1055 1056 1057 1058
class CPLUSPLUS_EXPORT QtMemberDeclarationAST: public StatementAST
{
public:
    unsigned q_token;
    unsigned lparen_token;
    ExpressionAST *type_id;
    unsigned rparen_token;

public:
1059 1060 1061 1062 1063 1064 1065
    QtMemberDeclarationAST()
        : q_token(0)
        , lparen_token(0)
        , type_id(0)
        , rparen_token(0)
    {}

1066 1067 1068 1069 1070
    virtual QtMemberDeclarationAST *asQtMemberDeclaration() { return this; }

    virtual unsigned firstToken() const;
    virtual unsigned lastToken() const;

1071 1072
    virtual QtMemberDeclarationAST *clone(MemoryPool *pool) const;

1073 1074 1075 1076 1077
protected:
    virtual void accept0(ASTVisitor *visitor);
    virtual bool match0(AST *, ASTMatcher *);
};

con's avatar
con committed
1078 1079 1080 1081
class CPLUSPLUS_EXPORT BinaryExpressionAST: public ExpressionAST
{
public:
    ExpressionAST *left_expression;
1082
    unsigned binary_op_token;
con's avatar
con committed
1083 1084 1085
    ExpressionAST *right_expression;

public:
1086 1087 1088 1089 1090 1091
    BinaryExpressionAST()
        : left_expression(0)
        , binary_op_token(0)
        , right_expression(0)
    {}

1092
    virtual BinaryExpressionAST *asBinaryExpression() { return this; }
1093