/****************************************************************************
|
**
|
** Copyright (C) 2018 The Qt Company Ltd.
|
** Contact: https://www.qt.io/licensing/
|
**
|
** This file is part of the Qt VS Tools.
|
**
|
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
|
** Commercial License Usage
|
** Licensees holding valid commercial Qt licenses may use this file in
|
** accordance with the commercial license agreement provided with the
|
** Software or, alternatively, in accordance with the terms contained in
|
** a written agreement between you and The Qt Company. For licensing terms
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
** information use the contact form at https://www.qt.io/contact-us.
|
**
|
** GNU General Public License Usage
|
** Alternatively, this file may be used under the terms of the GNU
|
** General Public License version 3 as published by the Free Software
|
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
|
** included in the packaging of this file. Please review the following
|
** information to ensure the GNU General Public License requirements will
|
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
|
**
|
** $QT_END_LICENSE$
|
**
|
****************************************************************************/
|
#include "astvisitor.h"
|
|
using namespace QQmlJS::AST;
|
|
class AstVisitorPrivate : public QQmlJS::AST::Visitor
|
{
|
private:
|
Callback callbackUnfiltered;
|
QMap<int, Callback> callbackFiltered;
|
|
Callback getCallback(Node *node) {
|
auto callback = callbackUnfiltered;
|
auto itFilter = callbackFiltered.find(node->kind);
|
if (itFilter != callbackFiltered.end())
|
callback = itFilter.value();
|
return callback;
|
}
|
|
bool invokeCallback(Callback callback, QVector<int> &nodeData, Node *node, bool beginVisit)
|
{
|
if (!callback)
|
return true;
|
bool result = callback(this, node->kind, node,
|
beginVisit, nodeData.data(), nodeData.count() * sizeof(int));
|
|
nodeData.clear();
|
return result;
|
}
|
|
void marshalInt(QVector<int> &nodeData, int n)
|
{
|
nodeData.append(n);
|
}
|
|
void marshalLocation(QVector<int> &nodeData, SourceLocation &location)
|
{
|
nodeData.append(location.offset);
|
nodeData.append(location.length);
|
}
|
|
void marshalPointer(QVector<int> &nodeData, void *ptr)
|
{
|
auto ptrRef = reinterpret_cast<long long>(ptr);
|
auto ptrHi = ptrRef >> 32;
|
auto ptrLo = ptrRef & 0xFFFFFFFFLL;
|
nodeData.append(int(ptrHi));
|
nodeData.append(int(ptrLo));
|
}
|
|
void marshalNode(QVector<int> &nodeData, Node *node)
|
{
|
auto firstLocation = node->firstSourceLocation();
|
auto lastLocation = node->lastSourceLocation();
|
marshalLocation(nodeData, firstLocation);
|
marshalLocation(nodeData, lastLocation);
|
}
|
|
bool visitCallback(UiImport *node, bool beginVisit)
|
{
|
auto callback = getCallback(node);
|
if (!callback)
|
return true;
|
QVector<int> nodeData;
|
marshalNode(nodeData, node);
|
marshalLocation(nodeData, node->importToken);
|
marshalLocation(nodeData, node->fileNameToken);
|
marshalLocation(nodeData, node->versionToken);
|
marshalLocation(nodeData, node->asToken);
|
marshalLocation(nodeData, node->importIdToken);
|
marshalLocation(nodeData, node->semicolonToken);
|
return invokeCallback(callback, nodeData, node, beginVisit);
|
}
|
|
bool visitCallback(UiQualifiedId *node, bool beginVisit)
|
{
|
auto callback = getCallback(node);
|
if (!callback)
|
return true;
|
QVector<int> nodeData;
|
marshalNode(nodeData, node);
|
marshalPointer(nodeData, node->next);
|
marshalLocation(nodeData, node->identifierToken);
|
return invokeCallback(callback, nodeData, node, beginVisit);
|
}
|
|
bool visitCallback(UiObjectDefinition *node, bool beginVisit)
|
{
|
auto callback = getCallback(node);
|
if (!callback)
|
return true;
|
QVector<int> nodeData;
|
marshalNode(nodeData, node);
|
marshalPointer(nodeData, node->qualifiedTypeNameId);
|
marshalPointer(nodeData, node->initializer);
|
return invokeCallback(callback, nodeData, node, beginVisit);
|
}
|
|
bool visitCallback(UiObjectBinding *node, bool beginVisit)
|
{
|
auto callback = getCallback(node);
|
if (!callback)
|
return true;
|
QVector<int> nodeData;
|
marshalNode(nodeData, node);
|
marshalPointer(nodeData, node->qualifiedId);
|
marshalPointer(nodeData, node->qualifiedTypeNameId);
|
marshalPointer(nodeData, node->initializer);
|
marshalLocation(nodeData, node->colonToken);
|
return invokeCallback(callback, nodeData, node, beginVisit);
|
}
|
|
bool visitCallback(UiObjectInitializer *node, bool beginVisit)
|
{
|
auto callback = getCallback(node);
|
if (!callback)
|
return true;
|
QVector<int> nodeData;
|
marshalNode(nodeData, node);
|
return invokeCallback(callback, nodeData, node, beginVisit);
|
}
|
|
bool visitCallback(UiScriptBinding *node, bool beginVisit)
|
{
|
auto callback = getCallback(node);
|
if (!callback)
|
return true;
|
QVector<int> nodeData;
|
marshalNode(nodeData, node);
|
marshalPointer(nodeData, node->qualifiedId);
|
marshalPointer(nodeData, node->statement);
|
marshalLocation(nodeData, node->colonToken);
|
return invokeCallback(callback, nodeData, node, beginVisit);
|
}
|
|
bool visitCallback(UiArrayBinding *node, bool beginVisit)
|
{
|
auto callback = getCallback(node);
|
if (!callback)
|
return true;
|
QVector<int> nodeData;
|
marshalNode(nodeData, node);
|
marshalPointer(nodeData, node->qualifiedId);
|
marshalPointer(nodeData, node->members);
|
marshalLocation(nodeData, node->colonToken);
|
marshalLocation(nodeData, node->lbracketToken);
|
marshalLocation(nodeData, node->rbracketToken);
|
return invokeCallback(callback, nodeData, node, beginVisit);
|
}
|
|
bool visitCallback(UiPublicMember *node, bool beginVisit)
|
{
|
auto callback = getCallback(node);
|
if (!callback)
|
return true;
|
QVector<int> nodeData;
|
marshalNode(nodeData, node);
|
marshalInt(nodeData, node->type);
|
marshalPointer(nodeData, node->memberType);
|
marshalPointer(nodeData, node->statement);
|
marshalPointer(nodeData, node->binding);
|
marshalInt(nodeData, node->isDefaultMember);
|
marshalInt(nodeData, node->isReadonlyMember);
|
marshalPointer(nodeData, node->parameters);
|
marshalLocation(nodeData, node->defaultToken);
|
marshalLocation(nodeData, node->readonlyToken);
|
marshalLocation(nodeData, node->propertyToken);
|
marshalLocation(nodeData, node->typeModifierToken);
|
marshalLocation(nodeData, node->typeToken);
|
marshalLocation(nodeData, node->identifierToken);
|
marshalLocation(nodeData, node->colonToken);
|
marshalLocation(nodeData, node->semicolonToken);
|
return invokeCallback(callback, nodeData, node, beginVisit);
|
}
|
|
bool visitCallback(Node *node, bool beginVisit)
|
{
|
auto callback = getCallback(node);
|
if (!callback)
|
return true;
|
QVector<int> nodeData;
|
marshalNode(nodeData, node);
|
return invokeCallback(callback, nodeData, node, beginVisit);
|
}
|
|
public:
|
AstVisitorPrivate()
|
{
|
callbackUnfiltered = 0;
|
}
|
|
~AstVisitorPrivate()
|
{
|
}
|
|
void setCallback(Callback visitCallback)
|
{
|
callbackUnfiltered = visitCallback;
|
}
|
|
void setCallback(int nodeKindFilter, Callback visitCallback)
|
{
|
callbackFiltered[nodeKindFilter] = visitCallback;
|
}
|
|
// Copied from qqmljsastvisitor_p.h
|
|
virtual bool visit(UiProgram *node) { return visitCallback(node, true); }
|
virtual bool visit(UiHeaderItemList *node) { return visitCallback(node, true); }
|
virtual bool visit(UiPragma *node) { return visitCallback(node, true); }
|
virtual bool visit(UiImport *node) { return visitCallback(node, true); }
|
virtual bool visit(UiPublicMember *node) { return visitCallback(node, true); }
|
virtual bool visit(UiSourceElement *node) { return visitCallback(node, true); }
|
virtual bool visit(UiObjectDefinition *node) { return visitCallback(node, true); }
|
virtual bool visit(UiObjectInitializer *node) { return visitCallback(node, true); }
|
virtual bool visit(UiObjectBinding *node) { return visitCallback(node, true); }
|
virtual bool visit(UiScriptBinding *node) { return visitCallback(node, true); }
|
virtual bool visit(UiArrayBinding *node) { return visitCallback(node, true); }
|
virtual bool visit(UiParameterList *node) { return visitCallback(node, true); }
|
virtual bool visit(UiObjectMemberList *node) { return visitCallback(node, true); }
|
virtual bool visit(UiArrayMemberList *node) { return visitCallback(node, true); }
|
virtual bool visit(UiQualifiedId *node) { return visitCallback(node, true); }
|
virtual bool visit(UiEnumDeclaration *node) { return visitCallback(node, true); }
|
virtual bool visit(UiEnumMemberList *node) { return visitCallback(node, true); }
|
|
virtual void endVisit(UiProgram *node) { visitCallback(node, false); }
|
virtual void endVisit(UiImport *node) { visitCallback(node, false); }
|
virtual void endVisit(UiHeaderItemList *node) { visitCallback(node, false); }
|
virtual void endVisit(UiPragma *node) { visitCallback(node, false); }
|
virtual void endVisit(UiPublicMember *node) { visitCallback(node, false); }
|
virtual void endVisit(UiSourceElement *node) { visitCallback(node, false); }
|
virtual void endVisit(UiObjectDefinition *node) { visitCallback(node, false); }
|
virtual void endVisit(UiObjectInitializer *node) { visitCallback(node, false); }
|
virtual void endVisit(UiObjectBinding *node) { visitCallback(node, false); }
|
virtual void endVisit(UiScriptBinding *node) { visitCallback(node, false); }
|
virtual void endVisit(UiArrayBinding *node) { visitCallback(node, false); }
|
virtual void endVisit(UiParameterList *node) { visitCallback(node, false); }
|
virtual void endVisit(UiObjectMemberList *node) { visitCallback(node, false); }
|
virtual void endVisit(UiArrayMemberList *node) { visitCallback(node, false); }
|
virtual void endVisit(UiQualifiedId *node) { visitCallback(node, false); }
|
virtual void endVisit(UiEnumDeclaration *node) { visitCallback(node, false); }
|
virtual void endVisit(UiEnumMemberList *node) { visitCallback(node, false); }
|
|
// QQmlJS
|
virtual bool visit(ThisExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(ThisExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(IdentifierExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(IdentifierExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(NullExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(NullExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(TrueLiteral *node) { return visitCallback(node, true); }
|
virtual void endVisit(TrueLiteral *node) { visitCallback(node, false); }
|
|
virtual bool visit(FalseLiteral *node) { return visitCallback(node, true); }
|
virtual void endVisit(FalseLiteral *node) { visitCallback(node, false); }
|
|
virtual bool visit(SuperLiteral *node) { return visitCallback(node, true); }
|
virtual void endVisit(SuperLiteral *node) { visitCallback(node, false); }
|
|
virtual bool visit(StringLiteral *node) { return visitCallback(node, true); }
|
virtual void endVisit(StringLiteral *node) { visitCallback(node, false); }
|
|
virtual bool visit(TemplateLiteral *node) { return visitCallback(node, true); }
|
virtual void endVisit(TemplateLiteral *node) { visitCallback(node, false); }
|
|
virtual bool visit(NumericLiteral *node) { return visitCallback(node, true); }
|
virtual void endVisit(NumericLiteral *node) { visitCallback(node, false); }
|
|
virtual bool visit(RegExpLiteral *node) { return visitCallback(node, true); }
|
virtual void endVisit(RegExpLiteral *node) { visitCallback(node, false); }
|
|
virtual bool visit(ArrayPattern *node) { return visitCallback(node, true); }
|
virtual void endVisit(ArrayPattern *node) { visitCallback(node, false); }
|
|
virtual bool visit(ObjectPattern *node) { return visitCallback(node, true); }
|
virtual void endVisit(ObjectPattern *node) { visitCallback(node, false); }
|
|
virtual bool visit(PatternElementList *node) { return visitCallback(node, true); }
|
virtual void endVisit(PatternElementList *node) { visitCallback(node, false); }
|
|
virtual bool visit(PatternPropertyList *node) { return visitCallback(node, true); }
|
virtual void endVisit(PatternPropertyList *node) { visitCallback(node, false); }
|
|
virtual bool visit(PatternElement *node) { return visitCallback(node, true); }
|
virtual void endVisit(PatternElement *node) { visitCallback(node, false); }
|
|
virtual bool visit(PatternProperty *node) { return visitCallback(node, true); }
|
virtual void endVisit(PatternProperty *node) { visitCallback(node, false); }
|
|
virtual bool visit(Elision *node) { return visitCallback(node, true); }
|
virtual void endVisit(Elision *node) { visitCallback(node, false); }
|
|
virtual bool visit(NestedExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(NestedExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(IdentifierPropertyName *node) { return visitCallback(node, true); }
|
virtual void endVisit(IdentifierPropertyName *node) { visitCallback(node, false); }
|
|
virtual bool visit(StringLiteralPropertyName *node) { return visitCallback(node, true); }
|
virtual void endVisit(StringLiteralPropertyName *node) { visitCallback(node, false); }
|
|
virtual bool visit(NumericLiteralPropertyName *node) { return visitCallback(node, true); }
|
virtual void endVisit(NumericLiteralPropertyName *node) { visitCallback(node, false); }
|
|
virtual bool visit(ComputedPropertyName *node) { return visitCallback(node, true); }
|
virtual void endVisit(ComputedPropertyName *node) { visitCallback(node, false); }
|
|
virtual bool visit(ArrayMemberExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(ArrayMemberExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(FieldMemberExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(FieldMemberExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(TaggedTemplate *node) { return visitCallback(node, true); }
|
virtual void endVisit(TaggedTemplate *node) { visitCallback(node, false); }
|
|
virtual bool visit(NewMemberExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(NewMemberExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(NewExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(NewExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(CallExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(CallExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(ArgumentList *node) { return visitCallback(node, true); }
|
virtual void endVisit(ArgumentList *node) { visitCallback(node, false); }
|
|
virtual bool visit(PostIncrementExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(PostIncrementExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(PostDecrementExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(PostDecrementExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(DeleteExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(DeleteExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(VoidExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(VoidExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(TypeOfExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(TypeOfExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(PreIncrementExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(PreIncrementExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(PreDecrementExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(PreDecrementExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(UnaryPlusExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(UnaryPlusExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(UnaryMinusExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(UnaryMinusExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(TildeExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(TildeExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(NotExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(NotExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(BinaryExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(BinaryExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(ConditionalExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(ConditionalExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(Expression *node) { return visitCallback(node, true); }
|
virtual void endVisit(Expression *node) { visitCallback(node, false); }
|
|
virtual bool visit(Block *node) { return visitCallback(node, true); }
|
virtual void endVisit(Block *node) { visitCallback(node, false); }
|
|
virtual bool visit(StatementList *node) { return visitCallback(node, true); }
|
virtual void endVisit(StatementList *node) { visitCallback(node, false); }
|
|
virtual bool visit(VariableStatement *node) { return visitCallback(node, true); }
|
virtual void endVisit(VariableStatement *node) { visitCallback(node, false); }
|
|
virtual bool visit(VariableDeclarationList *node) { return visitCallback(node, true); }
|
virtual void endVisit(VariableDeclarationList *node) { visitCallback(node, false); }
|
|
virtual bool visit(EmptyStatement *node) { return visitCallback(node, true); }
|
virtual void endVisit(EmptyStatement *node) { visitCallback(node, false); }
|
|
virtual bool visit(ExpressionStatement *node) { return visitCallback(node, true); }
|
virtual void endVisit(ExpressionStatement *node) { visitCallback(node, false); }
|
|
virtual bool visit(IfStatement *node) { return visitCallback(node, true); }
|
virtual void endVisit(IfStatement *node) { visitCallback(node, false); }
|
|
virtual bool visit(DoWhileStatement *node) { return visitCallback(node, true); }
|
virtual void endVisit(DoWhileStatement *node) { visitCallback(node, false); }
|
|
virtual bool visit(WhileStatement *node) { return visitCallback(node, true); }
|
virtual void endVisit(WhileStatement *node) { visitCallback(node, false); }
|
|
virtual bool visit(ForStatement *node) { return visitCallback(node, true); }
|
virtual void endVisit(ForStatement *node) { visitCallback(node, false); }
|
|
virtual bool visit(ForEachStatement *node) { return visitCallback(node, true); }
|
virtual void endVisit(ForEachStatement *node) { visitCallback(node, false); }
|
|
virtual bool visit(ContinueStatement *node) { return visitCallback(node, true); }
|
virtual void endVisit(ContinueStatement *node) { visitCallback(node, false); }
|
|
virtual bool visit(BreakStatement *node) { return visitCallback(node, true); }
|
virtual void endVisit(BreakStatement *node) { visitCallback(node, false); }
|
|
virtual bool visit(ReturnStatement *node) { return visitCallback(node, true); }
|
virtual void endVisit(ReturnStatement *node) { visitCallback(node, false); }
|
|
virtual bool visit(YieldExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(YieldExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(WithStatement *node) { return visitCallback(node, true); }
|
virtual void endVisit(WithStatement *node) { visitCallback(node, false); }
|
|
virtual bool visit(SwitchStatement *node) { return visitCallback(node, true); }
|
virtual void endVisit(SwitchStatement *node) { visitCallback(node, false); }
|
|
virtual bool visit(CaseBlock *node) { return visitCallback(node, true); }
|
virtual void endVisit(CaseBlock *node) { visitCallback(node, false); }
|
|
virtual bool visit(CaseClauses *node) { return visitCallback(node, true); }
|
virtual void endVisit(CaseClauses *node) { visitCallback(node, false); }
|
|
virtual bool visit(CaseClause *node) { return visitCallback(node, true); }
|
virtual void endVisit(CaseClause *node) { visitCallback(node, false); }
|
|
virtual bool visit(DefaultClause *node) { return visitCallback(node, true); }
|
virtual void endVisit(DefaultClause *node) { visitCallback(node, false); }
|
|
virtual bool visit(LabelledStatement *node) { return visitCallback(node, true); }
|
virtual void endVisit(LabelledStatement *node) { visitCallback(node, false); }
|
|
virtual bool visit(ThrowStatement *node) { return visitCallback(node, true); }
|
virtual void endVisit(ThrowStatement *node) { visitCallback(node, false); }
|
|
virtual bool visit(TryStatement *node) { return visitCallback(node, true); }
|
virtual void endVisit(TryStatement *node) { visitCallback(node, false); }
|
|
virtual bool visit(Catch *node) { return visitCallback(node, true); }
|
virtual void endVisit(Catch *node) { visitCallback(node, false); }
|
|
virtual bool visit(Finally *node) { return visitCallback(node, true); }
|
virtual void endVisit(Finally *node) { visitCallback(node, false); }
|
|
virtual bool visit(FunctionDeclaration *node) { return visitCallback(node, true); }
|
virtual void endVisit(FunctionDeclaration *node) { visitCallback(node, false); }
|
|
virtual bool visit(FunctionExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(FunctionExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(FormalParameterList *node) { return visitCallback(node, true); }
|
virtual void endVisit(FormalParameterList *node) { visitCallback(node, false); }
|
|
virtual bool visit(ClassExpression *node) { return visitCallback(node, true); }
|
virtual void endVisit(ClassExpression *node) { visitCallback(node, false); }
|
|
virtual bool visit(ClassDeclaration *node) { return visitCallback(node, true); }
|
virtual void endVisit(ClassDeclaration *node) { visitCallback(node, false); }
|
|
virtual bool visit(ClassElementList *node) { return visitCallback(node, true); }
|
virtual void endVisit(ClassElementList *node) { visitCallback(node, false); }
|
|
virtual bool visit(Program *node) { return visitCallback(node, true); }
|
virtual void endVisit(Program *node) { visitCallback(node, false); }
|
|
virtual bool visit(NameSpaceImport *node) { return visitCallback(node, true); }
|
virtual void endVisit(NameSpaceImport *node) { visitCallback(node, false); }
|
|
virtual bool visit(ImportSpecifier *node) { return visitCallback(node, true); }
|
virtual void endVisit(ImportSpecifier *node) { visitCallback(node, false); }
|
|
virtual bool visit(ImportsList *node) { return visitCallback(node, true); }
|
virtual void endVisit(ImportsList *node) { visitCallback(node, false); }
|
|
virtual bool visit(NamedImports *node) { return visitCallback(node, true); }
|
virtual void endVisit(NamedImports *node) { visitCallback(node, false); }
|
|
virtual bool visit(FromClause *node) { return visitCallback(node, true); }
|
virtual void endVisit(FromClause *node) { visitCallback(node, false); }
|
|
virtual bool visit(ImportClause *node) { return visitCallback(node, true); }
|
virtual void endVisit(ImportClause *node) { visitCallback(node, false); }
|
|
virtual bool visit(ImportDeclaration *node) { return visitCallback(node, true); }
|
virtual void endVisit(ImportDeclaration *node) { visitCallback(node, false); }
|
|
virtual bool visit(ExportSpecifier *node) { return visitCallback(node, true); }
|
virtual void endVisit(ExportSpecifier *node) { visitCallback(node, false); }
|
|
virtual bool visit(ExportsList *node) { return visitCallback(node, true); }
|
virtual void endVisit(ExportsList *node) { visitCallback(node, false); }
|
|
virtual bool visit(ExportClause *node) { return visitCallback(node, true); }
|
virtual void endVisit(ExportClause *node) { visitCallback(node, false); }
|
|
virtual bool visit(ExportDeclaration *node) { return visitCallback(node, true); }
|
virtual void endVisit(ExportDeclaration *node) { visitCallback(node, false); }
|
|
virtual bool visit(ESModule *node) { return visitCallback(node, true); }
|
virtual void endVisit(ESModule *node) { visitCallback(node, false); }
|
|
virtual bool visit(DebuggerStatement *node) { return visitCallback(node, true); }
|
virtual void endVisit(DebuggerStatement *node) { visitCallback(node, false); }
|
|
virtual void throwRecursionDepthError() { /* TODO: Anything we should do here? */ }
|
};
|
|
AstVisitor::AstVisitor() : d_ptr(new AstVisitorPrivate)
|
{
|
}
|
|
AstVisitor::~AstVisitor()
|
{
|
delete d_ptr;
|
}
|
|
void AstVisitor::setCallback(Callback visitCallback)
|
{
|
d_ptr->setCallback(visitCallback);
|
}
|
|
void AstVisitor::setCallback(int nodeKindFilter, Callback visitCallback)
|
{
|
d_ptr->setCallback(nodeKindFilter, visitCallback);
|
}
|
|
Visitor *AstVisitor::GetVisitor()
|
{
|
return d_ptr;
|
}
|
