/**************************************************************************** | |
** | |
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). | |
** All rights reserved. | |
** Contact: Nokia Corporation (qt-info@nokia.com) | |
** | |
** This file is part of the QtDeclarative module of the Qt Toolkit. | |
** | |
** $QT_BEGIN_LICENSE:LGPL$ | |
** GNU Lesser General Public License Usage | |
** This file may be used under the terms of the GNU Lesser General Public | |
** License version 2.1 as published by the Free Software Foundation and | |
** appearing in the file LICENSE.LGPL included in the packaging of this | |
** file. Please review the following information to ensure the GNU Lesser | |
** General Public License version 2.1 requirements will be met: | |
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. | |
** | |
** In addition, as a special exception, Nokia gives you certain additional | |
** rights. These rights are described in the Nokia Qt LGPL Exception | |
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. | |
** | |
** GNU General Public License Usage | |
** Alternatively, this file may be used under the terms of the GNU General | |
** Public License version 3.0 as published by the Free Software Foundation | |
** and appearing in the file LICENSE.GPL included in the packaging of this | |
** file. Please review the following information to ensure the GNU General | |
** Public License version 3.0 requirements will be met: | |
** http://www.gnu.org/copyleft/gpl.html. | |
** | |
** Other Usage | |
** Alternatively, this file may be used in accordance with the terms and | |
** conditions contained in a signed written agreement between you and Nokia. | |
** | |
** | |
** | |
** | |
** | |
** $QT_END_LICENSE$ | |
** | |
****************************************************************************/ | |
#ifndef QDECLARATIVEJSAST_P_H | |
#define QDECLARATIVEJSAST_P_H | |
// | |
// W A R N I N G | |
// ------------- | |
// | |
// This file is not part of the Qt API. It exists purely as an | |
// implementation detail. This header file may change from version to | |
// version without notice, or even be removed. | |
// | |
// We mean it. | |
// | |
#include "private/qdeclarativejsastvisitor_p.h" | |
#include "private/qdeclarativejsglobal_p.h" | |
#include <QtCore/QString> | |
QT_QML_BEGIN_NAMESPACE | |
#define QDECLARATIVEJS_DECLARE_AST_NODE(name) \ | |
enum { K = Kind_##name }; | |
namespace QSOperator // ### rename | |
{ | |
enum Op { | |
Add, | |
And, | |
InplaceAnd, | |
Assign, | |
BitAnd, | |
BitOr, | |
BitXor, | |
InplaceSub, | |
Div, | |
InplaceDiv, | |
Equal, | |
Ge, | |
Gt, | |
In, | |
InplaceAdd, | |
InstanceOf, | |
Le, | |
LShift, | |
InplaceLeftShift, | |
Lt, | |
Mod, | |
InplaceMod, | |
Mul, | |
InplaceMul, | |
NotEqual, | |
Or, | |
InplaceOr, | |
RShift, | |
InplaceRightShift, | |
StrictEqual, | |
StrictNotEqual, | |
Sub, | |
URShift, | |
InplaceURightShift, | |
InplaceXor | |
}; | |
} // namespace QSOperator | |
namespace QDeclarativeJS { | |
class NameId; | |
namespace AST { | |
template <typename _T1, typename _T2> | |
_T1 cast(_T2 *ast) | |
{ | |
if (ast && ast->kind == static_cast<_T1>(0)->K) | |
return static_cast<_T1>(ast); | |
return 0; | |
} | |
class QML_PARSER_EXPORT Node | |
{ | |
public: | |
enum Kind { | |
Kind_Undefined, | |
Kind_ArgumentList, | |
Kind_ArrayLiteral, | |
Kind_ArrayMemberExpression, | |
Kind_BinaryExpression, | |
Kind_Block, | |
Kind_BreakStatement, | |
Kind_CallExpression, | |
Kind_CaseBlock, | |
Kind_CaseClause, | |
Kind_CaseClauses, | |
Kind_Catch, | |
Kind_ConditionalExpression, | |
Kind_ContinueStatement, | |
Kind_DebuggerStatement, | |
Kind_DefaultClause, | |
Kind_DeleteExpression, | |
Kind_DoWhileStatement, | |
Kind_ElementList, | |
Kind_Elision, | |
Kind_EmptyStatement, | |
Kind_Expression, | |
Kind_ExpressionStatement, | |
Kind_FalseLiteral, | |
Kind_FieldMemberExpression, | |
Kind_Finally, | |
Kind_ForEachStatement, | |
Kind_ForStatement, | |
Kind_FormalParameterList, | |
Kind_FunctionBody, | |
Kind_FunctionDeclaration, | |
Kind_FunctionExpression, | |
Kind_FunctionSourceElement, | |
Kind_IdentifierExpression, | |
Kind_IdentifierPropertyName, | |
Kind_IfStatement, | |
Kind_LabelledStatement, | |
Kind_LocalForEachStatement, | |
Kind_LocalForStatement, | |
Kind_NewExpression, | |
Kind_NewMemberExpression, | |
Kind_NotExpression, | |
Kind_NullExpression, | |
Kind_NumericLiteral, | |
Kind_NumericLiteralPropertyName, | |
Kind_ObjectLiteral, | |
Kind_PostDecrementExpression, | |
Kind_PostIncrementExpression, | |
Kind_PreDecrementExpression, | |
Kind_PreIncrementExpression, | |
Kind_Program, | |
Kind_PropertyName, | |
Kind_PropertyNameAndValueList, | |
Kind_RegExpLiteral, | |
Kind_ReturnStatement, | |
Kind_SourceElement, | |
Kind_SourceElements, | |
Kind_StatementList, | |
Kind_StatementSourceElement, | |
Kind_StringLiteral, | |
Kind_StringLiteralPropertyName, | |
Kind_SwitchStatement, | |
Kind_ThisExpression, | |
Kind_ThrowStatement, | |
Kind_TildeExpression, | |
Kind_TrueLiteral, | |
Kind_TryStatement, | |
Kind_TypeOfExpression, | |
Kind_UnaryMinusExpression, | |
Kind_UnaryPlusExpression, | |
Kind_VariableDeclaration, | |
Kind_VariableDeclarationList, | |
Kind_VariableStatement, | |
Kind_VoidExpression, | |
Kind_WhileStatement, | |
Kind_WithStatement, | |
Kind_NestedExpression, | |
Kind_UiArrayBinding, | |
Kind_UiImport, | |
Kind_UiImportList, | |
Kind_UiObjectBinding, | |
Kind_UiObjectDefinition, | |
Kind_UiObjectInitializer, | |
Kind_UiObjectMemberList, | |
Kind_UiArrayMemberList, | |
Kind_UiProgram, | |
Kind_UiParameterList, | |
Kind_UiPublicMember, | |
Kind_UiQualifiedId, | |
Kind_UiScriptBinding, | |
Kind_UiSourceElement, | |
Kind_UiFormal, | |
Kind_UiFormalList, | |
Kind_UiSignature | |
}; | |
inline Node() | |
: kind(Kind_Undefined) {} | |
// NOTE: node destructors are never called, | |
// instead we block free the memory | |
// (see the NodePool class) | |
virtual ~Node() {} | |
virtual ExpressionNode *expressionCast(); | |
virtual BinaryExpression *binaryExpressionCast(); | |
virtual Statement *statementCast(); | |
virtual UiObjectMember *uiObjectMemberCast(); | |
void accept(Visitor *visitor); | |
static void accept(Node *node, Visitor *visitor); | |
inline static void acceptChild(Node *node, Visitor *visitor) | |
{ return accept(node, visitor); } // ### remove | |
virtual void accept0(Visitor *visitor) = 0; | |
// attributes | |
int kind; | |
}; | |
class QML_PARSER_EXPORT ExpressionNode: public Node | |
{ | |
public: | |
ExpressionNode() {} | |
virtual ExpressionNode *expressionCast(); | |
virtual SourceLocation firstSourceLocation() const = 0; | |
virtual SourceLocation lastSourceLocation() const = 0; | |
}; | |
class QML_PARSER_EXPORT Statement: public Node | |
{ | |
public: | |
Statement() {} | |
virtual Statement *statementCast(); | |
virtual SourceLocation firstSourceLocation() const = 0; | |
virtual SourceLocation lastSourceLocation() const = 0; | |
}; | |
class QML_PARSER_EXPORT UiFormal: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(UiFormal) | |
UiFormal(NameId *name, NameId *alias = 0) | |
: name(name), alias(alias) | |
{ } | |
virtual SourceLocation firstSourceLocation() const | |
{ return SourceLocation(); } | |
virtual SourceLocation lastSourceLocation() const | |
{ return SourceLocation(); } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
NameId *name; | |
NameId *alias; | |
SourceLocation identifierToken; | |
SourceLocation asToken; | |
SourceLocation aliasToken; | |
}; | |
class QML_PARSER_EXPORT UiFormalList: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(UiFormalList) | |
UiFormalList(UiFormal *formal) | |
: formal(formal), next(this) {} | |
UiFormalList(UiFormalList *previous, UiFormal *formal) | |
: formal(formal) | |
{ | |
next = previous->next; | |
previous->next = this; | |
} | |
UiFormalList *finish() | |
{ | |
UiFormalList *head = next; | |
next = 0; | |
return head; | |
} | |
virtual SourceLocation firstSourceLocation() const | |
{ return SourceLocation(); } | |
virtual SourceLocation lastSourceLocation() const | |
{ return SourceLocation(); } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
UiFormal *formal; | |
UiFormalList *next; | |
}; | |
class QML_PARSER_EXPORT UiSignature: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(UiSignature) | |
UiSignature(UiFormalList *formals = 0) | |
: formals(formals) | |
{ } | |
virtual SourceLocation firstSourceLocation() const | |
{ return SourceLocation(); } | |
virtual SourceLocation lastSourceLocation() const | |
{ return SourceLocation(); } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
SourceLocation lparenToken; | |
UiFormalList *formals; | |
SourceLocation rparenToken; | |
}; | |
class QML_PARSER_EXPORT NestedExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(NestedExpression) | |
NestedExpression(ExpressionNode *expression) | |
: expression(expression) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return lparenToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return rparenToken; } | |
// attributes | |
ExpressionNode *expression; | |
SourceLocation lparenToken; | |
SourceLocation rparenToken; | |
}; | |
class QML_PARSER_EXPORT ThisExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(ThisExpression) | |
ThisExpression() { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return thisToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return thisToken; } | |
// attributes | |
SourceLocation thisToken; | |
}; | |
class QML_PARSER_EXPORT IdentifierExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(IdentifierExpression) | |
IdentifierExpression(NameId *n): | |
name (n) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return identifierToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return identifierToken; } | |
// attributes | |
NameId *name; | |
SourceLocation identifierToken; | |
}; | |
class QML_PARSER_EXPORT NullExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(NullExpression) | |
NullExpression() { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return nullToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return nullToken; } | |
// attributes | |
SourceLocation nullToken; | |
}; | |
class QML_PARSER_EXPORT TrueLiteral: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(TrueLiteral) | |
TrueLiteral() { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return trueToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return trueToken; } | |
// attributes | |
SourceLocation trueToken; | |
}; | |
class QML_PARSER_EXPORT FalseLiteral: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(FalseLiteral) | |
FalseLiteral() { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return falseToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return falseToken; } | |
// attributes | |
SourceLocation falseToken; | |
}; | |
class QML_PARSER_EXPORT NumericLiteral: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(NumericLiteral) | |
NumericLiteral(double v): | |
value(v) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return literalToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return literalToken; } | |
// attributes: | |
double value; | |
SourceLocation literalToken; | |
}; | |
class QML_PARSER_EXPORT StringLiteral: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(StringLiteral) | |
StringLiteral(NameId *v): | |
value (v) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return literalToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return literalToken; } | |
// attributes: | |
NameId *value; | |
SourceLocation literalToken; | |
}; | |
class QML_PARSER_EXPORT RegExpLiteral: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(RegExpLiteral) | |
RegExpLiteral(NameId *p, int f): | |
pattern (p), flags (f) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return literalToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return literalToken; } | |
// attributes: | |
NameId *pattern; | |
int flags; | |
SourceLocation literalToken; | |
}; | |
class QML_PARSER_EXPORT ArrayLiteral: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(ArrayLiteral) | |
ArrayLiteral(Elision *e): | |
elements (0), elision (e) | |
{ kind = K; } | |
ArrayLiteral(ElementList *elts): | |
elements (elts), elision (0) | |
{ kind = K; } | |
ArrayLiteral(ElementList *elts, Elision *e): | |
elements (elts), elision (e) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return lbracketToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return rbracketToken; } | |
// attributes | |
ElementList *elements; | |
Elision *elision; | |
SourceLocation lbracketToken; | |
SourceLocation commaToken; | |
SourceLocation rbracketToken; | |
}; | |
class QML_PARSER_EXPORT ObjectLiteral: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(ObjectLiteral) | |
ObjectLiteral(): | |
properties (0) { kind = K; } | |
ObjectLiteral(PropertyNameAndValueList *plist): | |
properties (plist) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return lbraceToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return rbraceToken; } | |
// attributes | |
PropertyNameAndValueList *properties; | |
SourceLocation lbraceToken; | |
SourceLocation rbraceToken; | |
}; | |
class QML_PARSER_EXPORT ElementList: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(ElementList) | |
ElementList(Elision *e, ExpressionNode *expr): | |
elision (e), expression (expr), next (this) | |
{ kind = K; } | |
ElementList(ElementList *previous, Elision *e, ExpressionNode *expr): | |
elision (e), expression (expr) | |
{ | |
kind = K; | |
next = previous->next; | |
previous->next = this; | |
} | |
inline ElementList *finish () | |
{ | |
ElementList *front = next; | |
next = 0; | |
return front; | |
} | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
Elision *elision; | |
ExpressionNode *expression; | |
ElementList *next; | |
SourceLocation commaToken; | |
}; | |
class QML_PARSER_EXPORT Elision: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(Elision) | |
Elision(): | |
next (this) { kind = K; } | |
Elision(Elision *previous) | |
{ | |
kind = K; | |
next = previous->next; | |
previous->next = this; | |
} | |
virtual void accept0(Visitor *visitor); | |
inline Elision *finish () | |
{ | |
Elision *front = next; | |
next = 0; | |
return front; | |
} | |
// attributes | |
Elision *next; | |
SourceLocation commaToken; | |
}; | |
class QML_PARSER_EXPORT PropertyNameAndValueList: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(PropertyNameAndValueList) | |
PropertyNameAndValueList(PropertyName *n, ExpressionNode *v): | |
name (n), value (v), next (this) | |
{ kind = K; } | |
PropertyNameAndValueList(PropertyNameAndValueList *previous, PropertyName *n, ExpressionNode *v): | |
name (n), value (v) | |
{ | |
kind = K; | |
next = previous->next; | |
previous->next = this; | |
} | |
virtual void accept0(Visitor *visitor); | |
inline PropertyNameAndValueList *finish () | |
{ | |
PropertyNameAndValueList *front = next; | |
next = 0; | |
return front; | |
} | |
// attributes | |
PropertyName *name; | |
ExpressionNode *value; | |
PropertyNameAndValueList *next; | |
SourceLocation colonToken; | |
SourceLocation commaToken; | |
}; | |
class QML_PARSER_EXPORT PropertyName: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(PropertyName) | |
PropertyName() { kind = K; } | |
// attributes | |
SourceLocation propertyNameToken; | |
}; | |
class QML_PARSER_EXPORT IdentifierPropertyName: public PropertyName | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(IdentifierPropertyName) | |
IdentifierPropertyName(NameId *n): | |
id (n) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
NameId *id; | |
}; | |
class QML_PARSER_EXPORT StringLiteralPropertyName: public PropertyName | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(StringLiteralPropertyName) | |
StringLiteralPropertyName(NameId *n): | |
id (n) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
NameId *id; | |
}; | |
class QML_PARSER_EXPORT NumericLiteralPropertyName: public PropertyName | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(NumericLiteralPropertyName) | |
NumericLiteralPropertyName(double n): | |
id (n) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
double id; | |
}; | |
class QML_PARSER_EXPORT ArrayMemberExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(ArrayMemberExpression) | |
ArrayMemberExpression(ExpressionNode *b, ExpressionNode *e): | |
base (b), expression (e) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return base->firstSourceLocation(); } | |
virtual SourceLocation lastSourceLocation() const | |
{ return rbracketToken; } | |
// attributes | |
ExpressionNode *base; | |
ExpressionNode *expression; | |
SourceLocation lbracketToken; | |
SourceLocation rbracketToken; | |
}; | |
class QML_PARSER_EXPORT FieldMemberExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(FieldMemberExpression) | |
FieldMemberExpression(ExpressionNode *b, NameId *n): | |
base (b), name (n) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return base->firstSourceLocation(); } | |
virtual SourceLocation lastSourceLocation() const | |
{ return identifierToken; } | |
// attributes | |
ExpressionNode *base; | |
NameId *name; | |
SourceLocation dotToken; | |
SourceLocation identifierToken; | |
}; | |
class QML_PARSER_EXPORT NewMemberExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(NewMemberExpression) | |
NewMemberExpression(ExpressionNode *b, ArgumentList *a): | |
base (b), arguments (a) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return newToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return rparenToken; } | |
// attributes | |
ExpressionNode *base; | |
ArgumentList *arguments; | |
SourceLocation newToken; | |
SourceLocation lparenToken; | |
SourceLocation rparenToken; | |
}; | |
class QML_PARSER_EXPORT NewExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(NewExpression) | |
NewExpression(ExpressionNode *e): | |
expression (e) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return newToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return expression->lastSourceLocation(); } | |
// attributes | |
ExpressionNode *expression; | |
SourceLocation newToken; | |
}; | |
class QML_PARSER_EXPORT CallExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(CallExpression) | |
CallExpression(ExpressionNode *b, ArgumentList *a): | |
base (b), arguments (a) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return base->firstSourceLocation(); } | |
virtual SourceLocation lastSourceLocation() const | |
{ return rparenToken; } | |
// attributes | |
ExpressionNode *base; | |
ArgumentList *arguments; | |
SourceLocation lparenToken; | |
SourceLocation rparenToken; | |
}; | |
class QML_PARSER_EXPORT ArgumentList: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(ArgumentList) | |
ArgumentList(ExpressionNode *e): | |
expression (e), next (this) | |
{ kind = K; } | |
ArgumentList(ArgumentList *previous, ExpressionNode *e): | |
expression (e) | |
{ | |
kind = K; | |
next = previous->next; | |
previous->next = this; | |
} | |
virtual void accept0(Visitor *visitor); | |
inline ArgumentList *finish () | |
{ | |
ArgumentList *front = next; | |
next = 0; | |
return front; | |
} | |
// attributes | |
ExpressionNode *expression; | |
ArgumentList *next; | |
SourceLocation commaToken; | |
}; | |
class QML_PARSER_EXPORT PostIncrementExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(PostIncrementExpression) | |
PostIncrementExpression(ExpressionNode *b): | |
base (b) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return base->firstSourceLocation(); } | |
virtual SourceLocation lastSourceLocation() const | |
{ return incrementToken; } | |
// attributes | |
ExpressionNode *base; | |
SourceLocation incrementToken; | |
}; | |
class QML_PARSER_EXPORT PostDecrementExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(PostDecrementExpression) | |
PostDecrementExpression(ExpressionNode *b): | |
base (b) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return base->firstSourceLocation(); } | |
virtual SourceLocation lastSourceLocation() const | |
{ return decrementToken; } | |
// attributes | |
ExpressionNode *base; | |
SourceLocation decrementToken; | |
}; | |
class QML_PARSER_EXPORT DeleteExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(DeleteExpression) | |
DeleteExpression(ExpressionNode *e): | |
expression (e) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return deleteToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return expression->lastSourceLocation(); } | |
// attributes | |
ExpressionNode *expression; | |
SourceLocation deleteToken; | |
}; | |
class QML_PARSER_EXPORT VoidExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(VoidExpression) | |
VoidExpression(ExpressionNode *e): | |
expression (e) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return voidToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return expression->lastSourceLocation(); } | |
// attributes | |
ExpressionNode *expression; | |
SourceLocation voidToken; | |
}; | |
class QML_PARSER_EXPORT TypeOfExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(TypeOfExpression) | |
TypeOfExpression(ExpressionNode *e): | |
expression (e) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return typeofToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return expression->lastSourceLocation(); } | |
// attributes | |
ExpressionNode *expression; | |
SourceLocation typeofToken; | |
}; | |
class QML_PARSER_EXPORT PreIncrementExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(PreIncrementExpression) | |
PreIncrementExpression(ExpressionNode *e): | |
expression (e) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return incrementToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return expression->lastSourceLocation(); } | |
// attributes | |
ExpressionNode *expression; | |
SourceLocation incrementToken; | |
}; | |
class QML_PARSER_EXPORT PreDecrementExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(PreDecrementExpression) | |
PreDecrementExpression(ExpressionNode *e): | |
expression (e) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return decrementToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return expression->lastSourceLocation(); } | |
// attributes | |
ExpressionNode *expression; | |
SourceLocation decrementToken; | |
}; | |
class QML_PARSER_EXPORT UnaryPlusExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(UnaryPlusExpression) | |
UnaryPlusExpression(ExpressionNode *e): | |
expression (e) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return plusToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return expression->lastSourceLocation(); } | |
// attributes | |
ExpressionNode *expression; | |
SourceLocation plusToken; | |
}; | |
class QML_PARSER_EXPORT UnaryMinusExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(UnaryMinusExpression) | |
UnaryMinusExpression(ExpressionNode *e): | |
expression (e) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return minusToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return expression->lastSourceLocation(); } | |
// attributes | |
ExpressionNode *expression; | |
SourceLocation minusToken; | |
}; | |
class QML_PARSER_EXPORT TildeExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(TildeExpression) | |
TildeExpression(ExpressionNode *e): | |
expression (e) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return tildeToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return expression->lastSourceLocation(); } | |
// attributes | |
ExpressionNode *expression; | |
SourceLocation tildeToken; | |
}; | |
class QML_PARSER_EXPORT NotExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(NotExpression) | |
NotExpression(ExpressionNode *e): | |
expression (e) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return notToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return expression->lastSourceLocation(); } | |
// attributes | |
ExpressionNode *expression; | |
SourceLocation notToken; | |
}; | |
class QML_PARSER_EXPORT BinaryExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(BinaryExpression) | |
BinaryExpression(ExpressionNode *l, int o, ExpressionNode *r): | |
left (l), op (o), right (r) | |
{ kind = K; } | |
virtual BinaryExpression *binaryExpressionCast(); | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return left->firstSourceLocation(); } | |
virtual SourceLocation lastSourceLocation() const | |
{ return right->lastSourceLocation(); } | |
// attributes | |
ExpressionNode *left; | |
int op; | |
ExpressionNode *right; | |
SourceLocation operatorToken; | |
}; | |
class QML_PARSER_EXPORT ConditionalExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(ConditionalExpression) | |
ConditionalExpression(ExpressionNode *e, ExpressionNode *t, ExpressionNode *f): | |
expression (e), ok (t), ko (f) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return expression->firstSourceLocation(); } | |
virtual SourceLocation lastSourceLocation() const | |
{ return ko->lastSourceLocation(); } | |
// attributes | |
ExpressionNode *expression; | |
ExpressionNode *ok; | |
ExpressionNode *ko; | |
SourceLocation questionToken; | |
SourceLocation colonToken; | |
}; | |
class QML_PARSER_EXPORT Expression: public ExpressionNode // ### rename | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(Expression) | |
Expression(ExpressionNode *l, ExpressionNode *r): | |
left (l), right (r) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return left->firstSourceLocation(); } | |
virtual SourceLocation lastSourceLocation() const | |
{ return right->lastSourceLocation(); } | |
// attributes | |
ExpressionNode *left; | |
ExpressionNode *right; | |
SourceLocation commaToken; | |
}; | |
class QML_PARSER_EXPORT Block: public Statement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(Block) | |
Block(StatementList *slist): | |
statements (slist) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return lbraceToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return rbraceToken; } | |
// attributes | |
StatementList *statements; | |
SourceLocation lbraceToken; | |
SourceLocation rbraceToken; | |
}; | |
class QML_PARSER_EXPORT StatementList: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(StatementList) | |
StatementList(Statement *stmt): | |
statement (stmt), next (this) | |
{ kind = K; } | |
StatementList(StatementList *previous, Statement *stmt): | |
statement (stmt) | |
{ | |
kind = K; | |
next = previous->next; | |
previous->next = this; | |
} | |
virtual void accept0(Visitor *visitor); | |
inline StatementList *finish () | |
{ | |
StatementList *front = next; | |
next = 0; | |
return front; | |
} | |
// attributes | |
Statement *statement; | |
StatementList *next; | |
}; | |
class QML_PARSER_EXPORT VariableStatement: public Statement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(VariableStatement) | |
VariableStatement(VariableDeclarationList *vlist): | |
declarations (vlist) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return declarationKindToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return semicolonToken; } | |
// attributes | |
VariableDeclarationList *declarations; | |
SourceLocation declarationKindToken; | |
SourceLocation semicolonToken; | |
}; | |
class QML_PARSER_EXPORT VariableDeclaration: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(VariableDeclaration) | |
VariableDeclaration(NameId *n, ExpressionNode *e): | |
name (n), expression (e), readOnly(false) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
NameId *name; | |
ExpressionNode *expression; | |
bool readOnly; | |
SourceLocation identifierToken; | |
}; | |
class QML_PARSER_EXPORT VariableDeclarationList: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(VariableDeclarationList) | |
VariableDeclarationList(VariableDeclaration *decl): | |
declaration (decl), next (this) | |
{ kind = K; } | |
VariableDeclarationList(VariableDeclarationList *previous, VariableDeclaration *decl): | |
declaration (decl) | |
{ | |
kind = K; | |
next = previous->next; | |
previous->next = this; | |
} | |
virtual void accept0(Visitor *visitor); | |
inline VariableDeclarationList *finish (bool readOnly) | |
{ | |
VariableDeclarationList *front = next; | |
next = 0; | |
if (readOnly) { | |
VariableDeclarationList *vdl; | |
for (vdl = front; vdl != 0; vdl = vdl->next) | |
vdl->declaration->readOnly = true; | |
} | |
return front; | |
} | |
// attributes | |
VariableDeclaration *declaration; | |
VariableDeclarationList *next; | |
SourceLocation commaToken; | |
}; | |
class QML_PARSER_EXPORT EmptyStatement: public Statement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(EmptyStatement) | |
EmptyStatement() { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return semicolonToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return semicolonToken; } | |
// attributes | |
SourceLocation semicolonToken; | |
}; | |
class QML_PARSER_EXPORT ExpressionStatement: public Statement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(ExpressionStatement) | |
ExpressionStatement(ExpressionNode *e): | |
expression (e) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return expression->firstSourceLocation(); } | |
virtual SourceLocation lastSourceLocation() const | |
{ return semicolonToken; } | |
// attributes | |
ExpressionNode *expression; | |
SourceLocation semicolonToken; | |
}; | |
class QML_PARSER_EXPORT IfStatement: public Statement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(IfStatement) | |
IfStatement(ExpressionNode *e, Statement *t, Statement *f = 0): | |
expression (e), ok (t), ko (f) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return ifToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ | |
if (ko) | |
return ko->lastSourceLocation(); | |
return ok->lastSourceLocation(); | |
} | |
// attributes | |
ExpressionNode *expression; | |
Statement *ok; | |
Statement *ko; | |
SourceLocation ifToken; | |
SourceLocation lparenToken; | |
SourceLocation rparenToken; | |
SourceLocation elseToken; | |
}; | |
class QML_PARSER_EXPORT DoWhileStatement: public Statement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(DoWhileStatement) | |
DoWhileStatement(Statement *stmt, ExpressionNode *e): | |
statement (stmt), expression (e) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return doToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return semicolonToken; } | |
// attributes | |
Statement *statement; | |
ExpressionNode *expression; | |
SourceLocation doToken; | |
SourceLocation whileToken; | |
SourceLocation lparenToken; | |
SourceLocation rparenToken; | |
SourceLocation semicolonToken; | |
}; | |
class QML_PARSER_EXPORT WhileStatement: public Statement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(WhileStatement) | |
WhileStatement(ExpressionNode *e, Statement *stmt): | |
expression (e), statement (stmt) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return whileToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return statement->lastSourceLocation(); } | |
// attributes | |
ExpressionNode *expression; | |
Statement *statement; | |
SourceLocation whileToken; | |
SourceLocation lparenToken; | |
SourceLocation rparenToken; | |
}; | |
class QML_PARSER_EXPORT ForStatement: public Statement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(ForStatement) | |
ForStatement(ExpressionNode *i, ExpressionNode *c, ExpressionNode *e, Statement *stmt): | |
initialiser (i), condition (c), expression (e), statement (stmt) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return forToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return statement->lastSourceLocation(); } | |
// attributes | |
ExpressionNode *initialiser; | |
ExpressionNode *condition; | |
ExpressionNode *expression; | |
Statement *statement; | |
SourceLocation forToken; | |
SourceLocation lparenToken; | |
SourceLocation firstSemicolonToken; | |
SourceLocation secondSemicolonToken; | |
SourceLocation rparenToken; | |
}; | |
class QML_PARSER_EXPORT LocalForStatement: public Statement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(LocalForStatement) | |
LocalForStatement(VariableDeclarationList *vlist, ExpressionNode *c, ExpressionNode *e, Statement *stmt): | |
declarations (vlist), condition (c), expression (e), statement (stmt) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return forToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return statement->lastSourceLocation(); } | |
// attributes | |
VariableDeclarationList *declarations; | |
ExpressionNode *condition; | |
ExpressionNode *expression; | |
Statement *statement; | |
SourceLocation forToken; | |
SourceLocation lparenToken; | |
SourceLocation varToken; | |
SourceLocation firstSemicolonToken; | |
SourceLocation secondSemicolonToken; | |
SourceLocation rparenToken; | |
}; | |
class QML_PARSER_EXPORT ForEachStatement: public Statement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(ForEachStatement) | |
ForEachStatement(ExpressionNode *i, ExpressionNode *e, Statement *stmt): | |
initialiser (i), expression (e), statement (stmt) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return forToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return statement->lastSourceLocation(); } | |
// attributes | |
ExpressionNode *initialiser; | |
ExpressionNode *expression; | |
Statement *statement; | |
SourceLocation forToken; | |
SourceLocation lparenToken; | |
SourceLocation inToken; | |
SourceLocation rparenToken; | |
}; | |
class QML_PARSER_EXPORT LocalForEachStatement: public Statement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(LocalForEachStatement) | |
LocalForEachStatement(VariableDeclaration *v, ExpressionNode *e, Statement *stmt): | |
declaration (v), expression (e), statement (stmt) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return forToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return statement->lastSourceLocation(); } | |
// attributes | |
VariableDeclaration *declaration; | |
ExpressionNode *expression; | |
Statement *statement; | |
SourceLocation forToken; | |
SourceLocation lparenToken; | |
SourceLocation varToken; | |
SourceLocation inToken; | |
SourceLocation rparenToken; | |
}; | |
class QML_PARSER_EXPORT ContinueStatement: public Statement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(ContinueStatement) | |
ContinueStatement(NameId *l = 0): | |
label (l) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return continueToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return semicolonToken; } | |
// attributes | |
NameId *label; | |
SourceLocation continueToken; | |
SourceLocation identifierToken; | |
SourceLocation semicolonToken; | |
}; | |
class QML_PARSER_EXPORT BreakStatement: public Statement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(BreakStatement) | |
BreakStatement(NameId *l = 0): | |
label (l) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return breakToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return semicolonToken; } | |
// attributes | |
NameId *label; | |
SourceLocation breakToken; | |
SourceLocation identifierToken; | |
SourceLocation semicolonToken; | |
}; | |
class QML_PARSER_EXPORT ReturnStatement: public Statement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(ReturnStatement) | |
ReturnStatement(ExpressionNode *e): | |
expression (e) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return returnToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return semicolonToken; } | |
// attributes | |
ExpressionNode *expression; | |
SourceLocation returnToken; | |
SourceLocation semicolonToken; | |
}; | |
class QML_PARSER_EXPORT WithStatement: public Statement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(WithStatement) | |
WithStatement(ExpressionNode *e, Statement *stmt): | |
expression (e), statement (stmt) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return withToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return statement->lastSourceLocation(); } | |
// attributes | |
ExpressionNode *expression; | |
Statement *statement; | |
SourceLocation withToken; | |
SourceLocation lparenToken; | |
SourceLocation rparenToken; | |
}; | |
class QML_PARSER_EXPORT CaseBlock: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(CaseBlock) | |
CaseBlock(CaseClauses *c, DefaultClause *d = 0, CaseClauses *r = 0): | |
clauses (c), defaultClause (d), moreClauses (r) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
CaseClauses *clauses; | |
DefaultClause *defaultClause; | |
CaseClauses *moreClauses; | |
SourceLocation lbraceToken; | |
SourceLocation rbraceToken; | |
}; | |
class QML_PARSER_EXPORT SwitchStatement: public Statement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(SwitchStatement) | |
SwitchStatement(ExpressionNode *e, CaseBlock *b): | |
expression (e), block (b) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return switchToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return block->rbraceToken; } | |
// attributes | |
ExpressionNode *expression; | |
CaseBlock *block; | |
SourceLocation switchToken; | |
SourceLocation lparenToken; | |
SourceLocation rparenToken; | |
}; | |
class QML_PARSER_EXPORT CaseClauses: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(CaseClauses) | |
CaseClauses(CaseClause *c): | |
clause (c), next (this) | |
{ kind = K; } | |
CaseClauses(CaseClauses *previous, CaseClause *c): | |
clause (c) | |
{ | |
kind = K; | |
next = previous->next; | |
previous->next = this; | |
} | |
virtual void accept0(Visitor *visitor); | |
inline CaseClauses *finish () | |
{ | |
CaseClauses *front = next; | |
next = 0; | |
return front; | |
} | |
//attributes | |
CaseClause *clause; | |
CaseClauses *next; | |
}; | |
class QML_PARSER_EXPORT CaseClause: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(CaseClause) | |
CaseClause(ExpressionNode *e, StatementList *slist): | |
expression (e), statements (slist) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
ExpressionNode *expression; | |
StatementList *statements; | |
SourceLocation caseToken; | |
SourceLocation colonToken; | |
}; | |
class QML_PARSER_EXPORT DefaultClause: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(DefaultClause) | |
DefaultClause(StatementList *slist): | |
statements (slist) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
StatementList *statements; | |
SourceLocation defaultToken; | |
SourceLocation colonToken; | |
}; | |
class QML_PARSER_EXPORT LabelledStatement: public Statement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(LabelledStatement) | |
LabelledStatement(NameId *l, Statement *stmt): | |
label (l), statement (stmt) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return identifierToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return statement->lastSourceLocation(); } | |
// attributes | |
NameId *label; | |
Statement *statement; | |
SourceLocation identifierToken; | |
SourceLocation colonToken; | |
}; | |
class QML_PARSER_EXPORT ThrowStatement: public Statement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(ThrowStatement) | |
ThrowStatement(ExpressionNode *e): | |
expression (e) { kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return throwToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return semicolonToken; } | |
// attributes | |
ExpressionNode *expression; | |
SourceLocation throwToken; | |
SourceLocation semicolonToken; | |
}; | |
class QML_PARSER_EXPORT Catch: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(Catch) | |
Catch(NameId *n, Block *stmt): | |
name (n), statement (stmt) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
NameId *name; | |
Block *statement; | |
SourceLocation catchToken; | |
SourceLocation lparenToken; | |
SourceLocation identifierToken; | |
SourceLocation rparenToken; | |
}; | |
class QML_PARSER_EXPORT Finally: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(Finally) | |
Finally(Block *stmt): | |
statement (stmt) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
Block *statement; | |
SourceLocation finallyToken; | |
}; | |
class QML_PARSER_EXPORT TryStatement: public Statement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(TryStatement) | |
TryStatement(Statement *stmt, Catch *c, Finally *f): | |
statement (stmt), catchExpression (c), finallyExpression (f) | |
{ kind = K; } | |
TryStatement(Statement *stmt, Finally *f): | |
statement (stmt), catchExpression (0), finallyExpression (f) | |
{ kind = K; } | |
TryStatement(Statement *stmt, Catch *c): | |
statement (stmt), catchExpression (c), finallyExpression (0) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return tryToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ | |
if (finallyExpression) | |
return finallyExpression->statement->rbraceToken; | |
else if (catchExpression) | |
return catchExpression->statement->rbraceToken; | |
return statement->lastSourceLocation(); | |
} | |
// attributes | |
Statement *statement; | |
Catch *catchExpression; | |
Finally *finallyExpression; | |
SourceLocation tryToken; | |
}; | |
class QML_PARSER_EXPORT FunctionExpression: public ExpressionNode | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(FunctionExpression) | |
FunctionExpression(NameId *n, FormalParameterList *f, FunctionBody *b): | |
name (n), formals (f), body (b) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return functionToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return rbraceToken; } | |
// attributes | |
NameId *name; | |
FormalParameterList *formals; | |
FunctionBody *body; | |
SourceLocation functionToken; | |
SourceLocation identifierToken; | |
SourceLocation lparenToken; | |
SourceLocation rparenToken; | |
SourceLocation lbraceToken; | |
SourceLocation rbraceToken; | |
}; | |
class QML_PARSER_EXPORT FunctionDeclaration: public FunctionExpression | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(FunctionDeclaration) | |
FunctionDeclaration(NameId *n, FormalParameterList *f, FunctionBody *b): | |
FunctionExpression(n, f, b) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
}; | |
class QML_PARSER_EXPORT FormalParameterList: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(FormalParameterList) | |
FormalParameterList(NameId *n): | |
name (n), next (this) | |
{ kind = K; } | |
FormalParameterList(FormalParameterList *previous, NameId *n): | |
name (n) | |
{ | |
kind = K; | |
next = previous->next; | |
previous->next = this; | |
} | |
virtual void accept0(Visitor *visitor); | |
inline FormalParameterList *finish () | |
{ | |
FormalParameterList *front = next; | |
next = 0; | |
return front; | |
} | |
// attributes | |
NameId *name; | |
FormalParameterList *next; | |
SourceLocation commaToken; | |
SourceLocation identifierToken; | |
}; | |
class QML_PARSER_EXPORT FunctionBody: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(FunctionBody) | |
FunctionBody(SourceElements *elts): | |
elements (elts) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
SourceElements *elements; | |
}; | |
class QML_PARSER_EXPORT Program: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(Program) | |
Program(SourceElements *elts): | |
elements (elts) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
SourceElements *elements; | |
}; | |
class QML_PARSER_EXPORT SourceElements: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(SourceElements) | |
SourceElements(SourceElement *elt): | |
element (elt), next (this) | |
{ kind = K; } | |
SourceElements(SourceElements *previous, SourceElement *elt): | |
element (elt) | |
{ | |
kind = K; | |
next = previous->next; | |
previous->next = this; | |
} | |
virtual void accept0(Visitor *visitor); | |
inline SourceElements *finish () | |
{ | |
SourceElements *front = next; | |
next = 0; | |
return front; | |
} | |
// attributes | |
SourceElement *element; | |
SourceElements *next; | |
}; | |
class QML_PARSER_EXPORT SourceElement: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(SourceElement) | |
inline SourceElement() | |
{ kind = K; } | |
}; | |
class QML_PARSER_EXPORT FunctionSourceElement: public SourceElement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(FunctionSourceElement) | |
FunctionSourceElement(FunctionDeclaration *f): | |
declaration (f) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
FunctionDeclaration *declaration; | |
}; | |
class QML_PARSER_EXPORT StatementSourceElement: public SourceElement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(StatementSourceElement) | |
StatementSourceElement(Statement *stmt): | |
statement (stmt) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
Statement *statement; | |
}; | |
class QML_PARSER_EXPORT DebuggerStatement: public Statement | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(DebuggerStatement) | |
DebuggerStatement() | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
virtual SourceLocation firstSourceLocation() const | |
{ return debuggerToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return semicolonToken; } | |
// attributes | |
SourceLocation debuggerToken; | |
SourceLocation semicolonToken; | |
}; | |
class QML_PARSER_EXPORT UiProgram: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(UiProgram) | |
UiProgram(UiImportList *imports, UiObjectMemberList *members) | |
: imports(imports), members(members) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
UiImportList *imports; | |
UiObjectMemberList *members; | |
}; | |
class QML_PARSER_EXPORT UiQualifiedId: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(UiQualifiedId) | |
UiQualifiedId(NameId *name) | |
: next(this), name(name) | |
{ kind = K; } | |
UiQualifiedId(UiQualifiedId *previous, NameId *name) | |
: name(name) | |
{ | |
kind = K; | |
next = previous->next; | |
previous->next = this; | |
} | |
UiQualifiedId *finish() | |
{ | |
UiQualifiedId *head = next; | |
next = 0; | |
return head; | |
} | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
UiQualifiedId *next; | |
NameId *name; | |
SourceLocation identifierToken; | |
}; | |
class QML_PARSER_EXPORT UiImport: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(UiImport) | |
UiImport(NameId *fileName) | |
: fileName(fileName), importUri(0), importId(0) | |
{ kind = K; } | |
UiImport(UiQualifiedId *uri) | |
: fileName(0), importUri(uri), importId(0) | |
{ kind = K; } | |
virtual SourceLocation firstSourceLocation() const | |
{ return importToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return semicolonToken; } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
NameId *fileName; | |
UiQualifiedId *importUri; | |
NameId *importId; | |
SourceLocation importToken; | |
SourceLocation fileNameToken; | |
SourceLocation versionToken; | |
SourceLocation asToken; | |
SourceLocation importIdToken; | |
SourceLocation semicolonToken; | |
}; | |
class QML_PARSER_EXPORT UiImportList: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(UiImportList) | |
UiImportList(UiImport *import) | |
: import(import), | |
next(this) | |
{ kind = K; } | |
UiImportList(UiImportList *previous, UiImport *import) | |
: import(import) | |
{ | |
kind = K; | |
next = previous->next; | |
previous->next = this; | |
} | |
virtual SourceLocation firstSourceLocation() const | |
{ | |
if (import) return import->firstSourceLocation(); | |
else return SourceLocation(); | |
} | |
virtual SourceLocation lastSourceLocation() const | |
{ | |
for (const UiImportList *it = this; it; it = it->next) | |
if (!it->next && it->import) | |
return it->import->lastSourceLocation(); | |
return SourceLocation(); | |
} | |
UiImportList *finish() | |
{ | |
UiImportList *head = next; | |
next = 0; | |
return head; | |
} | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
UiImport *import; | |
UiImportList *next; | |
}; | |
class QML_PARSER_EXPORT UiObjectMember: public Node | |
{ | |
public: | |
virtual SourceLocation firstSourceLocation() const = 0; | |
virtual SourceLocation lastSourceLocation() const = 0; | |
virtual UiObjectMember *uiObjectMemberCast(); | |
}; | |
class QML_PARSER_EXPORT UiObjectMemberList: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(UiObjectMemberList) | |
UiObjectMemberList(UiObjectMember *member) | |
: next(this), member(member) | |
{ kind = K; } | |
UiObjectMemberList(UiObjectMemberList *previous, UiObjectMember *member) | |
: member(member) | |
{ | |
kind = K; | |
next = previous->next; | |
previous->next = this; | |
} | |
virtual void accept0(Visitor *visitor); | |
UiObjectMemberList *finish() | |
{ | |
UiObjectMemberList *head = next; | |
next = 0; | |
return head; | |
} | |
// attributes | |
UiObjectMemberList *next; | |
UiObjectMember *member; | |
}; | |
class QML_PARSER_EXPORT UiArrayMemberList: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(UiArrayMemberList) | |
UiArrayMemberList(UiObjectMember *member) | |
: next(this), member(member) | |
{ kind = K; } | |
UiArrayMemberList(UiArrayMemberList *previous, UiObjectMember *member) | |
: member(member) | |
{ | |
kind = K; | |
next = previous->next; | |
previous->next = this; | |
} | |
virtual void accept0(Visitor *visitor); | |
UiArrayMemberList *finish() | |
{ | |
UiArrayMemberList *head = next; | |
next = 0; | |
return head; | |
} | |
// attributes | |
UiArrayMemberList *next; | |
UiObjectMember *member; | |
SourceLocation commaToken; | |
}; | |
class QML_PARSER_EXPORT UiObjectInitializer: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(UiObjectInitializer) | |
UiObjectInitializer(UiObjectMemberList *members) | |
: members(members) | |
{ kind = K; } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
SourceLocation lbraceToken; | |
UiObjectMemberList *members; | |
SourceLocation rbraceToken; | |
}; | |
class QML_PARSER_EXPORT UiParameterList: public Node | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(UiParameterList) | |
UiParameterList(NameId *t, NameId *n): | |
type (t), name (n), next (this) | |
{ kind = K; } | |
UiParameterList(UiParameterList *previous, NameId *t, NameId *n): | |
type (t), name (n) | |
{ | |
kind = K; | |
next = previous->next; | |
previous->next = this; | |
} | |
virtual void accept0(Visitor *) {} | |
inline UiParameterList *finish () | |
{ | |
UiParameterList *front = next; | |
next = 0; | |
return front; | |
} | |
// attributes | |
NameId *type; | |
NameId *name; | |
UiParameterList *next; | |
SourceLocation commaToken; | |
SourceLocation identifierToken; | |
}; | |
class QML_PARSER_EXPORT UiPublicMember: public UiObjectMember | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(UiPublicMember) | |
UiPublicMember(NameId *memberType, | |
NameId *name) | |
: type(Property), typeModifier(0), memberType(memberType), name(name), expression(0), binding(0), isDefaultMember(false), isReadonlyMember(false), parameters(0) | |
{ kind = K; } | |
UiPublicMember(NameId *memberType, | |
NameId *name, | |
ExpressionNode *expression) | |
: type(Property), typeModifier(0), memberType(memberType), name(name), expression(expression), binding(0), isDefaultMember(false), isReadonlyMember(false), parameters(0) | |
{ kind = K; } | |
virtual SourceLocation firstSourceLocation() const | |
{ | |
if (defaultToken.isValid()) | |
return defaultToken; | |
else if (readonlyToken.isValid()) | |
return readonlyToken; | |
return propertyToken; | |
} | |
virtual SourceLocation lastSourceLocation() const | |
{ | |
if (binding) | |
return binding->lastSourceLocation(); | |
return semicolonToken; | |
} | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
enum { Signal, Property } type; | |
NameId *typeModifier; | |
NameId *memberType; | |
NameId *name; | |
ExpressionNode *expression; // initialized with a JS expression | |
UiObjectMember *binding; // initialized with a QML object or array. | |
bool isDefaultMember; | |
bool isReadonlyMember; | |
UiParameterList *parameters; | |
SourceLocation defaultToken; | |
SourceLocation readonlyToken; | |
SourceLocation propertyToken; | |
SourceLocation typeModifierToken; | |
SourceLocation typeToken; | |
SourceLocation identifierToken; | |
SourceLocation colonToken; | |
SourceLocation semicolonToken; | |
}; | |
class QML_PARSER_EXPORT UiObjectDefinition: public UiObjectMember | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(UiObjectDefinition) | |
UiObjectDefinition(UiQualifiedId *qualifiedTypeNameId, | |
UiObjectInitializer *initializer) | |
: qualifiedTypeNameId(qualifiedTypeNameId), initializer(initializer) | |
{ kind = K; } | |
virtual SourceLocation firstSourceLocation() const | |
{ return qualifiedTypeNameId->identifierToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return initializer->rbraceToken; } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
UiQualifiedId *qualifiedTypeNameId; | |
UiObjectInitializer *initializer; | |
}; | |
class QML_PARSER_EXPORT UiSourceElement: public UiObjectMember | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(UiSourceElement) | |
UiSourceElement(Node *sourceElement) | |
: sourceElement(sourceElement) | |
{ kind = K; } | |
virtual SourceLocation firstSourceLocation() const | |
{ | |
if (FunctionDeclaration *funDecl = cast<FunctionDeclaration *>(sourceElement)) | |
return funDecl->firstSourceLocation(); | |
else if (VariableStatement *varStmt = cast<VariableStatement *>(sourceElement)) | |
return varStmt->firstSourceLocation(); | |
return SourceLocation(); | |
} | |
virtual SourceLocation lastSourceLocation() const | |
{ | |
if (FunctionDeclaration *funDecl = cast<FunctionDeclaration *>(sourceElement)) | |
return funDecl->lastSourceLocation(); | |
else if (VariableStatement *varStmt = cast<VariableStatement *>(sourceElement)) | |
return varStmt->lastSourceLocation(); | |
return SourceLocation(); | |
} | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
Node *sourceElement; | |
}; | |
class QML_PARSER_EXPORT UiObjectBinding: public UiObjectMember | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(UiObjectBinding) | |
UiObjectBinding(UiQualifiedId *qualifiedId, | |
UiQualifiedId *qualifiedTypeNameId, | |
UiObjectInitializer *initializer) | |
: qualifiedId(qualifiedId), | |
qualifiedTypeNameId(qualifiedTypeNameId), | |
initializer(initializer), | |
hasOnToken(false) | |
{ kind = K; } | |
virtual SourceLocation firstSourceLocation() const | |
{ | |
if (hasOnToken && qualifiedTypeNameId) | |
return qualifiedTypeNameId->identifierToken; | |
return qualifiedId->identifierToken; | |
} | |
virtual SourceLocation lastSourceLocation() const | |
{ return initializer->rbraceToken; } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
UiQualifiedId *qualifiedId; | |
UiQualifiedId *qualifiedTypeNameId; | |
UiObjectInitializer *initializer; | |
SourceLocation colonToken; | |
bool hasOnToken; | |
}; | |
class QML_PARSER_EXPORT UiScriptBinding: public UiObjectMember | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(UiScriptBinding) | |
UiScriptBinding(UiQualifiedId *qualifiedId, | |
Statement *statement) | |
: qualifiedId(qualifiedId), | |
statement(statement) | |
{ kind = K; } | |
virtual SourceLocation firstSourceLocation() const | |
{ return qualifiedId->identifierToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return statement->lastSourceLocation(); } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
UiQualifiedId *qualifiedId; | |
Statement *statement; | |
SourceLocation colonToken; | |
}; | |
class QML_PARSER_EXPORT UiArrayBinding: public UiObjectMember | |
{ | |
public: | |
QDECLARATIVEJS_DECLARE_AST_NODE(UiArrayBinding) | |
UiArrayBinding(UiQualifiedId *qualifiedId, | |
UiArrayMemberList *members) | |
: qualifiedId(qualifiedId), | |
members(members) | |
{ kind = K; } | |
virtual SourceLocation firstSourceLocation() const | |
{ return qualifiedId->identifierToken; } | |
virtual SourceLocation lastSourceLocation() const | |
{ return rbracketToken; } | |
virtual void accept0(Visitor *visitor); | |
// attributes | |
UiQualifiedId *qualifiedId; | |
UiArrayMemberList *members; | |
SourceLocation colonToken; | |
SourceLocation lbracketToken; | |
SourceLocation rbracketToken; | |
}; | |
} } // namespace AST | |
QT_QML_END_NAMESPACE | |
#endif |