1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 // Copyright (c) 2008 Roberto Raggi <roberto.raggi@gmail.com>

    42 //

    43 // Permission is hereby granted, free of charge, to any person obtaining a copy

    44 // of this software and associated documentation files (the "Software"), to deal

    45 // in the Software without restriction, including without limitation the rights

    46 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

    47 // copies of the Software, and to permit persons to whom the Software is

    48 // furnished to do so, subject to the following conditions:

    49 //

    50 // The above copyright notice and this permission notice shall be included in

    51 // all copies or substantial portions of the Software.

    52 //

    53 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

    54 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

    55 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

    56 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

    57 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

    58 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

    59 // THE SOFTWARE.

    60 

    61 #ifndef CPLUSPLUS_AST_H

    62 #define CPLUSPLUS_AST_H

    63 

    64 #include "CPlusPlusForwardDeclarations.h"

    65 #include "ASTfwd.h"

    66 #include "MemoryPool.h"

    67 

    68 namespace CPlusPlus {

    69 

    70 template <typename _Tp>

    71 class CPLUSPLUS_EXPORT List: public Managed

    72 {

    73     List(const List &other);

    74     void operator =(const List &other);

    75 

    76 public:

    77     List()

    78         : value(_Tp()), next(0)

    79     { }

    80 

    81     List(const _Tp &value)

    82         : value(value), next(0)

    83     { }

    84 

    85     unsigned firstToken() const

    86     {

    87         if (value)

    88             return value->firstToken();

    89 

    90         // ### assert(0);

    91         return 0;

    92     }

    93 

    94     unsigned lastToken() const

    95     {

    96         _Tp lastValue = 0;

    97 

    98         for (const List *it = this; it; it = it->next) {

    99             if (it->value)

   100                 lastValue = it->value;

   101         }

   102 

   103         if (lastValue)

   104             return lastValue->lastToken();

   105 

   106         // ### assert(0);

   107         return 0;

   108     }

   109     

   110     _Tp value;

   111     List *next;

   112 };

   113 

   114 class CPLUSPLUS_EXPORT AST: public Managed

   115 {

   116     AST(const AST &other);

   117     void operator =(const AST &other);

   118 

   119 public:

   120     AST();

   121     virtual ~AST();

   122 

   123     void accept(ASTVisitor *visitor);

   124 

   125     static void accept(AST *ast, ASTVisitor *visitor)

   126     { if (ast) ast->accept(visitor); }

   127 

   128     template <typename _Tp>

   129     static void accept(List<_Tp> *it, ASTVisitor *visitor)

   130     {

   131         for (; it; it = it->next)

   132             accept(it->value, visitor);

   133     }

   134 

   135     static bool match(AST *ast, AST *pattern, ASTMatcher *matcher);

   136     bool match(AST *pattern, ASTMatcher *matcher);

   137 

   138     template <typename _Tp>

   139     static bool match(List<_Tp> *it, List<_Tp> *patternIt, ASTMatcher *matcher)

   140     {

   141         while (it && patternIt) {

   142             if (! match(it->value, patternIt->value, matcher))

   143                 return false;

   144 

   145             it = it->next;

   146             patternIt = patternIt->next;

   147         }

   148 

   149         if (! it && ! patternIt)

   150             return true;

   151 

   152         return false;

   153     }

   154 

   155     virtual unsigned firstToken() const = 0;

   156     virtual unsigned lastToken() const = 0;

   157 

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

   159 

   160     virtual AccessDeclarationAST *asAccessDeclaration() { return 0; }

   161     virtual ArrayAccessAST *asArrayAccess() { return 0; }

   162     virtual ArrayDeclaratorAST *asArrayDeclarator() { return 0; }

   163     virtual ArrayInitializerAST *asArrayInitializer() { return 0; }

   164     virtual AsmDefinitionAST *asAsmDefinition() { return 0; }

   165     virtual AttributeAST *asAttribute() { return 0; }

   166     virtual AttributeSpecifierAST *asAttributeSpecifier() { return 0; }

   167     virtual BaseSpecifierAST *asBaseSpecifier() { return 0; }

   168     virtual BinaryExpressionAST *asBinaryExpression() { return 0; }

   169     virtual BoolLiteralAST *asBoolLiteral() { return 0; }

   170     virtual BreakStatementAST *asBreakStatement() { return 0; }

   171     virtual CallAST *asCall() { return 0; }

   172     virtual CaseStatementAST *asCaseStatement() { return 0; }

   173     virtual CastExpressionAST *asCastExpression() { return 0; }

   174     virtual CatchClauseAST *asCatchClause() { return 0; }

   175     virtual ClassSpecifierAST *asClassSpecifier() { return 0; }

   176     virtual CompoundLiteralAST *asCompoundLiteral() { return 0; }

   177     virtual CompoundStatementAST *asCompoundStatement() { return 0; }

   178     virtual ConditionAST *asCondition() { return 0; }

   179     virtual ConditionalExpressionAST *asConditionalExpression() { return 0; }

   180     virtual ContinueStatementAST *asContinueStatement() { return 0; }

   181     virtual ConversionFunctionIdAST *asConversionFunctionId() { return 0; }

   182     virtual CoreDeclaratorAST *asCoreDeclarator() { return 0; }

   183     virtual CppCastExpressionAST *asCppCastExpression() { return 0; }

   184     virtual CtorInitializerAST *asCtorInitializer() { return 0; }

   185     virtual DeclarationAST *asDeclaration() { return 0; }

   186     virtual DeclarationStatementAST *asDeclarationStatement() { return 0; }

   187     virtual DeclaratorAST *asDeclarator() { return 0; }

   188     virtual DeclaratorIdAST *asDeclaratorId() { return 0; }

   189     virtual DeleteExpressionAST *asDeleteExpression() { return 0; }

   190     virtual DestructorNameAST *asDestructorName() { return 0; }

   191     virtual DoStatementAST *asDoStatement() { return 0; }

   192     virtual ElaboratedTypeSpecifierAST *asElaboratedTypeSpecifier() { return 0; }

   193     virtual EmptyDeclarationAST *asEmptyDeclaration() { return 0; }

   194     virtual EnumSpecifierAST *asEnumSpecifier() { return 0; }

   195     virtual EnumeratorAST *asEnumerator() { return 0; }

   196     virtual ExceptionDeclarationAST *asExceptionDeclaration() { return 0; }

   197     virtual ExceptionSpecificationAST *asExceptionSpecification() { return 0; }

   198     virtual ExpressionAST *asExpression() { return 0; }

   199     virtual ExpressionOrDeclarationStatementAST *asExpressionOrDeclarationStatement() { return 0; }

   200     virtual ExpressionStatementAST *asExpressionStatement() { return 0; }

   201     virtual ForStatementAST *asForStatement() { return 0; }

   202     virtual ForeachStatementAST *asForeachStatement() { return 0; }

   203     virtual FunctionDeclaratorAST *asFunctionDeclarator() { return 0; }

   204     virtual FunctionDefinitionAST *asFunctionDefinition() { return 0; }

   205     virtual GotoStatementAST *asGotoStatement() { return 0; }

   206     virtual IfStatementAST *asIfStatement() { return 0; }

   207     virtual LabeledStatementAST *asLabeledStatement() { return 0; }

   208     virtual LinkageBodyAST *asLinkageBody() { return 0; }

   209     virtual LinkageSpecificationAST *asLinkageSpecification() { return 0; }

   210     virtual MemInitializerAST *asMemInitializer() { return 0; }

   211     virtual MemberAccessAST *asMemberAccess() { return 0; }

   212     virtual NameAST *asName() { return 0; }

   213     virtual NamedTypeSpecifierAST *asNamedTypeSpecifier() { return 0; }

   214     virtual NamespaceAST *asNamespace() { return 0; }

   215     virtual NamespaceAliasDefinitionAST *asNamespaceAliasDefinition() { return 0; }

   216     virtual NestedDeclaratorAST *asNestedDeclarator() { return 0; }

   217     virtual NestedExpressionAST *asNestedExpression() { return 0; }

   218     virtual NestedNameSpecifierAST *asNestedNameSpecifier() { return 0; }

   219     virtual NewArrayDeclaratorAST *asNewArrayDeclarator() { return 0; }

   220     virtual NewExpressionAST *asNewExpression() { return 0; }

   221     virtual NewInitializerAST *asNewInitializer() { return 0; }

   222     virtual NewPlacementAST *asNewPlacement() { return 0; }

   223     virtual NewTypeIdAST *asNewTypeId() { return 0; }

   224     virtual NumericLiteralAST *asNumericLiteral() { return 0; }

   225     virtual ObjCClassDeclarationAST *asObjCClassDeclaration() { return 0; }

   226     virtual ObjCClassForwardDeclarationAST *asObjCClassForwardDeclaration() { return 0; }

   227     virtual ObjCDynamicPropertiesDeclarationAST *asObjCDynamicPropertiesDeclaration() { return 0; }

   228     virtual ObjCEncodeExpressionAST *asObjCEncodeExpression() { return 0; }

   229     virtual ObjCFastEnumerationAST *asObjCFastEnumeration() { return 0; }

   230     virtual ObjCInstanceVariablesDeclarationAST *asObjCInstanceVariablesDeclaration() { return 0; }

   231     virtual ObjCMessageArgumentAST *asObjCMessageArgument() { return 0; }

   232     virtual ObjCMessageArgumentDeclarationAST *asObjCMessageArgumentDeclaration() { return 0; }

   233     virtual ObjCMessageExpressionAST *asObjCMessageExpression() { return 0; }

   234     virtual ObjCMethodDeclarationAST *asObjCMethodDeclaration() { return 0; }

   235     virtual ObjCMethodPrototypeAST *asObjCMethodPrototype() { return 0; }

   236     virtual ObjCPropertyAttributeAST *asObjCPropertyAttribute() { return 0; }

   237     virtual ObjCPropertyDeclarationAST *asObjCPropertyDeclaration() { return 0; }

   238     virtual ObjCProtocolDeclarationAST *asObjCProtocolDeclaration() { return 0; }

   239     virtual ObjCProtocolExpressionAST *asObjCProtocolExpression() { return 0; }

   240     virtual ObjCProtocolForwardDeclarationAST *asObjCProtocolForwardDeclaration() { return 0; }

   241     virtual ObjCProtocolRefsAST *asObjCProtocolRefs() { return 0; }

   242     virtual ObjCSelectorAST *asObjCSelector() { return 0; }

   243     virtual ObjCSelectorArgumentAST *asObjCSelectorArgument() { return 0; }

   244     virtual ObjCSelectorExpressionAST *asObjCSelectorExpression() { return 0; }

   245     virtual ObjCSelectorWithArgumentsAST *asObjCSelectorWithArguments() { return 0; }

   246     virtual ObjCSelectorWithoutArgumentsAST *asObjCSelectorWithoutArguments() { return 0; }

   247     virtual ObjCSynchronizedStatementAST *asObjCSynchronizedStatement() { return 0; }

   248     virtual ObjCSynthesizedPropertiesDeclarationAST *asObjCSynthesizedPropertiesDeclaration() { return 0; }

   249     virtual ObjCSynthesizedPropertyAST *asObjCSynthesizedProperty() { return 0; }

   250     virtual ObjCTypeNameAST *asObjCTypeName() { return 0; }

   251     virtual ObjCVisibilityDeclarationAST *asObjCVisibilityDeclaration() { return 0; }

   252     virtual OperatorAST *asOperator() { return 0; }

   253     virtual OperatorFunctionIdAST *asOperatorFunctionId() { return 0; }

   254     virtual ParameterDeclarationAST *asParameterDeclaration() { return 0; }

   255     virtual ParameterDeclarationClauseAST *asParameterDeclarationClause() { return 0; }

   256     virtual PointerAST *asPointer() { return 0; }

   257     virtual PointerToMemberAST *asPointerToMember() { return 0; }

   258     virtual PostIncrDecrAST *asPostIncrDecr() { return 0; }

   259     virtual PostfixAST *asPostfix() { return 0; }

   260     virtual PostfixDeclaratorAST *asPostfixDeclarator() { return 0; }

   261     virtual PostfixExpressionAST *asPostfixExpression() { return 0; }

   262     virtual PtrOperatorAST *asPtrOperator() { return 0; }

   263     virtual QtMemberDeclarationAST *asQtMemberDeclaration() { return 0; }

   264     virtual QtMethodAST *asQtMethod() { return 0; }

   265     virtual QualifiedNameAST *asQualifiedName() { return 0; }

   266     virtual ReferenceAST *asReference() { return 0; }

   267     virtual ReturnStatementAST *asReturnStatement() { return 0; }

   268     virtual SimpleDeclarationAST *asSimpleDeclaration() { return 0; }

   269     virtual SimpleNameAST *asSimpleName() { return 0; }

   270     virtual SimpleSpecifierAST *asSimpleSpecifier() { return 0; }

   271     virtual SizeofExpressionAST *asSizeofExpression() { return 0; }

   272     virtual SpecifierAST *asSpecifier() { return 0; }

   273     virtual StatementAST *asStatement() { return 0; }

   274     virtual StringLiteralAST *asStringLiteral() { return 0; }

   275     virtual SwitchStatementAST *asSwitchStatement() { return 0; }

   276     virtual TemplateDeclarationAST *asTemplateDeclaration() { return 0; }

   277     virtual TemplateIdAST *asTemplateId() { return 0; }

   278     virtual TemplateTypeParameterAST *asTemplateTypeParameter() { return 0; }

   279     virtual ThisExpressionAST *asThisExpression() { return 0; }

   280     virtual ThrowExpressionAST *asThrowExpression() { return 0; }

   281     virtual TranslationUnitAST *asTranslationUnit() { return 0; }

   282     virtual TryBlockStatementAST *asTryBlockStatement() { return 0; }

   283     virtual TypeConstructorCallAST *asTypeConstructorCall() { return 0; }

   284     virtual TypeIdAST *asTypeId() { return 0; }

   285     virtual TypeidExpressionAST *asTypeidExpression() { return 0; }

   286     virtual TypenameCallExpressionAST *asTypenameCallExpression() { return 0; }

   287     virtual TypenameTypeParameterAST *asTypenameTypeParameter() { return 0; }

   288     virtual TypeofSpecifierAST *asTypeofSpecifier() { return 0; }

   289     virtual UnaryExpressionAST *asUnaryExpression() { return 0; }

   290     virtual UsingAST *asUsing() { return 0; }

   291     virtual UsingDirectiveAST *asUsingDirective() { return 0; }

   292     virtual WhileStatementAST *asWhileStatement() { return 0; }

   293 #ifdef ICHECK_BUILD

   294     virtual QPropertyDeclarationAST *asQPropertyDeclarationAST() { return 0; }

   295     virtual QEnumDeclarationAST *asQEnumDeclarationAST() { return 0; }

   296     virtual QFlagsDeclarationAST *asQFlagsDeclarationAST() { return 0; }

   297     virtual QDeclareFlagsDeclarationAST *asQDeclareFlagsDeclarationAST() { return 0; }

   298 #endif

   299 

   300 protected:

   301     virtual void accept0(ASTVisitor *visitor) = 0;

   302     virtual bool match0(AST *, ASTMatcher *) = 0;

   303 };

   304 

   305 class CPLUSPLUS_EXPORT StatementAST: public AST

   306 {

   307 public:

   308     virtual StatementAST *asStatement() { return this; }

   309 

   310     virtual StatementAST *clone(MemoryPool *pool) const = 0;

   311 };

   312 

   313 class CPLUSPLUS_EXPORT ExpressionAST: public AST

   314 {

   315 public:

   316     virtual ExpressionAST *asExpression() { return this; }

   317 

   318     virtual ExpressionAST *clone(MemoryPool *pool) const = 0;

   319 };

   320 

   321 class CPLUSPLUS_EXPORT DeclarationAST: public AST

   322 {

   323 public:

   324     virtual DeclarationAST *asDeclaration() { return this; }

   325 

   326     virtual DeclarationAST *clone(MemoryPool *pool) const = 0;

   327 

   328 #ifdef ICHECK_BUILD

   329     unsigned invoke_token;

   330 #endif

   331 };

   332 

   333 class CPLUSPLUS_EXPORT NameAST: public ExpressionAST

   334 {

   335 public: // annotations

   336     const Name *name;

   337 

   338 public:

   339     virtual NameAST *asName() { return this; }

   340 

   341     virtual NameAST *clone(MemoryPool *pool) const = 0;

   342 };

   343 

   344 class CPLUSPLUS_EXPORT SpecifierAST: public AST

   345 {

   346 public:

   347     virtual SpecifierAST *asSpecifier() { return this; }

   348 

   349     virtual SpecifierAST *clone(MemoryPool *pool) const = 0;

   350 };

   351 

   352 class CPLUSPLUS_EXPORT PtrOperatorAST: public AST

   353 {

   354 public:

   355     virtual PtrOperatorAST *asPtrOperator() { return this; }

   356 

   357     virtual PtrOperatorAST *clone(MemoryPool *pool) const = 0;

   358 };

   359 

   360 class CPLUSPLUS_EXPORT PostfixAST: public AST

   361 {

   362 public:

   363     virtual PostfixAST *asPostfix() { return this; }

   364 

   365     virtual PostfixAST *clone(MemoryPool *pool) const = 0;

   366 };

   367 

   368 class CPLUSPLUS_EXPORT CoreDeclaratorAST: public AST

   369 {

   370 public:

   371     virtual CoreDeclaratorAST *asCoreDeclarator() { return this; }

   372 

   373     virtual CoreDeclaratorAST *clone(MemoryPool *pool) const = 0;

   374 };

   375 

   376 class CPLUSPLUS_EXPORT PostfixDeclaratorAST: public AST

   377 {

   378 public:

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

   380 

   381     virtual PostfixDeclaratorAST *clone(MemoryPool *pool) const = 0;

   382 };

   383 

   384 class CPLUSPLUS_EXPORT ObjCSelectorAST: public AST

   385 {

   386 public: // annotation

   387     const Name *selector_name;

   388 

   389 public:

   390     virtual ObjCSelectorAST *asObjCSelector() { return this; }

   391 

   392     virtual ObjCSelectorAST *clone(MemoryPool *pool) const = 0;

   393 };

   394 

   395 class CPLUSPLUS_EXPORT SimpleSpecifierAST: public SpecifierAST

   396 {

   397 public:

   398     unsigned specifier_token;

   399 

   400 public:

   401     virtual SimpleSpecifierAST *asSimpleSpecifier() { return this; }

   402 

   403     virtual unsigned firstToken() const;

   404     virtual unsigned lastToken() const;

   405 

   406     virtual SimpleSpecifierAST *clone(MemoryPool *pool) const;

   407 

   408 protected:

   409     virtual void accept0(ASTVisitor *visitor);

   410     virtual bool match0(AST *, ASTMatcher *);

   411 };

   412 

   413 class CPLUSPLUS_EXPORT AttributeSpecifierAST: public SpecifierAST

   414 {

   415 public:

   416     unsigned attribute_token;

   417     unsigned first_lparen_token;

   418     unsigned second_lparen_token;

   419     AttributeListAST *attribute_list;

   420     unsigned first_rparen_token;

   421     unsigned second_rparen_token;

   422 

   423 public:

   424     virtual AttributeSpecifierAST *asAttributeSpecifier() { return this; }

   425 

   426     virtual unsigned firstToken() const;

   427     virtual unsigned lastToken() const;

   428 

   429     virtual AttributeSpecifierAST *clone(MemoryPool *pool) const;

   430 

   431 protected:

   432     virtual void accept0(ASTVisitor *visitor);

   433     virtual bool match0(AST *, ASTMatcher *);

   434 };

   435 

   436 class CPLUSPLUS_EXPORT AttributeAST: public AST

   437 {

   438 public:

   439     unsigned identifier_token;

   440     unsigned lparen_token;

   441     unsigned tag_token;

   442     ExpressionListAST *expression_list;

   443     unsigned rparen_token;

   444 

   445 public:

   446     virtual AttributeAST *asAttribute() { return this; }

   447 

   448     virtual unsigned firstToken() const;

   449     virtual unsigned lastToken() const;

   450 

   451     virtual AttributeAST *clone(MemoryPool *pool) const;

   452 

   453 protected:

   454     virtual void accept0(ASTVisitor *visitor);

   455     virtual bool match0(AST *, ASTMatcher *);

   456 };

   457 

   458 class CPLUSPLUS_EXPORT TypeofSpecifierAST: public SpecifierAST

   459 {

   460 public:

   461     unsigned typeof_token;

   462     unsigned lparen_token;

   463     ExpressionAST *expression;

   464     unsigned rparen_token;

   465 

   466 public:

   467     virtual TypeofSpecifierAST *asTypeofSpecifier() { return this; }

   468 

   469     virtual unsigned firstToken() const;

   470     virtual unsigned lastToken() const;

   471 

   472     virtual TypeofSpecifierAST *clone(MemoryPool *pool) const;

   473 

   474 protected:

   475     virtual void accept0(ASTVisitor *visitor);

   476     virtual bool match0(AST *, ASTMatcher *);

   477 };

   478 

   479 class CPLUSPLUS_EXPORT DeclaratorAST: public AST

   480 {

   481 public:

   482     SpecifierListAST *attribute_list;

   483     PtrOperatorListAST *ptr_operator_list;

   484     CoreDeclaratorAST *core_declarator;

   485     PostfixDeclaratorListAST *postfix_declarator_list;

   486     SpecifierListAST *post_attribute_list;

   487     unsigned equals_token;

   488     ExpressionAST *initializer;

   489 

   490 public:

   491     virtual DeclaratorAST *asDeclarator() { return this; }

   492 

   493     virtual unsigned firstToken() const;

   494     virtual unsigned lastToken() const;

   495 

   496     virtual DeclaratorAST *clone(MemoryPool *pool) const;

   497 

   498 protected:

   499     virtual void accept0(ASTVisitor *visitor);

   500     virtual bool match0(AST *, ASTMatcher *);

   501 };

   502 

   503 class CPLUSPLUS_EXPORT SimpleDeclarationAST: public DeclarationAST

   504 {

   505 public:

   506     unsigned qt_invokable_token;

   507     SpecifierListAST *decl_specifier_list;

   508     DeclaratorListAST *declarator_list;

   509     unsigned semicolon_token;

   510 

   511 public:

   512     List<Declaration *> *symbols;

   513 

   514 public:

   515     virtual SimpleDeclarationAST *asSimpleDeclaration() { return this; }

   516 

   517     virtual unsigned firstToken() const;

   518     virtual unsigned lastToken() const;

   519 

   520     virtual SimpleDeclarationAST *clone(MemoryPool *pool) const;

   521 

   522 protected:

   523     virtual void accept0(ASTVisitor *visitor);

   524     virtual bool match0(AST *, ASTMatcher *);

   525 };

   526 

   527 class CPLUSPLUS_EXPORT EmptyDeclarationAST: public DeclarationAST

   528 {

   529 public:

   530     unsigned semicolon_token;

   531 

   532 public:

   533     virtual EmptyDeclarationAST *asEmptyDeclaration() { return this; }

   534 

   535     virtual unsigned firstToken() const;

   536     virtual unsigned lastToken() const;

   537 

   538     virtual EmptyDeclarationAST *clone(MemoryPool *pool) const;

   539 

   540 protected:

   541     virtual void accept0(ASTVisitor *visitor);

   542     virtual bool match0(AST *, ASTMatcher *);

   543 };

   544 

   545 class CPLUSPLUS_EXPORT AccessDeclarationAST: public DeclarationAST

   546 {

   547 public:

   548     unsigned access_specifier_token;

   549     unsigned slots_token;

   550     unsigned colon_token;

   551 

   552 public:

   553     virtual AccessDeclarationAST *asAccessDeclaration() { return this; }

   554 

   555     virtual unsigned firstToken() const;

   556     virtual unsigned lastToken() const;

   557 

   558     virtual AccessDeclarationAST *clone(MemoryPool *pool) const;

   559 

   560 protected:

   561     virtual void accept0(ASTVisitor *visitor);

   562     virtual bool match0(AST *, ASTMatcher *);

   563 };

   564 

   565 #ifdef ICHECK_BUILD

   566 class CPLUSPLUS_EXPORT QPropertyDeclarationAST: public DeclarationAST

   567 {

   568     /*

   569     Q_PROPERTY(type name

   570             READ getFunction

   571             [WRITE setFunction]

   572             [RESET resetFunction]

   573             [NOTIFY notifySignal]

   574             [DESIGNABLE bool]

   575             [SCRIPTABLE bool]

   576             [STORED bool]

   577             [USER bool]

   578             [CONSTANT]

   579             [FINAL])*/

   580 public:

   581     unsigned property_specifier_token;

   582     unsigned lparen_token;

   583     unsigned type_token;

   584     unsigned type_name_token;

   585     unsigned read_token;

   586     unsigned read_function_token;

   587     unsigned write_token;

   588     unsigned write_function_token;

   589     unsigned reset_token;

   590     unsigned reset_function_token;

   591     unsigned notify_token;

   592     unsigned notify_function_token;

   593     unsigned rparen_token;

   594 

   595 public:

   596     virtual QPropertyDeclarationAST *asQPropertyDeclarationAST() { return this; }

   597 

   598     virtual unsigned firstToken() const;

   599     virtual unsigned lastToken() const;

   600 

   601     virtual QPropertyDeclarationAST *clone(MemoryPool *pool) const;

   602 

   603 protected:

   604     virtual void accept0(ASTVisitor *visitor);

   605     virtual bool match0(AST *, ASTMatcher *);

   606 };

   607 

   608 class CPLUSPLUS_EXPORT QEnumDeclarationAST: public DeclarationAST

   609 {

   610     /*Q_ENUMS(enum1, enum2)*/

   611 public:

   612     unsigned enum_specifier_token;

   613     unsigned lparen_token;

   614     unsigned rparen_token;

   615     EnumeratorListAST *enumerator_list;

   616 

   617 public:

   618     virtual QEnumDeclarationAST *asQEnumDeclarationAST() { return this; }

   619 

   620     virtual unsigned firstToken() const;

   621     virtual unsigned lastToken() const;

   622 

   623     virtual QEnumDeclarationAST *clone(MemoryPool *pool) const;

   624 

   625 protected:

   626     virtual void accept0(ASTVisitor *visitor);

   627     virtual bool match0(AST *, ASTMatcher *);

   628 };

   629 

   630 class CPLUSPLUS_EXPORT QFlagsDeclarationAST: public DeclarationAST

   631 {

   632     /*Q_FLAGS(enum1 enum2 flags1 ...)*/

   633 public:

   634     unsigned flags_specifier_token;

   635     unsigned lparen_token;

   636     unsigned rparen_token;

   637     EnumeratorListAST *enumerator_list;

   638 

   639 public:

   640     virtual QFlagsDeclarationAST *asQFlagsDeclarationAST() { return this; }

   641 

   642     virtual unsigned firstToken() const;

   643     virtual unsigned lastToken() const;

   644 

   645     virtual QFlagsDeclarationAST *clone(MemoryPool *pool) const;

   646 

   647 protected:

   648     virtual void accept0(ASTVisitor *visitor);

   649     virtual bool match0(AST *, ASTMatcher *);

   650 };

   651 

   652 class CPLUSPLUS_EXPORT QDeclareFlagsDeclarationAST: public DeclarationAST

   653 {

   654     /*Q_DECLARE_FLAGS(flag enum)*/

   655 public:

   656     unsigned declareflags_specifier_token;

   657     unsigned lparen_token;

   658     unsigned flag_token;

   659     unsigned enum_token;

   660     unsigned rparen_token;

   661 

   662 public:

   663     virtual QDeclareFlagsDeclarationAST *asQDeclareFlagsDeclarationAST() { return this; }

   664 

   665     virtual unsigned firstToken() const;

   666     virtual unsigned lastToken() const;

   667 

   668     virtual QDeclareFlagsDeclarationAST *clone(MemoryPool *pool) const;

   669 

   670 protected:

   671     virtual void accept0(ASTVisitor *visitor);

   672     virtual bool match0(AST *, ASTMatcher *);

   673 };

   674 #endif

   675 

   676 class CPLUSPLUS_EXPORT AsmDefinitionAST: public DeclarationAST

   677 {

   678 public:

   679     unsigned asm_token;

   680     unsigned volatile_token;

   681     unsigned lparen_token;

   682     // ### string literals

   683     // ### asm operand list

   684     unsigned rparen_token;

   685     unsigned semicolon_token;

   686 

   687 public:

   688     virtual AsmDefinitionAST *asAsmDefinition() { return this; }

   689 

   690     virtual unsigned firstToken() const;

   691     virtual unsigned lastToken() const;

   692 

   693     virtual AsmDefinitionAST *clone(MemoryPool *pool) const;

   694 

   695 protected:

   696     virtual void accept0(ASTVisitor *visitor);

   697     virtual bool match0(AST *, ASTMatcher *);

   698 };

   699 

   700 class CPLUSPLUS_EXPORT BaseSpecifierAST: public AST

   701 {

   702 public:

   703     unsigned virtual_token;

   704     unsigned access_specifier_token;

   705     NameAST *name;

   706 

   707 public: // annotations

   708     BaseClass *symbol;

   709 

   710 public:

   711     virtual BaseSpecifierAST *asBaseSpecifier() { return this; }

   712 

   713     virtual unsigned firstToken() const;

   714     virtual unsigned lastToken() const;

   715 

   716     virtual BaseSpecifierAST *clone(MemoryPool *pool) const;

   717 

   718 protected:

   719     virtual void accept0(ASTVisitor *visitor);

   720     virtual bool match0(AST *, ASTMatcher *);

   721 };

   722 

   723 class CPLUSPLUS_EXPORT CompoundLiteralAST: public ExpressionAST

   724 {

   725 public:

   726     unsigned lparen_token;

   727     ExpressionAST *type_id;

   728     unsigned rparen_token;

   729     ExpressionAST *initializer;

   730 

   731 public:

   732     virtual CompoundLiteralAST *asCompoundLiteral() { return this; }

   733 

   734     virtual unsigned firstToken() const;

   735     virtual unsigned lastToken() const;

   736 

   737     virtual CompoundLiteralAST *clone(MemoryPool *pool) const;

   738 

   739 protected:

   740     virtual void accept0(ASTVisitor *visitor);

   741     virtual bool match0(AST *, ASTMatcher *);

   742 };

   743 

   744 class CPLUSPLUS_EXPORT QtMethodAST: public ExpressionAST

   745 {

   746 public:

   747     unsigned method_token;

   748     unsigned lparen_token;

   749     DeclaratorAST *declarator;

   750     unsigned rparen_token;

   751 

   752 public:

   753     virtual QtMethodAST *asQtMethod() { return this; }

   754 

   755     virtual unsigned firstToken() const;

   756     virtual unsigned lastToken() const;

   757 

   758     virtual QtMethodAST *clone(MemoryPool *pool) const;

   759 

   760 protected:

   761     virtual void accept0(ASTVisitor *visitor);

   762     virtual bool match0(AST *, ASTMatcher *);

   763 };

   764 

   765 class CPLUSPLUS_EXPORT QtMemberDeclarationAST: public StatementAST

   766 {

   767 public:

   768     unsigned q_token;

   769     unsigned lparen_token;

   770     ExpressionAST *type_id;

   771     unsigned rparen_token;

   772 

   773 public:

   774     virtual QtMemberDeclarationAST *asQtMemberDeclaration() { return this; }

   775 

   776     virtual unsigned firstToken() const;

   777     virtual unsigned lastToken() const;

   778 

   779     virtual QtMemberDeclarationAST *clone(MemoryPool *pool) const;

   780 

   781 protected:

   782     virtual void accept0(ASTVisitor *visitor);

   783     virtual bool match0(AST *, ASTMatcher *);

   784 };

   785 

   786 class CPLUSPLUS_EXPORT BinaryExpressionAST: public ExpressionAST

   787 {

   788 public:

   789     ExpressionAST *left_expression;

   790     unsigned binary_op_token;

   791     ExpressionAST *right_expression;

   792 

   793 public:

   794     virtual BinaryExpressionAST *asBinaryExpression() { return this; }

   795 

   796     virtual unsigned firstToken() const;

   797     virtual unsigned lastToken() const;

   798 

   799     virtual BinaryExpressionAST *clone(MemoryPool *pool) const;

   800 

   801 protected:

   802     virtual void accept0(ASTVisitor *visitor);

   803     virtual bool match0(AST *, ASTMatcher *);

   804 };

   805 

   806 class CPLUSPLUS_EXPORT CastExpressionAST: public ExpressionAST

   807 {

   808 public:

   809     unsigned lparen_token;

   810     ExpressionAST *type_id;

   811     unsigned rparen_token;

   812     ExpressionAST *expression;

   813 

   814 public:

   815     virtual CastExpressionAST *asCastExpression() { return this; }

   816 

   817     virtual unsigned firstToken() const;

   818     virtual unsigned lastToken() const;

   819 

   820     virtual CastExpressionAST *clone(MemoryPool *pool) const;

   821 

   822 protected:

   823     virtual void accept0(ASTVisitor *visitor);

   824     virtual bool match0(AST *, ASTMatcher *);

   825 };

   826 

   827 class CPLUSPLUS_EXPORT ClassSpecifierAST: public SpecifierAST

   828 {

   829 public:

   830     unsigned classkey_token;

   831     SpecifierListAST *attribute_list;

   832     NameAST *name;

   833     unsigned colon_token;

   834     BaseSpecifierListAST *base_clause_list;

   835     unsigned lbrace_token;

   836     DeclarationListAST *member_specifier_list;

   837     unsigned rbrace_token;

   838 

   839 public: // annotations

   840     Class *symbol;

   841 

   842 public:

   843     virtual ClassSpecifierAST *asClassSpecifier() { return this; }

   844 

   845     virtual unsigned firstToken() const;

   846     virtual unsigned lastToken() const;

   847 

   848     virtual ClassSpecifierAST *clone(MemoryPool *pool) const;

   849 

   850 protected:

   851     virtual void accept0(ASTVisitor *visitor);

   852     virtual bool match0(AST *, ASTMatcher *);

   853 };

   854 

   855 class CPLUSPLUS_EXPORT CaseStatementAST: public StatementAST

   856 {

   857 public:

   858     unsigned case_token;

   859     ExpressionAST *expression;

   860     unsigned colon_token;

   861     StatementAST *statement;

   862 

   863 public:

   864     virtual CaseStatementAST *asCaseStatement() { return this; }

   865 

   866     virtual unsigned firstToken() const;

   867     virtual unsigned lastToken() const;

   868 

   869     virtual CaseStatementAST *clone(MemoryPool *pool) const;

   870 

   871 protected:

   872     virtual void accept0(ASTVisitor *visitor);

   873     virtual bool match0(AST *, ASTMatcher *);

   874 };

   875 

   876 class CPLUSPLUS_EXPORT CompoundStatementAST: public StatementAST

   877 {

   878 public:

   879     unsigned lbrace_token;

   880     StatementListAST *statement_list;

   881     unsigned rbrace_token;

   882 

   883 public: // annotations

   884     Block *symbol;

   885 

   886 public:

   887     virtual CompoundStatementAST *asCompoundStatement() { return this; }

   888 

   889     virtual unsigned firstToken() const;

   890     virtual unsigned lastToken() const;

   891 

   892     virtual CompoundStatementAST *clone(MemoryPool *pool) const;

   893 

   894 protected:

   895     virtual void accept0(ASTVisitor *visitor);

   896     virtual bool match0(AST *, ASTMatcher *);

   897 };

   898 

   899 class CPLUSPLUS_EXPORT ConditionAST: public ExpressionAST

   900 {

   901 public:

   902     SpecifierListAST *type_specifier_list;

   903     DeclaratorAST *declarator;

   904 

   905 public:

   906     virtual ConditionAST *asCondition() { return this; }

   907 

   908     virtual unsigned firstToken() const;

   909     virtual unsigned lastToken() const;

   910 

   911     virtual ConditionAST *clone(MemoryPool *pool) const;

   912 

   913 protected:

   914     virtual void accept0(ASTVisitor *visitor);

   915     virtual bool match0(AST *, ASTMatcher *);

   916 };

   917 

   918 class CPLUSPLUS_EXPORT ConditionalExpressionAST: public ExpressionAST

   919 {

   920 public:

   921     ExpressionAST *condition;

   922     unsigned question_token;

   923     ExpressionAST *left_expression;

   924     unsigned colon_token;

   925     ExpressionAST *right_expression;

   926 

   927 public:

   928     virtual ConditionalExpressionAST *asConditionalExpression() { return this; }

   929 

   930     virtual unsigned firstToken() const;

   931     virtual unsigned lastToken() const;

   932 

   933     virtual ConditionalExpressionAST *clone(MemoryPool *pool) const;

   934 

   935 protected:

   936     virtual void accept0(ASTVisitor *visitor);

   937     virtual bool match0(AST *, ASTMatcher *);

   938 };

   939 

   940 class CPLUSPLUS_EXPORT CppCastExpressionAST: public ExpressionAST

   941 {

   942 public:

   943     unsigned cast_token;

   944     unsigned less_token;

   945     ExpressionAST *type_id;

   946     unsigned greater_token;

   947     unsigned lparen_token;

   948     ExpressionAST *expression;

   949     unsigned rparen_token;

   950 

   951 public:

   952     virtual CppCastExpressionAST *asCppCastExpression() { return this; }

   953 

   954     virtual unsigned firstToken() const;

   955     virtual unsigned lastToken() const;

   956 

   957     virtual CppCastExpressionAST *clone(MemoryPool *pool) const;

   958 

   959 protected:

   960     virtual void accept0(ASTVisitor *visitor);

   961     virtual bool match0(AST *, ASTMatcher *);

   962 };

   963 

   964 class CPLUSPLUS_EXPORT CtorInitializerAST: public AST

   965 {

   966 public:

   967     unsigned colon_token;

   968     MemInitializerListAST *member_initializer_list;

   969 

   970 public:

   971     virtual CtorInitializerAST *asCtorInitializer() { return this; }

   972 

   973     virtual unsigned firstToken() const;

   974     virtual unsigned lastToken() const;

   975 

   976     virtual CtorInitializerAST *clone(MemoryPool *pool) const;

   977 

   978 protected:

   979     virtual void accept0(ASTVisitor *visitor);

   980     virtual bool match0(AST *, ASTMatcher *);

   981 };

   982 

   983 class CPLUSPLUS_EXPORT DeclarationStatementAST: public StatementAST

   984 {

   985 public:

   986     DeclarationAST *declaration;

   987 

   988 public:

   989     virtual DeclarationStatementAST *asDeclarationStatement() { return this; }

   990 

   991     virtual unsigned firstToken() const;

   992     virtual unsigned lastToken() const;

   993 

   994     virtual DeclarationStatementAST *clone(MemoryPool *pool) const;

   995 

   996 protected:

   997     virtual void accept0(ASTVisitor *visitor);

   998     virtual bool match0(AST *, ASTMatcher *);

   999 };

  1000 

  1001 class CPLUSPLUS_EXPORT DeclaratorIdAST: public CoreDeclaratorAST

  1002 {

  1003 public:

  1004     NameAST *name;

  1005 

  1006 public:

  1007     virtual DeclaratorIdAST *asDeclaratorId() { return this; }

  1008 

  1009     virtual unsigned firstToken() const;

  1010     virtual unsigned lastToken() const;

  1011 

  1012     virtual DeclaratorIdAST *clone(MemoryPool *pool) const;

  1013 

  1014 protected:

  1015     virtual void accept0(ASTVisitor *visitor);

  1016     virtual bool match0(AST *, ASTMatcher *);

  1017 };

  1018 

  1019 class CPLUSPLUS_EXPORT NestedDeclaratorAST: public CoreDeclaratorAST

  1020 {

  1021 public:

  1022     unsigned lparen_token;

  1023     DeclaratorAST *declarator;

  1024     unsigned rparen_token;

  1025 

  1026 public:

  1027     virtual NestedDeclaratorAST *asNestedDeclarator() { return this; }

  1028 

  1029     virtual unsigned firstToken() const;

  1030     virtual unsigned lastToken() const;

  1031 

  1032     virtual NestedDeclaratorAST *clone(MemoryPool *pool) const;

  1033 

  1034 protected:

  1035     virtual void accept0(ASTVisitor *visitor);

  1036     virtual bool match0(AST *, ASTMatcher *);

  1037 };

  1038 

  1039 class CPLUSPLUS_EXPORT FunctionDeclaratorAST: public PostfixDeclaratorAST

  1040 {

  1041 public:

  1042     unsigned lparen_token;

  1043     ParameterDeclarationClauseAST *parameters;

  1044     unsigned rparen_token;

  1045     SpecifierListAST *cv_qualifier_list;

  1046     ExceptionSpecificationAST *exception_specification;

  1047     ExpressionAST *as_cpp_initializer;

  1048 

  1049 public: // annotations

  1050     Function *symbol;

  1051 

  1052 public:

  1053     virtual FunctionDeclaratorAST *asFunctionDeclarator() { return this; }

  1054 

  1055     virtual unsigned firstToken() const;

  1056     virtual unsigned lastToken() const;

  1057 

  1058     virtual FunctionDeclaratorAST *clone(MemoryPool *pool) const;

  1059 

  1060 protected:

  1061     virtual void accept0(ASTVisitor *visitor);

  1062     virtual bool match0(AST *, ASTMatcher *);

  1063 };

  1064 

  1065 class CPLUSPLUS_EXPORT ArrayDeclaratorAST: public PostfixDeclaratorAST

  1066 {

  1067 public:

  1068     unsigned lbracket_token;

  1069     ExpressionAST *expression;

  1070     unsigned rbracket_token;

  1071 

  1072 public:

  1073     virtual ArrayDeclaratorAST *asArrayDeclarator() { return this; }

  1074 

  1075     virtual unsigned firstToken() const;

  1076     virtual unsigned lastToken() const;

  1077 

  1078     virtual ArrayDeclaratorAST *clone(MemoryPool *pool) const;

  1079 

  1080 protected:

  1081     virtual void accept0(ASTVisitor *visitor);

  1082     virtual bool match0(AST *, ASTMatcher *);

  1083 };

  1084 

  1085 class CPLUSPLUS_EXPORT DeleteExpressionAST: public ExpressionAST

  1086 {

  1087 public:

  1088     unsigned scope_token;

  1089     unsigned delete_token;

  1090     unsigned lbracket_token;

  1091     unsigned rbracket_token;

  1092     ExpressionAST *expression;

  1093 

  1094 public:

  1095     virtual DeleteExpressionAST *asDeleteExpression() { return this; }

  1096 

  1097     virtual unsigned firstToken() const;

  1098     virtual unsigned lastToken() const;

  1099 

  1100     virtual DeleteExpressionAST *clone(MemoryPool *pool) const;

  1101 

  1102 protected:

  1103     virtual void accept0(ASTVisitor *visitor);

  1104     virtual bool match0(AST *, ASTMatcher *);

  1105 };

  1106 

  1107 class CPLUSPLUS_EXPORT DoStatementAST: public StatementAST

  1108 {

  1109 public:

  1110     unsigned do_token;

  1111     StatementAST *statement;

  1112     unsigned while_token;

  1113     unsigned lparen_token;

  1114     ExpressionAST *expression;

  1115     unsigned rparen_token;

  1116     unsigned semicolon_token;

  1117 

  1118 public:

  1119     virtual DoStatementAST *asDoStatement() { return this; }

  1120 

  1121     virtual unsigned firstToken() const;

  1122     virtual unsigned lastToken() const;

  1123 

  1124     virtual DoStatementAST *clone(MemoryPool *pool) const;

  1125 

  1126 protected:

  1127     virtual void accept0(ASTVisitor *visitor);

  1128     virtual bool match0(AST *, ASTMatcher *);

  1129 };

  1130 

  1131 class CPLUSPLUS_EXPORT NamedTypeSpecifierAST: public SpecifierAST

  1132 {

  1133 public:

  1134     NameAST *name;

  1135