src/shared/cplusplus/ASTVisitor.h

   1 /**************************************************************************
   2 **
   3 ** This file is part of Qt Creator
   4 **
   5 ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
   6 **
   7 ** Contact: Nokia Corporation (qt-info@nokia.com)
   8 **
   9 ** No Commercial Usage
  10 **
  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 **
  18 ** Alternatively, this file may be used under the terms of the GNU Lesser
  19 ** General Public License version 2.1 as published by the Free Software
  20 ** Foundation and appearing in the file LICENSE.LGPL included in the
  21 ** packaging of this file.  Please review the following information to
  22 ** ensure the GNU Lesser General Public License version 2.1 requirements
  23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  24 **
  25 ** In addition, as a special exception, Nokia gives you certain additional
  26 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  28 **
  29 ** If you have questions regarding the use of this file, please contact
  30 ** Nokia at qt-info@nokia.com.
  31 **
  32 **************************************************************************/
  33 // Copyright (c) 2008 Roberto Raggi <roberto.raggi@gmail.com>
  34 //
  35 // Permission is hereby granted, free of charge, to any person obtaining a copy
  36 // of this software and associated documentation files (the "Software"), to deal
  37 // in the Software without restriction, including without limitation the rights
  38 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  39 // copies of the Software, and to permit persons to whom the Software is
  40 // furnished to do so, subject to the following conditions:
  41 //
  42 // The above copyright notice and this permission notice shall be included in
  43 // all copies or substantial portions of the Software.
  44 //
  45 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  46 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  47 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  48 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  49 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  50 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  51 // THE SOFTWARE.
  52
  53 #ifndef CPLUSPLUS_ASTVISITOR_H
  54 #define CPLUSPLUS_ASTVISITOR_H
  55
  56 #include "CPlusPlusForwardDeclarations.h"
  57 #include "ASTfwd.h"
  58
  59
  60 namespace CPlusPlus {
  61
  62 class CPLUSPLUS_EXPORT ASTVisitor
  63 {
  64     ASTVisitor(const ASTVisitor &other);
  65     void operator =(const ASTVisitor &other);
  66
  67 public:
  68     ASTVisitor(TranslationUnit *unit);
  69     virtual ~ASTVisitor();
  70
  71     TranslationUnit *translationUnit() const;
  72     void setTranslationUnit(TranslationUnit *translationUnit);
  73
  74     Control *control() const;
  75     unsigned tokenCount() const;
  76     const Token &tokenAt(unsigned index) const;
  77     int tokenKind(unsigned index) const;
  78     const char *spell(unsigned index) const;
  79     const Identifier *identifier(unsigned index) const;
  80     const Literal *literal(unsigned index) const;
  81     const NumericLiteral *numericLiteral(unsigned index) const;
  82     const StringLiteral *stringLiteral(unsigned index) const;
  83
  84     void getPosition(unsigned offset,
  85                      unsigned *line,
  86                      unsigned *column = 0,
  87                      const StringLiteral **fileName = 0) const;
  88
  89     void getTokenPosition(unsigned index,
  90                           unsigned *line,
  91                           unsigned *column = 0,
  92                           const StringLiteral **fileName = 0) const;
  93
  94     void getTokenStartPosition(unsigned index, unsigned *line, unsigned *column) const;
  95     void getTokenEndPosition(unsigned index, unsigned *line, unsigned *column) const;
  96
  97     void accept(AST *ast);
  98
  99     template <typename _Tp>
 100     void accept(List<_Tp> *it)
 101     {
 102         for (; it; it = it->next)
 103             accept(it->value);
 104     }
 105
 106     virtual bool preVisit(AST *) { return true; }
 107     virtual void postVisit(AST *) {}
 108
 109     virtual bool visit(AccessDeclarationAST *) { return true; }
 110     virtual bool visit(QtObjectTagAST *) { return true; }
 111     virtual bool visit(QtPrivateSlotAST *) { return true; }
 112     virtual bool visit(QtPropertyDeclarationAST *) { return true; }
 113     virtual bool visit(QtEnumDeclarationAST *) { return true; }
 114     virtual bool visit(QtFlagsDeclarationAST *) { return true; }
 115     virtual bool visit(ArrayAccessAST *) { return true; }
 116     virtual bool visit(ArrayDeclaratorAST *) { return true; }
 117     virtual bool visit(ArrayInitializerAST *) { return true; }
 118     virtual bool visit(AsmDefinitionAST *) { return true; }
 119     virtual bool visit(AttributeSpecifierAST *) { return true; }
 120     virtual bool visit(AttributeAST *) { return true; }
 121     virtual bool visit(BaseSpecifierAST *) { return true; }
 122     virtual bool visit(BinaryExpressionAST *) { return true; }
 123     virtual bool visit(BoolLiteralAST *) { return true; }
 124     virtual bool visit(BreakStatementAST *) { return true; }
 125     virtual bool visit(CallAST *) { return true; }
 126     virtual bool visit(CaseStatementAST *) { return true; }
 127     virtual bool visit(CastExpressionAST *) { return true; }
 128     virtual bool visit(CatchClauseAST *) { return true; }
 129     virtual bool visit(ClassSpecifierAST *) { return true; }
 130     virtual bool visit(CompoundExpressionAST *) { return true; }
 131     virtual bool visit(CompoundLiteralAST *) { return true; }
 132     virtual bool visit(CompoundStatementAST *) { return true; }
 133     virtual bool visit(ConditionAST *) { return true; }
 134     virtual bool visit(ConditionalExpressionAST *) { return true; }
 135     virtual bool visit(ContinueStatementAST *) { return true; }
 136     virtual bool visit(ConversionFunctionIdAST *) { return true; }
 137     virtual bool visit(CppCastExpressionAST *) { return true; }
 138     virtual bool visit(CtorInitializerAST *) { return true; }
 139     virtual bool visit(DeclaratorAST *) { return true; }
 140     virtual bool visit(DeclarationStatementAST *) { return true; }
 141     virtual bool visit(DeclaratorIdAST *) { return true; }
 142     virtual bool visit(DeleteExpressionAST *) { return true; }
 143     virtual bool visit(DestructorNameAST *) { return true; }
 144     virtual bool visit(DoStatementAST *) { return true; }
 145     virtual bool visit(ElaboratedTypeSpecifierAST *) { return true; }
 146     virtual bool visit(EmptyDeclarationAST *) { return true; }
 147     virtual bool visit(EnumSpecifierAST *) { return true; }
 148     virtual bool visit(EnumeratorAST *) { return true; }
 149     virtual bool visit(ExceptionDeclarationAST *) { return true; }
 150     virtual bool visit(ExceptionSpecificationAST *) { return true; }
 151     virtual bool visit(ExpressionOrDeclarationStatementAST *) { return true; }
 152     virtual bool visit(ExpressionStatementAST *) { return true; }
 153     virtual bool visit(ForeachStatementAST *) { return true; }
 154     virtual bool visit(ForStatementAST *) { return true; }
 155     virtual bool visit(FunctionDeclaratorAST *) { return true; }
 156     virtual bool visit(FunctionDefinitionAST *) { return true; }
 157     virtual bool visit(GotoStatementAST *) { return true; }
 158     virtual bool visit(IdExpressionAST *) { return true; }
 159     virtual bool visit(IfStatementAST *) { return true; }
 160     virtual bool visit(LabeledStatementAST *) { return true; }
 161     virtual bool visit(LinkageBodyAST *) { return true; }
 162     virtual bool visit(LinkageSpecificationAST *) { return true; }
 163     virtual bool visit(MemInitializerAST *) { return true; }
 164     virtual bool visit(MemberAccessAST *) { return true; }
 165     virtual bool visit(NamedTypeSpecifierAST *) { return true; }
 166     virtual bool visit(NamespaceAST *) { return true; }
 167     virtual bool visit(NamespaceAliasDefinitionAST *) { return true; }
 168     virtual bool visit(NestedDeclaratorAST *) { return true; }
 169     virtual bool visit(NestedExpressionAST *) { return true; }
 170     virtual bool visit(NestedNameSpecifierAST *) { return true; }
 171     virtual bool visit(NewPlacementAST *) { return true; }
 172     virtual bool visit(NewArrayDeclaratorAST *) { return true; }
 173     virtual bool visit(NewExpressionAST *) { return true; }
 174     virtual bool visit(NewInitializerAST *) { return true; }
 175     virtual bool visit(NewTypeIdAST *) { return true; }
 176     virtual bool visit(NumericLiteralAST *) { return true; }
 177     virtual bool visit(OperatorAST *) { return true; }
 178     virtual bool visit(OperatorFunctionIdAST *) { return true; }
 179     virtual bool visit(ParameterDeclarationAST *) { return true; }
 180     virtual bool visit(ParameterDeclarationClauseAST *) { return true; }
 181     virtual bool visit(PointerAST *) { return true; }
 182     virtual bool visit(PointerToMemberAST *) { return true; }
 183     virtual bool visit(PostIncrDecrAST *) { return true; }
 184     virtual bool visit(QualifiedNameAST *) { return true; }
 185     virtual bool visit(ReferenceAST *) { return true; }
 186     virtual bool visit(ReturnStatementAST *) { return true; }
 187     virtual bool visit(SimpleDeclarationAST *) { return true; }
 188     virtual bool visit(SimpleNameAST *) { return true; }
 189     virtual bool visit(SimpleSpecifierAST *) { return true; }
 190     virtual bool visit(SizeofExpressionAST *) { return true; }
 191     virtual bool visit(StringLiteralAST *) { return true; }
 192     virtual bool visit(SwitchStatementAST *) { return true; }
 193     virtual bool visit(TemplateDeclarationAST *) { return true; }
 194     virtual bool visit(TemplateIdAST *) { return true; }
 195     virtual bool visit(TemplateTypeParameterAST *) { return true; }
 196     virtual bool visit(ThisExpressionAST *) { return true; }
 197     virtual bool visit(ThrowExpressionAST *) { return true; }
 198     virtual bool visit(TranslationUnitAST *) { return true; }
 199     virtual bool visit(TryBlockStatementAST *) { return true; }
 200     virtual bool visit(TypeConstructorCallAST *) { return true; }
 201     virtual bool visit(TypeIdAST *) { return true; }
 202     virtual bool visit(TypeidExpressionAST *) { return true; }
 203     virtual bool visit(TypeofSpecifierAST *) { return true; }
 204     virtual bool visit(TypenameCallExpressionAST *) { return true; }
 205     virtual bool visit(TypenameTypeParameterAST *) { return true; }
 206     virtual bool visit(UnaryExpressionAST *) { return true; }
 207     virtual bool visit(UsingAST *) { return true; }
 208     virtual bool visit(UsingDirectiveAST *) { return true; }
 209     virtual bool visit(WhileStatementAST *) { return true; }
 210     virtual bool visit(QtMethodAST *) { return true; }
 211     virtual bool visit(QtMemberDeclarationAST *) { return true; }
 212     virtual bool visit(QtPropertyDeclarationItemAST *) { return true; }
 213     virtual bool visit(QtInterfacesDeclarationAST *) { return true; }
 214     virtual bool visit(QtInterfaceNameAST *) { return true; }
 215
 216     // C++0x
 217     virtual bool visit(LambdaExpressionAST *) { return true; }
 218     virtual bool visit(LambdaIntroducerAST *) { return true; }
 219     virtual bool visit(LambdaCaptureAST *) { return true; }
 220     virtual bool visit(LambdaDeclaratorAST *) { return true; }
 221     virtual bool visit(CaptureAST *) { return true; }
 222     virtual bool visit(TrailingReturnTypeAST *) { return true; }
 223     virtual bool visit(BracedInitializerAST *) { return true; }
 224
 225     // ObjC++
 226     virtual bool visit(ObjCClassDeclarationAST *) { return true; }
 227     virtual bool visit(ObjCClassForwardDeclarationAST *) { return true; }
 228     virtual bool visit(ObjCProtocolDeclarationAST *) { return true; }
 229     virtual bool visit(ObjCProtocolForwardDeclarationAST *) { return true; }
 230     virtual bool visit(ObjCProtocolRefsAST *) { return true; }
 231     virtual bool visit(ObjCSelectorAST *) { return true; }
 232     virtual bool visit(ObjCMessageExpressionAST *) { return true; }
 233     virtual bool visit(ObjCMessageArgumentAST *) { return true; }
 234     virtual bool visit(ObjCProtocolExpressionAST *) { return true; }
 235     virtual bool visit(ObjCTypeNameAST *) { return true; }
 236     virtual bool visit(ObjCEncodeExpressionAST *) { return true; }
 237     virtual bool visit(ObjCSelectorArgumentAST *) { return true; }
 238     virtual bool visit(ObjCSelectorExpressionAST *) { return true; }
 239     virtual bool visit(ObjCInstanceVariablesDeclarationAST *) { return true; }
 240     virtual bool visit(ObjCVisibilityDeclarationAST *) { return true; }
 241     virtual bool visit(ObjCPropertyAttributeAST *) { return true; }
 242     virtual bool visit(ObjCPropertyDeclarationAST *) { return true; }
 243     virtual bool visit(ObjCMethodPrototypeAST *) { return true; }
 244     virtual bool visit(ObjCMethodDeclarationAST *) { return true; }
 245     virtual bool visit(ObjCMessageArgumentDeclarationAST *) { return true; }
 246     virtual bool visit(ObjCSynthesizedPropertyAST *) { return true; }
 247     virtual bool visit(ObjCSynthesizedPropertiesDeclarationAST *) { return true; }
 248     virtual bool visit(ObjCDynamicPropertiesDeclarationAST *) { return true; }
 249     virtual bool visit(ObjCFastEnumerationAST *) { return true; }
 250     virtual bool visit(ObjCSynchronizedStatementAST *) { return true; }
 251
 252     virtual void endVisit(AccessDeclarationAST *) { }
 253     virtual void endVisit(QtObjectTagAST *) {}
 254     virtual void endVisit(QtPrivateSlotAST *) {}
 255     virtual void endVisit(QtPropertyDeclarationAST *) { }
 256     virtual void endVisit(QtEnumDeclarationAST *) { }
 257     virtual void endVisit(QtFlagsDeclarationAST *) { }
 258     virtual void endVisit(ArrayAccessAST *) { }
 259     virtual void endVisit(ArrayDeclaratorAST *) { }
 260     virtual void endVisit(ArrayInitializerAST *) { }
 261     virtual void endVisit(AsmDefinitionAST *) { }
 262     virtual void endVisit(AttributeSpecifierAST *) { }
 263     virtual void endVisit(AttributeAST *) { }
 264     virtual void endVisit(BaseSpecifierAST *) { }
 265     virtual void endVisit(BinaryExpressionAST *) { }
 266     virtual void endVisit(BoolLiteralAST *) { }
 267     virtual void endVisit(BreakStatementAST *) { }
 268     virtual void endVisit(CallAST *) { }
 269     virtual void endVisit(CaseStatementAST *) { }
 270     virtual void endVisit(CastExpressionAST *) { }
 271     virtual void endVisit(CatchClauseAST *) { }
 272     virtual void endVisit(ClassSpecifierAST *) { }
 273     virtual void endVisit(CompoundExpressionAST *) { }
 274     virtual void endVisit(CompoundLiteralAST *) { }
 275     virtual void endVisit(CompoundStatementAST *) { }
 276     virtual void endVisit(ConditionAST *) { }
 277     virtual void endVisit(ConditionalExpressionAST *) { }
 278     virtual void endVisit(ContinueStatementAST *) { }
 279     virtual void endVisit(ConversionFunctionIdAST *) { }
 280     virtual void endVisit(CppCastExpressionAST *) { }
 281     virtual void endVisit(CtorInitializerAST *) { }
 282     virtual void endVisit(DeclaratorAST *) { }
 283     virtual void endVisit(DeclarationStatementAST *) { }
 284     virtual void endVisit(DeclaratorIdAST *) { }
 285     virtual void endVisit(DeleteExpressionAST *) { }
 286     virtual void endVisit(DestructorNameAST *) { }
 287     virtual void endVisit(DoStatementAST *) { }
 288     virtual void endVisit(ElaboratedTypeSpecifierAST *) { }
 289     virtual void endVisit(EmptyDeclarationAST *) { }
 290     virtual void endVisit(EnumSpecifierAST *) { }
 291     virtual void endVisit(EnumeratorAST *) { }
 292     virtual void endVisit(ExceptionDeclarationAST *) { }
 293     virtual void endVisit(ExceptionSpecificationAST *) { }
 294     virtual void endVisit(ExpressionOrDeclarationStatementAST *) { }
 295     virtual void endVisit(ExpressionStatementAST *) { }
 296     virtual void endVisit(ForeachStatementAST *) { }
 297     virtual void endVisit(ForStatementAST *) { }
 298     virtual void endVisit(FunctionDeclaratorAST *) { }
 299     virtual void endVisit(FunctionDefinitionAST *) { }
 300     virtual void endVisit(GotoStatementAST *) { }
 301     virtual void endVisit(IdExpressionAST *) { }
 302     virtual void endVisit(IfStatementAST *) { }
 303     virtual void endVisit(LabeledStatementAST *) { }
 304     virtual void endVisit(LinkageBodyAST *) { }
 305     virtual void endVisit(LinkageSpecificationAST *) { }
 306     virtual void endVisit(MemInitializerAST *) { }
 307     virtual void endVisit(MemberAccessAST *) { }
 308     virtual void endVisit(NamedTypeSpecifierAST *) { }
 309     virtual void endVisit(NamespaceAST *) { }
 310     virtual void endVisit(NamespaceAliasDefinitionAST *) { }
 311     virtual void endVisit(NestedDeclaratorAST *) { }
 312     virtual void endVisit(NestedExpressionAST *) { }
 313     virtual void endVisit(NestedNameSpecifierAST *) { }
 314     virtual void endVisit(NewPlacementAST *) { }
 315     virtual void endVisit(NewArrayDeclaratorAST *) { }
 316     virtual void endVisit(NewExpressionAST *) { }
 317     virtual void endVisit(NewInitializerAST *) { }
 318     virtual void endVisit(NewTypeIdAST *) { }
 319     virtual void endVisit(NumericLiteralAST *) { }
 320     virtual void endVisit(OperatorAST *) { }
 321     virtual void endVisit(OperatorFunctionIdAST *) { }
 322     virtual void endVisit(ParameterDeclarationAST *) { }
 323     virtual void endVisit(ParameterDeclarationClauseAST *) { }
 324     virtual void endVisit(PointerAST *) { }
 325     virtual void endVisit(PointerToMemberAST *) { }
 326     virtual void endVisit(PostIncrDecrAST *) { }
 327     virtual void endVisit(QualifiedNameAST *) { }
 328     virtual void endVisit(ReferenceAST *) { }
 329     virtual void endVisit(ReturnStatementAST *) { }
 330     virtual void endVisit(SimpleDeclarationAST *) { }
 331     virtual void endVisit(SimpleNameAST *) { }
 332     virtual void endVisit(SimpleSpecifierAST *) { }
 333     virtual void endVisit(SizeofExpressionAST *) { }
 334     virtual void endVisit(StringLiteralAST *) { }
 335     virtual void endVisit(SwitchStatementAST *) { }
 336     virtual void endVisit(TemplateDeclarationAST *) { }
 337     virtual void endVisit(TemplateIdAST *) { }
 338     virtual void endVisit(TemplateTypeParameterAST *) { }
 339     virtual void endVisit(ThisExpressionAST *) { }
 340     virtual void endVisit(ThrowExpressionAST *) { }
 341     virtual void endVisit(TranslationUnitAST *) { }
 342     virtual void endVisit(TryBlockStatementAST *) { }
 343     virtual void endVisit(TypeConstructorCallAST *) { }
 344     virtual void endVisit(TypeIdAST *) { }
 345     virtual void endVisit(TypeidExpressionAST *) { }
 346     virtual void endVisit(TypeofSpecifierAST *) { }
 347     virtual void endVisit(TypenameCallExpressionAST *) { }
 348     virtual void endVisit(TypenameTypeParameterAST *) { }
 349     virtual void endVisit(UnaryExpressionAST *) { }
 350     virtual void endVisit(UsingAST *) { }
 351     virtual void endVisit(UsingDirectiveAST *) { }
 352     virtual void endVisit(WhileStatementAST *) { }
 353     virtual void endVisit(QtMethodAST *) { }
 354     virtual void endVisit(QtMemberDeclarationAST *) { }
 355     virtual void endVisit(QtPropertyDeclarationItemAST *) { }
 356     virtual void endVisit(QtInterfacesDeclarationAST *) { }
 357     virtual void endVisit(QtInterfaceNameAST *) { }
 358
 359     // C++0x
 360     virtual void endVisit(LambdaExpressionAST *) { }
 361     virtual void endVisit(LambdaIntroducerAST *) { }
 362     virtual void endVisit(LambdaCaptureAST *) { }
 363     virtual void endVisit(LambdaDeclaratorAST *) { }
 364     virtual void endVisit(CaptureAST *) { }
 365     virtual void endVisit(TrailingReturnTypeAST *) { }
 366     virtual void endVisit(BracedInitializerAST *) { }
 367
 368     // ObjC++
 369     virtual void endVisit(ObjCClassDeclarationAST *) { }
 370     virtual void endVisit(ObjCClassForwardDeclarationAST *) { }
 371     virtual void endVisit(ObjCProtocolDeclarationAST *) { }
 372     virtual void endVisit(ObjCProtocolForwardDeclarationAST *) { }
 373     virtual void endVisit(ObjCProtocolRefsAST *) { }
 374     virtual void endVisit(ObjCSelectorAST *) { }
 375     virtual void endVisit(ObjCMessageExpressionAST *) { }
 376     virtual void endVisit(ObjCMessageArgumentAST *) { }
 377     virtual void endVisit(ObjCProtocolExpressionAST *) { }
 378     virtual void endVisit(ObjCTypeNameAST *) { }
 379     virtual void endVisit(ObjCEncodeExpressionAST *) { }
 380     virtual void endVisit(ObjCSelectorArgumentAST *) { }
 381     virtual void endVisit(ObjCSelectorExpressionAST *) { }
 382     virtual void endVisit(ObjCInstanceVariablesDeclarationAST *) { }
 383     virtual void endVisit(ObjCVisibilityDeclarationAST *) { }
 384     virtual void endVisit(ObjCPropertyAttributeAST *) { }
 385     virtual void endVisit(ObjCPropertyDeclarationAST *) { }
 386     virtual void endVisit(ObjCMethodPrototypeAST *) { }
 387     virtual void endVisit(ObjCMethodDeclarationAST *) { }
 388     virtual void endVisit(ObjCMessageArgumentDeclarationAST *) { }
 389     virtual void endVisit(ObjCSynthesizedPropertyAST *) { }
 390     virtual void endVisit(ObjCSynthesizedPropertiesDeclarationAST *) { }
 391     virtual void endVisit(ObjCDynamicPropertiesDeclarationAST *) { }
 392     virtual void endVisit(ObjCFastEnumerationAST *) { }
 393     virtual void endVisit(ObjCSynchronizedStatementAST *) { }
 394
 395 private:
 396     TranslationUnit *_translationUnit;
 397 };
 398
 399 } // end of namespace CPlusPlus
 400
 401
 402 #endif // CPLUSPLUS_ASTVISITOR_H