1 /**************************************************************************** 2 ** 3 ** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). 4 ** Contact: http://www.qt-project.org/legal 5 ** 6 ** This file is part of the Qt Solutions component. 7 ** 8 ** $QT_BEGIN_LICENSE:BSD$ 9 ** You may use this file under the terms of the BSD license as follows: 10 ** 11 ** "Redistribution and use in source and binary forms, with or without 12 ** modification, are permitted provided that the following conditions are 13 ** met: 14 ** * Redistributions of source code must retain the above copyright 15 ** notice, this list of conditions and the following disclaimer. 16 ** * Redistributions in binary form must reproduce the above copyright 17 ** notice, this list of conditions and the following disclaimer in 18 ** the documentation and/or other materials provided with the 19 ** distribution. 20 ** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names 21 ** of its contributors may be used to endorse or promote products derived 22 ** from this software without specific prior written permission. 23 ** 24 ** 25 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 26 ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 27 ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 28 ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 29 ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 30 ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 31 ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 32 ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 33 ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 34 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 35 ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." 36 ** 37 ** $QT_END_LICENSE$ 38 ** 39 ****************************************************************************/ 40 41 42 #ifndef QSCRIPTASTVISITOR_P_H 43 #define QSCRIPTASTVISITOR_P_H 44 45 // 46 // W A R N I N G 47 // ------------- 48 // 49 // This file is not part of the Qt API. It exists purely as an 50 // implementation detail. This header file may change from version to 51 // version without notice, or even be removed. 52 // 53 // We mean it. 54 // 55 56 #include "qscriptastfwd_p.h" 57 58 QT_BEGIN_NAMESPACE 59 60 namespace QScript { namespace AST { 61 62 class Visitor 63 { 64 public: 65 Visitor(); 66 virtual ~Visitor(); 67 preVisit(Node *)68 virtual bool preVisit(Node *) { return true; } postVisit(Node *)69 virtual void postVisit(Node *) {} 70 visit(ThisExpression *)71 virtual bool visit(ThisExpression *) { return true; } endVisit(ThisExpression *)72 virtual void endVisit(ThisExpression *) {} 73 visit(IdentifierExpression *)74 virtual bool visit(IdentifierExpression *) { return true; } endVisit(IdentifierExpression *)75 virtual void endVisit(IdentifierExpression *) {} 76 visit(NullExpression *)77 virtual bool visit(NullExpression *) { return true; } endVisit(NullExpression *)78 virtual void endVisit(NullExpression *) {} 79 visit(TrueLiteral *)80 virtual bool visit(TrueLiteral *) { return true; } endVisit(TrueLiteral *)81 virtual void endVisit(TrueLiteral *) {} 82 visit(FalseLiteral *)83 virtual bool visit(FalseLiteral *) { return true; } endVisit(FalseLiteral *)84 virtual void endVisit(FalseLiteral *) {} 85 visit(StringLiteral *)86 virtual bool visit(StringLiteral *) { return true; } endVisit(StringLiteral *)87 virtual void endVisit(StringLiteral *) {} 88 visit(NumericLiteral *)89 virtual bool visit(NumericLiteral *) { return true; } endVisit(NumericLiteral *)90 virtual void endVisit(NumericLiteral *) {} 91 visit(RegExpLiteral *)92 virtual bool visit(RegExpLiteral *) { return true; } endVisit(RegExpLiteral *)93 virtual void endVisit(RegExpLiteral *) {} 94 visit(ArrayLiteral *)95 virtual bool visit(ArrayLiteral *) { return true; } endVisit(ArrayLiteral *)96 virtual void endVisit(ArrayLiteral *) {} 97 visit(ObjectLiteral *)98 virtual bool visit(ObjectLiteral *) { return true; } endVisit(ObjectLiteral *)99 virtual void endVisit(ObjectLiteral *) {} 100 visit(ElementList *)101 virtual bool visit(ElementList *) { return true; } endVisit(ElementList *)102 virtual void endVisit(ElementList *) {} 103 visit(Elision *)104 virtual bool visit(Elision *) { return true; } endVisit(Elision *)105 virtual void endVisit(Elision *) {} 106 visit(PropertyNameAndValueList *)107 virtual bool visit(PropertyNameAndValueList *) { return true; } endVisit(PropertyNameAndValueList *)108 virtual void endVisit(PropertyNameAndValueList *) {} 109 visit(IdentifierPropertyName *)110 virtual bool visit(IdentifierPropertyName *) { return true; } endVisit(IdentifierPropertyName *)111 virtual void endVisit(IdentifierPropertyName *) {} 112 visit(StringLiteralPropertyName *)113 virtual bool visit(StringLiteralPropertyName *) { return true; } endVisit(StringLiteralPropertyName *)114 virtual void endVisit(StringLiteralPropertyName *) {} 115 visit(NumericLiteralPropertyName *)116 virtual bool visit(NumericLiteralPropertyName *) { return true; } endVisit(NumericLiteralPropertyName *)117 virtual void endVisit(NumericLiteralPropertyName *) {} 118 visit(ArrayMemberExpression *)119 virtual bool visit(ArrayMemberExpression *) { return true; } endVisit(ArrayMemberExpression *)120 virtual void endVisit(ArrayMemberExpression *) {} 121 visit(FieldMemberExpression *)122 virtual bool visit(FieldMemberExpression *) { return true; } endVisit(FieldMemberExpression *)123 virtual void endVisit(FieldMemberExpression *) {} 124 visit(NewMemberExpression *)125 virtual bool visit(NewMemberExpression *) { return true; } endVisit(NewMemberExpression *)126 virtual void endVisit(NewMemberExpression *) {} 127 visit(NewExpression *)128 virtual bool visit(NewExpression *) { return true; } endVisit(NewExpression *)129 virtual void endVisit(NewExpression *) {} 130 visit(CallExpression *)131 virtual bool visit(CallExpression *) { return true; } endVisit(CallExpression *)132 virtual void endVisit(CallExpression *) {} 133 visit(ArgumentList *)134 virtual bool visit(ArgumentList *) { return true; } endVisit(ArgumentList *)135 virtual void endVisit(ArgumentList *) {} 136 visit(PostIncrementExpression *)137 virtual bool visit(PostIncrementExpression *) { return true; } endVisit(PostIncrementExpression *)138 virtual void endVisit(PostIncrementExpression *) {} 139 visit(PostDecrementExpression *)140 virtual bool visit(PostDecrementExpression *) { return true; } endVisit(PostDecrementExpression *)141 virtual void endVisit(PostDecrementExpression *) {} 142 visit(DeleteExpression *)143 virtual bool visit(DeleteExpression *) { return true; } endVisit(DeleteExpression *)144 virtual void endVisit(DeleteExpression *) {} 145 visit(VoidExpression *)146 virtual bool visit(VoidExpression *) { return true; } endVisit(VoidExpression *)147 virtual void endVisit(VoidExpression *) {} 148 visit(TypeOfExpression *)149 virtual bool visit(TypeOfExpression *) { return true; } endVisit(TypeOfExpression *)150 virtual void endVisit(TypeOfExpression *) {} 151 visit(PreIncrementExpression *)152 virtual bool visit(PreIncrementExpression *) { return true; } endVisit(PreIncrementExpression *)153 virtual void endVisit(PreIncrementExpression *) {} 154 visit(PreDecrementExpression *)155 virtual bool visit(PreDecrementExpression *) { return true; } endVisit(PreDecrementExpression *)156 virtual void endVisit(PreDecrementExpression *) {} 157 visit(UnaryPlusExpression *)158 virtual bool visit(UnaryPlusExpression *) { return true; } endVisit(UnaryPlusExpression *)159 virtual void endVisit(UnaryPlusExpression *) {} 160 visit(UnaryMinusExpression *)161 virtual bool visit(UnaryMinusExpression *) { return true; } endVisit(UnaryMinusExpression *)162 virtual void endVisit(UnaryMinusExpression *) {} 163 visit(TildeExpression *)164 virtual bool visit(TildeExpression *) { return true; } endVisit(TildeExpression *)165 virtual void endVisit(TildeExpression *) {} 166 visit(NotExpression *)167 virtual bool visit(NotExpression *) { return true; } endVisit(NotExpression *)168 virtual void endVisit(NotExpression *) {} 169 visit(BinaryExpression *)170 virtual bool visit(BinaryExpression *) { return true; } endVisit(BinaryExpression *)171 virtual void endVisit(BinaryExpression *) {} 172 visit(ConditionalExpression *)173 virtual bool visit(ConditionalExpression *) { return true; } endVisit(ConditionalExpression *)174 virtual void endVisit(ConditionalExpression *) {} 175 visit(Expression *)176 virtual bool visit(Expression *) { return true; } endVisit(Expression *)177 virtual void endVisit(Expression *) {} 178 visit(Block *)179 virtual bool visit(Block *) { return true; } endVisit(Block *)180 virtual void endVisit(Block *) {} 181 visit(StatementList *)182 virtual bool visit(StatementList *) { return true; } endVisit(StatementList *)183 virtual void endVisit(StatementList *) {} 184 visit(VariableStatement *)185 virtual bool visit(VariableStatement *) { return true; } endVisit(VariableStatement *)186 virtual void endVisit(VariableStatement *) {} 187 visit(VariableDeclarationList *)188 virtual bool visit(VariableDeclarationList *) { return true; } endVisit(VariableDeclarationList *)189 virtual void endVisit(VariableDeclarationList *) {} 190 visit(VariableDeclaration *)191 virtual bool visit(VariableDeclaration *) { return true; } endVisit(VariableDeclaration *)192 virtual void endVisit(VariableDeclaration *) {} 193 visit(EmptyStatement *)194 virtual bool visit(EmptyStatement *) { return true; } endVisit(EmptyStatement *)195 virtual void endVisit(EmptyStatement *) {} 196 visit(ExpressionStatement *)197 virtual bool visit(ExpressionStatement *) { return true; } endVisit(ExpressionStatement *)198 virtual void endVisit(ExpressionStatement *) {} 199 visit(IfStatement *)200 virtual bool visit(IfStatement *) { return true; } endVisit(IfStatement *)201 virtual void endVisit(IfStatement *) {} 202 visit(DoWhileStatement *)203 virtual bool visit(DoWhileStatement *) { return true; } endVisit(DoWhileStatement *)204 virtual void endVisit(DoWhileStatement *) {} 205 visit(WhileStatement *)206 virtual bool visit(WhileStatement *) { return true; } endVisit(WhileStatement *)207 virtual void endVisit(WhileStatement *) {} 208 visit(ForStatement *)209 virtual bool visit(ForStatement *) { return true; } endVisit(ForStatement *)210 virtual void endVisit(ForStatement *) {} 211 visit(LocalForStatement *)212 virtual bool visit(LocalForStatement *) { return true; } endVisit(LocalForStatement *)213 virtual void endVisit(LocalForStatement *) {} 214 visit(ForEachStatement *)215 virtual bool visit(ForEachStatement *) { return true; } endVisit(ForEachStatement *)216 virtual void endVisit(ForEachStatement *) {} 217 visit(LocalForEachStatement *)218 virtual bool visit(LocalForEachStatement *) { return true; } endVisit(LocalForEachStatement *)219 virtual void endVisit(LocalForEachStatement *) {} 220 visit(ContinueStatement *)221 virtual bool visit(ContinueStatement *) { return true; } endVisit(ContinueStatement *)222 virtual void endVisit(ContinueStatement *) {} 223 visit(BreakStatement *)224 virtual bool visit(BreakStatement *) { return true; } endVisit(BreakStatement *)225 virtual void endVisit(BreakStatement *) {} 226 visit(ReturnStatement *)227 virtual bool visit(ReturnStatement *) { return true; } endVisit(ReturnStatement *)228 virtual void endVisit(ReturnStatement *) {} 229 visit(WithStatement *)230 virtual bool visit(WithStatement *) { return true; } endVisit(WithStatement *)231 virtual void endVisit(WithStatement *) {} 232 visit(SwitchStatement *)233 virtual bool visit(SwitchStatement *) { return true; } endVisit(SwitchStatement *)234 virtual void endVisit(SwitchStatement *) {} 235 visit(CaseBlock *)236 virtual bool visit(CaseBlock *) { return true; } endVisit(CaseBlock *)237 virtual void endVisit(CaseBlock *) {} 238 visit(CaseClauses *)239 virtual bool visit(CaseClauses *) { return true; } endVisit(CaseClauses *)240 virtual void endVisit(CaseClauses *) {} 241 visit(CaseClause *)242 virtual bool visit(CaseClause *) { return true; } endVisit(CaseClause *)243 virtual void endVisit(CaseClause *) {} 244 visit(DefaultClause *)245 virtual bool visit(DefaultClause *) { return true; } endVisit(DefaultClause *)246 virtual void endVisit(DefaultClause *) {} 247 visit(LabelledStatement *)248 virtual bool visit(LabelledStatement *) { return true; } endVisit(LabelledStatement *)249 virtual void endVisit(LabelledStatement *) {} 250 visit(ThrowStatement *)251 virtual bool visit(ThrowStatement *) { return true; } endVisit(ThrowStatement *)252 virtual void endVisit(ThrowStatement *) {} 253 visit(TryStatement *)254 virtual bool visit(TryStatement *) { return true; } endVisit(TryStatement *)255 virtual void endVisit(TryStatement *) {} 256 visit(Catch *)257 virtual bool visit(Catch *) { return true; } endVisit(Catch *)258 virtual void endVisit(Catch *) {} 259 visit(Finally *)260 virtual bool visit(Finally *) { return true; } endVisit(Finally *)261 virtual void endVisit(Finally *) {} 262 visit(FunctionDeclaration *)263 virtual bool visit(FunctionDeclaration *) { return true; } endVisit(FunctionDeclaration *)264 virtual void endVisit(FunctionDeclaration *) {} 265 visit(FunctionExpression *)266 virtual bool visit(FunctionExpression *) { return true; } endVisit(FunctionExpression *)267 virtual void endVisit(FunctionExpression *) {} 268 visit(FormalParameterList *)269 virtual bool visit(FormalParameterList *) { return true; } endVisit(FormalParameterList *)270 virtual void endVisit(FormalParameterList *) {} 271 visit(FunctionBody *)272 virtual bool visit(FunctionBody *) { return true; } endVisit(FunctionBody *)273 virtual void endVisit(FunctionBody *) {} 274 visit(Program *)275 virtual bool visit(Program *) { return true; } endVisit(Program *)276 virtual void endVisit(Program *) {} 277 visit(SourceElements *)278 virtual bool visit(SourceElements *) { return true; } endVisit(SourceElements *)279 virtual void endVisit(SourceElements *) {} 280 visit(FunctionSourceElement *)281 virtual bool visit(FunctionSourceElement *) { return true; } endVisit(FunctionSourceElement *)282 virtual void endVisit(FunctionSourceElement *) {} 283 visit(StatementSourceElement *)284 virtual bool visit(StatementSourceElement *) { return true; } endVisit(StatementSourceElement *)285 virtual void endVisit(StatementSourceElement *) {} 286 visit(DebuggerStatement *)287 virtual bool visit(DebuggerStatement *) { return true; } endVisit(DebuggerStatement *)288 virtual void endVisit(DebuggerStatement *) {} 289 }; 290 291 } } // namespace AST 292 293 QT_END_NAMESPACE 294 295 #endif // QSCRIPTASTVISITOR_P_H 296