File Index Symbol Index

/*********************************************************************** This file is generated by: Vczh Parser Generator From parser definition:WfExpression.parser.txt Licensed under https://github.com/vczh-libraries/License ***********************************************************************/
#ifndef VCZH_WORKFLOW_EXPRESSION_WFEXPRESSIONPARSER_AST
#define VCZH_WORKFLOW_EXPRESSION_WFEXPRESSIONPARSER_AST
#include <VlppParser.h>
namespace
vl
{
namespace
workflow
{
/// <summary>Token types. Values of enum items will be used in <see cref="vl::regex::RegexToken::token"/>.</summary>
enum
class
WfParserTokenIndex
{
/// <summary>Token EXP: /^</summary>
EXP
=
0
,
/// <summary>Token ADD: /+</summary>
ADD
=
1
,
/// <summary>Token SUB: -</summary>
SUB
=
2
,
/// <summary>Token MUL: /*</summary>
MUL
=
3
,
/// <summary>Token DIV: //</summary>
DIV
=
4
,
/// <summary>Token MOD: %</summary>
MOD
=
5
,
/// <summary>Token JOIN: &amp;</summary>
JOIN
=
6
,
/// <summary>Token INTERSECTION: /|</summary>
INTERSECTION
=
7
,
/// <summary>Token LE: /&lt;/=</summary>
LE
=
8
,
/// <summary>Token GE: /&gt;/=</summary>
GE
=
9
,
/// <summary>Token LT: /&lt;</summary>
LT
=
10
,
/// <summary>Token GT: /&gt;</summary>
GT
=
11
,
/// <summary>Token EQ: /=/=</summary>
EQ
=
12
,
/// <summary>Token NE: /!/=</summary>
NE
=
13
,
/// <summary>Token ASSIGN: /=</summary>
ASSIGN
=
14
,
/// <summary>Token FAILED_THEN: /?/?</summary>
FAILED_THEN
=
15
,
/// <summary>Token QUESTION_MARK: /?</summary>
QUESTION_MARK
=
16
,
/// <summary>Token SCOPE_DELIMITER: ::</summary>
SCOPE_DELIMITER
=
17
,
/// <summary>Token COLON: :</summary>
COLON
=
18
,
/// <summary>Token SEMICOLON: ;</summary>
SEMICOLON
=
19
,
/// <summary>Token COMMA: ,</summary>
COMMA
=
20
,
/// <summary>Token DOT: .</summary>
DOT
=
21
,
/// <summary>Token OPEN_ARRAY: /[</summary>
OPEN_ARRAY
=
22
,
/// <summary>Token CLOSE_ARRAY: /]</summary>
CLOSE_ARRAY
=
23
,
/// <summary>Token OPEN_BRACE: /{</summary>
OPEN_BRACE
=
24
,
/// <summary>Token CLOSE_BRACE: /}</summary>
CLOSE_BRACE
=
25
,
/// <summary>Token OPEN_BRACKET: /(</summary>
OPEN_BRACKET
=
26
,
/// <summary>Token CLOSE_BRACKET: /)</summary>
CLOSE_BRACKET
=
27
,
/// <summary>Token AT: @</summary>
AT
=
28
,
/// <summary>Token TYPE_VOID: void</summary>
TYPE_VOID
=
29
,
/// <summary>Token TYPE_OBJECT: object</summary>
TYPE_OBJECT
=
30
,
/// <summary>Token TYPE_INTERFACE: interface</summary>
TYPE_INTERFACE
=
31
,
/// <summary>Token TYPE_INT: int</summary>
TYPE_INT
=
32
,
/// <summary>Token TYPE_UINT: uint</summary>
TYPE_UINT
=
33
,
/// <summary>Token TYPE_FLOAT: float</summary>
TYPE_FLOAT
=
34
,
/// <summary>Token TYPE_DOUBLE: double</summary>
TYPE_DOUBLE
=
35
,
/// <summary>Token TYPE_STRING: string</summary>
TYPE_STRING
=
36
,
/// <summary>Token TYPE_CHAR: char</summary>
TYPE_CHAR
=
37
,
/// <summary>Token TYPE_BOOL: bool</summary>
TYPE_BOOL
=
38
,
/// <summary>Token KEYWORD_CONST: const</summary>
KEYWORD_CONST
=
39
,
/// <summary>Token KEYWORD_SHL: shl</summary>
KEYWORD_SHL
=
40
,
/// <summary>Token KEYWORD_SHR: shr</summary>
KEYWORD_SHR
=
41
,
/// <summary>Token KEYWORD_XOR: xor</summary>
KEYWORD_XOR
=
42
,
/// <summary>Token KEYWORD_AND: and</summary>
KEYWORD_AND
=
43
,
/// <summary>Token KEYWORD_OR: or</summary>
KEYWORD_OR
=
44
,
/// <summary>Token KEYWORD_NOT: not</summary>
KEYWORD_NOT
=
45
,
/// <summary>Token KEYWORD_NULL: null</summary>
KEYWORD_NULL
=
46
,
/// <summary>Token KEYWORD_THIS: this</summary>
KEYWORD_THIS
=
47
,
/// <summary>Token KEYWORD_TRUE: true</summary>
KEYWORD_TRUE
=
48
,
/// <summary>Token KEYWORD_FALSE: false</summary>
KEYWORD_FALSE
=
49
,
/// <summary>Token KEYWORD_LET: let</summary>
KEYWORD_LET
=
50
,
/// <summary>Token KEYWORD_IN: in</summary>
KEYWORD_IN
=
51
,
/// <summary>Token KEYWORD_RANGE: range</summary>
KEYWORD_RANGE
=
52
,
/// <summary>Token KEYWORD_NEW: new</summary>
KEYWORD_NEW
=
53
,
/// <summary>Token KEYWORD_OF: of</summary>
KEYWORD_OF
=
54
,
/// <summary>Token KEYWORD_AS: as</summary>
KEYWORD_AS
=
55
,
/// <summary>Token KEYWORD_IS: is</summary>
KEYWORD_IS
=
56
,
/// <summary>Token KEYWORD_CAST: cast</summary>
KEYWORD_CAST
=
57
,
/// <summary>Token KEYWORD_FUNC: func</summary>
KEYWORD_FUNC
=
58
,
/// <summary>Token KEYWORD_TYPEOF: typeof</summary>
KEYWORD_TYPEOF
=
59
,
/// <summary>Token KEYWORD_TYPE: type</summary>
KEYWORD_TYPE
=
60
,
/// <summary>Token KEYWORD_BIND: bind</summary>
KEYWORD_BIND
=
61
,
/// <summary>Token KEYWORD_OBSERVE: observe</summary>
KEYWORD_OBSERVE
=
62
,
/// <summary>Token KEYWORD_ON: on</summary>
KEYWORD_ON
=
63
,
/// <summary>Token KEYWORD_ATTACH: attach</summary>
KEYWORD_ATTACH
=
64
,
/// <summary>Token KEYWORD_DETACH: detach</summary>
KEYWORD_DETACH
=
65
,
/// <summary>Token KEYWORD_GOTO: goto</summary>
KEYWORD_GOTO
=
66
,
/// <summary>Token KEYWORD_VAR: var</summary>
KEYWORD_VAR
=
67
,
/// <summary>Token KEYWORD_BREAK: break</summary>
KEYWORD_BREAK
=
68
,
/// <summary>Token KEYWORD_CONTINUE: continue</summary>
KEYWORD_CONTINUE
=
69
,
/// <summary>Token KEYWORD_RETURN: return</summary>
KEYWORD_RETURN
=
70
,
/// <summary>Token KEYWORD_DELETE: delete</summary>
KEYWORD_DELETE
=
71
,
/// <summary>Token KEYWORD_RAISE: raise</summary>
KEYWORD_RAISE
=
72
,
/// <summary>Token KEYWORD_IF: if</summary>
KEYWORD_IF
=
73
,
/// <summary>Token KEYWORD_ELSE: else</summary>
KEYWORD_ELSE
=
74
,
/// <summary>Token KEYWORD_SWITCH: switch</summary>
KEYWORD_SWITCH
=
75
,
/// <summary>Token KEYWORD_CASE: case</summary>
KEYWORD_CASE
=
76
,
/// <summary>Token KEYWORD_DEFAULT: default</summary>
KEYWORD_DEFAULT
=
77
,
/// <summary>Token KEYWORD_WHILE: while</summary>
KEYWORD_WHILE
=
78
,
/// <summary>Token KEYWORD_FOR: for</summary>
KEYWORD_FOR
=
79
,
/// <summary>Token KEYWORD_REVERSED: reversed</summary>
KEYWORD_REVERSED
=
80
,
/// <summary>Token KEYWORD_TRY: try</summary>
KEYWORD_TRY
=
81
,
/// <summary>Token KEYWORD_CATCH: catch</summary>
KEYWORD_CATCH
=
82
,
/// <summary>Token KEYWORD_FINALLY: finally</summary>
KEYWORD_FINALLY
=
83
,
/// <summary>Token KEYWORD_CLASS: class</summary>
KEYWORD_CLASS
=
84
,
/// <summary>Token KEYWORD_ENUM: enum</summary>
KEYWORD_ENUM
=
85
,
/// <summary>Token KEYWORD_FLAGENUM: flagenum</summary>
KEYWORD_FLAGENUM
=
86
,
/// <summary>Token KEYWORD_STRUCT: struct</summary>
KEYWORD_STRUCT
=
87
,
/// <summary>Token KEYWORD_PROP: prop</summary>
KEYWORD_PROP
=
88
,
/// <summary>Token KEYWORD_EVENT: event</summary>
KEYWORD_EVENT
=
89
,
/// <summary>Token KEYWORD_STATIC: static</summary>
KEYWORD_STATIC
=
90
,
/// <summary>Token KEYWORD_OVERRIDE: override</summary>
KEYWORD_OVERRIDE
=
91
,
/// <summary>Token KEYWORD_USING: using</summary>
KEYWORD_USING
=
92
,
/// <summary>Token KEYWORD_NAMESPACE: namespace</summary>
KEYWORD_NAMESPACE
=
93
,
/// <summary>Token KEYWORD_MODULE: module</summary>
KEYWORD_MODULE
=
94
,
/// <summary>Token KEYWORD_UNIT: unit</summary>
KEYWORD_UNIT
=
95
,
/// <summary>Token STATE_MACHINE: /$state_machine</summary>
STATE_MACHINE
=
96
,
/// <summary>Token STATE_INPUT: /$state_input</summary>
STATE_INPUT
=
97
,
/// <summary>Token STATE_SWITCH: /$switch</summary>
STATE_SWITCH
=
98
,
/// <summary>Token STATE_GOTO: /$goto_state</summary>
STATE_GOTO
=
99
,
/// <summary>Token STATE_PUSH: /$push_state</summary>
STATE_PUSH
=
100
,
/// <summary>Token STATE_DECL: /$state</summary>
STATE_DECL
=
101
,
/// <summary>Token COROUTINE_COROUTINE: /$coroutine</summary>
COROUTINE_COROUTINE
=
102
,
/// <summary>Token COROUTINE_PAUSE: /$pause</summary>
COROUTINE_PAUSE
=
103
,
/// <summary>Token COROUTINE_INTERFACE: /$interface</summary>
COROUTINE_INTERFACE
=
104
,
/// <summary>Token COROUTINE_OPERATOR: /$[A-Z]/w*</summary>
COROUTINE_OPERATOR
=
105
,
/// <summary>Token COROUTINE_SIGN: /$</summary>
COROUTINE_SIGN
=
106
,
/// <summary>Token NAME: [a-zA-Z_]/w*</summary>
NAME
=
107
,
/// <summary>Token ORDERED_NAME: /$[0-9]*</summary>
ORDERED_NAME
=
108
,
/// <summary>Token FLOAT: /d+./d+</summary>
FLOAT
=
109
,
/// <summary>Token INTEGER: /d+</summary>
INTEGER
=
110
,
/// <summary>Token STRING: &apos;([^&apos;\\]|\\\.)*&apos;|&quot;([^&quot;\\]|\\\.)*&quot;</summary>
STRING
=
111
,
/// <summary>Token FORMATSTRING: /$(&apos;([^&apos;\\]|\\\.)*&apos;|&quot;([^&quot;\\]|\\\.)*&quot;)</summary>
FORMATSTRING
=
112
,
/// <summary>Discardable token SPACE: /s+</summary>
SPACE
=
113
,
/// <summary>Discardable token COMMENT: ///*([^*]|/*+[^//])*/*+//</summary>
COMMENT
=
114
, };
class
WfClassMember
;
class
WfType
;
class
WfExpression
;
class
WfStatement
;
class
WfAttribute
;
class
WfDeclaration
;
class
WfPredefinedType
;
class
WfTopQualifiedType
;
class
WfReferenceType
;
class
WfRawPointerType
;
class
WfSharedPointerType
;
class
WfNullableType
;
class
WfEnumerableType
;
class
WfMapType
;
class
WfObservableListType
;
class
WfFunctionType
;
class
WfChildType
;
class
WfNamespaceDeclaration
;
class
WfFunctionArgument
;
class
WfFunctionDeclaration
;
class
WfVariableDeclaration
;
class
WfEventDeclaration
;
class
WfPropertyDeclaration
;
class
WfBaseConstructorCall
;
class
WfConstructorDeclaration
;
class
WfDestructorDeclaration
;
class
WfClassDeclaration
;
class
WfEnumItemIntersection
;
class
WfEnumItem
;
class
WfEnumDeclaration
;
class
WfStructMember
;
class
WfStructDeclaration
;
class
WfVirtualCfeDeclaration
;
class
WfAutoPropertyDeclaration
;
class
WfCastResultInterfaceDeclaration
;
class
WfVirtualCseDeclaration
;
class
WfStateInput
;
class
WfStateDeclaration
;
class
WfStateMachineDeclaration
;
class
WfBreakStatement
;
class
WfContinueStatement
;
class
WfReturnStatement
;
class
WfDeleteStatement
;
class
WfRaiseExceptionStatement
;
class
WfIfStatement
;
class
WfWhileStatement
;
class
WfTryStatement
;
class
WfBlockStatement
;
class
WfGotoStatement
;
class
WfVariableStatement
;
class
WfExpressionStatement
;
class
WfVirtualCseStatement
;
class
WfForEachStatement
;
class
WfSwitchCase
;
class
WfSwitchStatement
;
class
WfCoProviderStatement
;
class
WfCoroutineStatement
;
class
WfCoPauseStatement
;
class
WfCoOperatorStatement
;
class
WfStateMachineStatement
;
class
WfStateSwitchArgument
;
class
WfStateSwitchCase
;
class
WfStateSwitchStatement
;
class
WfStateInvokeStatement
;
class
WfThisExpression
;
class
WfTopQualifiedExpression
;
class
WfReferenceExpression
;
class
WfOrderedNameExpression
;
class
WfOrderedLambdaExpression
;
class
WfMemberExpression
;
class
WfChildExpression
;
class
WfLiteralExpression
;
class
WfFloatingExpression
;
class
WfIntegerExpression
;
class
WfStringExpression
;
class
WfUnaryExpression
;
class
WfBinaryExpression
;
class
WfLetVariable
;
class
WfLetExpression
;
class
WfIfExpression
;
class
WfRangeExpression
;
class
WfSetTestingExpression
;
class
WfConstructorArgument
;
class
WfConstructorExpression
;
class
WfInferExpression
;
class
WfTypeCastingExpression
;
class
WfTypeTestingExpression
;
class
WfTypeOfTypeExpression
;
class
WfTypeOfExpressionExpression
;
class
WfAttachEventExpression
;
class
WfDetachEventExpression
;
class
WfObserveExpression
;
class
WfCallExpression
;
class
WfFunctionExpression
;
class
WfNewClassExpression
;
class
WfNewInterfaceExpression
;
class
WfVirtualCfeExpression
;
class
WfFormatExpression
;
class
WfVirtualCseExpression
;
class
WfBindExpression
;
class
WfNewCoroutineExpression
;
class
WfMixinCastExpression
;
class
WfExpectedTypeCastExpression
;
class
WfCoOperatorExpression
;
class
WfModuleUsingFragment
;
class
WfModuleUsingNameFragment
;
class
WfModuleUsingWildCardFragment
;
class
WfModuleUsingItem
;
class
WfModuleUsingPath
;
class
WfModule
;
enum
class
WfClassMemberKind
{
Static
,
Override
,
Normal
, };
class
WfClassMember
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfClassMember
> {
public
:
WfClassMemberKind
kind
;
static
vl
::
Ptr
<
WfClassMember
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfType
abstract
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfType
> {
public
:
class
IVisitor
:
public
vl
::
reflection
::
IDescriptable
,
vl
::
reflection
::
Description
<
IVisitor
> {
public
:
virtual
void
Visit
(
WfPredefinedType
*
node
)=
0
;
virtual
void
Visit
(
WfTopQualifiedType
*
node
)=
0
;
virtual
void
Visit
(
WfReferenceType
*
node
)=
0
;
virtual
void
Visit
(
WfRawPointerType
*
node
)=
0
;
virtual
void
Visit
(
WfSharedPointerType
*
node
)=
0
;
virtual
void
Visit
(
WfNullableType
*
node
)=
0
;
virtual
void
Visit
(
WfEnumerableType
*
node
)=
0
;
virtual
void
Visit
(
WfMapType
*
node
)=
0
;
virtual
void
Visit
(
WfObservableListType
*
node
)=
0
;
virtual
void
Visit
(
WfFunctionType
*
node
)=
0
;
virtual
void
Visit
(
WfChildType
*
node
)=
0
; };
virtual
void
Accept
(
WfType
::
IVisitor
*
visitor
)=
0
; };
class
WfExpression
abstract
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfExpression
> {
public
:
class
IVisitor
:
public
vl
::
reflection
::
IDescriptable
,
vl
::
reflection
::
Description
<
IVisitor
> {
public
:
virtual
void
Visit
(
WfThisExpression
*
node
)=
0
;
virtual
void
Visit
(
WfTopQualifiedExpression
*
node
)=
0
;
virtual
void
Visit
(
WfReferenceExpression
*
node
)=
0
;
virtual
void
Visit
(
WfOrderedNameExpression
*
node
)=
0
;
virtual
void
Visit
(
WfOrderedLambdaExpression
*
node
)=
0
;
virtual
void
Visit
(
WfMemberExpression
*
node
)=
0
;
virtual
void
Visit
(
WfChildExpression
*
node
)=
0
;
virtual
void
Visit
(
WfLiteralExpression
*
node
)=
0
;
virtual
void
Visit
(
WfFloatingExpression
*
node
)=
0
;
virtual
void
Visit
(
WfIntegerExpression
*
node
)=
0
;
virtual
void
Visit
(
WfStringExpression
*
node
)=
0
;
virtual
void
Visit
(
WfUnaryExpression
*
node
)=
0
;
virtual
void
Visit
(
WfBinaryExpression
*
node
)=
0
;
virtual
void
Visit
(
WfLetExpression
*
node
)=
0
;
virtual
void
Visit
(
WfIfExpression
*
node
)=
0
;
virtual
void
Visit
(
WfRangeExpression
*
node
)=
0
;
virtual
void
Visit
(
WfSetTestingExpression
*
node
)=
0
;
virtual
void
Visit
(
WfConstructorExpression
*
node
)=
0
;
virtual
void
Visit
(
WfInferExpression
*
node
)=
0
;
virtual
void
Visit
(
WfTypeCastingExpression
*
node
)=
0
;
virtual
void
Visit
(
WfTypeTestingExpression
*
node
)=
0
;
virtual
void
Visit
(
WfTypeOfTypeExpression
*
node
)=
0
;
virtual
void
Visit
(
WfTypeOfExpressionExpression
*
node
)=
0
;
virtual
void
Visit
(
WfAttachEventExpression
*
node
)=
0
;
virtual
void
Visit
(
WfDetachEventExpression
*
node
)=
0
;
virtual
void
Visit
(
WfObserveExpression
*
node
)=
0
;
virtual
void
Visit
(
WfCallExpression
*
node
)=
0
;
virtual
void
Visit
(
WfFunctionExpression
*
node
)=
0
;
virtual
void
Visit
(
WfNewClassExpression
*
node
)=
0
;
virtual
void
Visit
(
WfNewInterfaceExpression
*
node
)=
0
;
virtual
void
Visit
(
WfVirtualCfeExpression
*
node
)=
0
;
virtual
void
Visit
(
WfVirtualCseExpression
*
node
)=
0
; };
virtual
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)=
0
; };
class
WfStatement
abstract
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfStatement
> {
public
:
class
IVisitor
:
public
vl
::
reflection
::
IDescriptable
,
vl
::
reflection
::
Description
<
IVisitor
> {
public
:
virtual
void
Visit
(
WfBreakStatement
*
node
)=
0
;
virtual
void
Visit
(
WfContinueStatement
*
node
)=
0
;
virtual
void
Visit
(
WfReturnStatement
*
node
)=
0
;
virtual
void
Visit
(
WfDeleteStatement
*
node
)=
0
;
virtual
void
Visit
(
WfRaiseExceptionStatement
*
node
)=
0
;
virtual
void
Visit
(
WfIfStatement
*
node
)=
0
;
virtual
void
Visit
(
WfWhileStatement
*
node
)=
0
;
virtual
void
Visit
(
WfTryStatement
*
node
)=
0
;
virtual
void
Visit
(
WfBlockStatement
*
node
)=
0
;
virtual
void
Visit
(
WfGotoStatement
*
node
)=
0
;
virtual
void
Visit
(
WfVariableStatement
*
node
)=
0
;
virtual
void
Visit
(
WfExpressionStatement
*
node
)=
0
;
virtual
void
Visit
(
WfVirtualCseStatement
*
node
)=
0
;
virtual
void
Visit
(
WfCoroutineStatement
*
node
)=
0
;
virtual
void
Visit
(
WfStateMachineStatement
*
node
)=
0
; };
virtual
void
Accept
(
WfStatement
::
IVisitor
*
visitor
)=
0
; };
class
WfAttribute
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfAttribute
> {
public
:
vl
::
parsing
::
ParsingToken
category
;
vl
::
parsing
::
ParsingToken
name
;
vl
::
Ptr
<
WfExpression
>
value
;
static
vl
::
Ptr
<
WfAttribute
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfDeclaration
abstract
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfDeclaration
> {
public
:
class
IVisitor
:
public
vl
::
reflection
::
IDescriptable
,
vl
::
reflection
::
Description
<
IVisitor
> {
public
:
virtual
void
Visit
(
WfNamespaceDeclaration
*
node
)=
0
;
virtual
void
Visit
(
WfFunctionDeclaration
*
node
)=
0
;
virtual
void
Visit
(
WfVariableDeclaration
*
node
)=
0
;
virtual
void
Visit
(
WfEventDeclaration
*
node
)=
0
;
virtual
void
Visit
(
WfPropertyDeclaration
*
node
)=
0
;
virtual
void
Visit
(
WfConstructorDeclaration
*
node
)=
0
;
virtual
void
Visit
(
WfDestructorDeclaration
*
node
)=
0
;
virtual
void
Visit
(
WfClassDeclaration
*
node
)=
0
;
virtual
void
Visit
(
WfEnumDeclaration
*
node
)=
0
;
virtual
void
Visit
(
WfStructDeclaration
*
node
)=
0
;
virtual
void
Visit
(
WfVirtualCfeDeclaration
*
node
)=
0
;
virtual
void
Visit
(
WfVirtualCseDeclaration
*
node
)=
0
; };
virtual
void
Accept
(
WfDeclaration
::
IVisitor
*
visitor
)=
0
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfAttribute
>>
attributes
;
vl
::
parsing
::
ParsingToken
name
;
vl
::
Ptr
<
WfClassMember
>
classMember
; };
enum
class
WfPredefinedTypeName
{
Void
,
Object
,
Interface
,
Int
,
UInt
,
Float
,
Double
,
String
,
Char
,
Bool
, };
class
WfPredefinedType
:
public
WfType
,
vl
::
reflection
::
Description
<
WfPredefinedType
> {
public
:
WfPredefinedTypeName
name
;
void
Accept
(
WfType
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfPredefinedType
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfTopQualifiedType
:
public
WfType
,
vl
::
reflection
::
Description
<
WfTopQualifiedType
> {
public
:
vl
::
parsing
::
ParsingToken
name
;
void
Accept
(
WfType
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfTopQualifiedType
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfReferenceType
:
public
WfType
,
vl
::
reflection
::
Description
<
WfReferenceType
> {
public
:
vl
::
parsing
::
ParsingToken
name
;
void
Accept
(
WfType
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfReferenceType
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfRawPointerType
:
public
WfType
,
vl
::
reflection
::
Description
<
WfRawPointerType
> {
public
:
vl
::
Ptr
<
WfType
>
element
;
void
Accept
(
WfType
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfRawPointerType
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfSharedPointerType
:
public
WfType
,
vl
::
reflection
::
Description
<
WfSharedPointerType
> {
public
:
vl
::
Ptr
<
WfType
>
element
;
void
Accept
(
WfType
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfSharedPointerType
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfNullableType
:
public
WfType
,
vl
::
reflection
::
Description
<
WfNullableType
> {
public
:
vl
::
Ptr
<
WfType
>
element
;
void
Accept
(
WfType
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfNullableType
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfEnumerableType
:
public
WfType
,
vl
::
reflection
::
Description
<
WfEnumerableType
> {
public
:
vl
::
Ptr
<
WfType
>
element
;
void
Accept
(
WfType
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfEnumerableType
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
enum
class
WfMapWritability
{
Readonly
,
Writable
, };
class
WfMapType
:
public
WfType
,
vl
::
reflection
::
Description
<
WfMapType
> {
public
:
WfMapWritability
writability
;
vl
::
Ptr
<
WfType
>
key
;
vl
::
Ptr
<
WfType
>
value
;
void
Accept
(
WfType
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfMapType
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfObservableListType
:
public
WfType
,
vl
::
reflection
::
Description
<
WfObservableListType
> {
public
:
vl
::
Ptr
<
WfType
>
element
;
void
Accept
(
WfType
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfObservableListType
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfFunctionType
:
public
WfType
,
vl
::
reflection
::
Description
<
WfFunctionType
> {
public
:
vl
::
Ptr
<
WfType
>
result
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfType
>>
arguments
;
void
Accept
(
WfType
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfFunctionType
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfChildType
:
public
WfType
,
vl
::
reflection
::
Description
<
WfChildType
> {
public
:
vl
::
Ptr
<
WfType
>
parent
;
vl
::
parsing
::
ParsingToken
name
;
void
Accept
(
WfType
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfChildType
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfNamespaceDeclaration
:
public
WfDeclaration
,
vl
::
reflection
::
Description
<
WfNamespaceDeclaration
> {
public
:
vl
::
collections
::
List
<
vl
::
Ptr
<
WfDeclaration
>>
declarations
;
void
Accept
(
WfDeclaration
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfNamespaceDeclaration
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfFunctionArgument
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfFunctionArgument
> {
public
:
vl
::
collections
::
List
<
vl
::
Ptr
<
WfAttribute
>>
attributes
;
vl
::
parsing
::
ParsingToken
name
;
vl
::
Ptr
<
WfType
>
type
;
static
vl
::
Ptr
<
WfFunctionArgument
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
enum
class
WfFunctionAnonymity
{
Named
,
Anonymous
, };
class
WfFunctionDeclaration
:
public
WfDeclaration
,
vl
::
reflection
::
Description
<
WfFunctionDeclaration
> {
public
:
WfFunctionAnonymity
anonymity
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfFunctionArgument
>>
arguments
;
vl
::
Ptr
<
WfType
>
returnType
;
vl
::
Ptr
<
WfStatement
>
statement
;
void
Accept
(
WfDeclaration
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfFunctionDeclaration
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfVariableDeclaration
:
public
WfDeclaration
,
vl
::
reflection
::
Description
<
WfVariableDeclaration
> {
public
:
vl
::
Ptr
<
WfType
>
type
;
vl
::
Ptr
<
WfExpression
>
expression
;
void
Accept
(
WfDeclaration
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfVariableDeclaration
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfEventDeclaration
:
public
WfDeclaration
,
vl
::
reflection
::
Description
<
WfEventDeclaration
> {
public
:
vl
::
collections
::
List
<
vl
::
Ptr
<
WfType
>>
arguments
;
void
Accept
(
WfDeclaration
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfEventDeclaration
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfPropertyDeclaration
:
public
WfDeclaration
,
vl
::
reflection
::
Description
<
WfPropertyDeclaration
> {
public
:
vl
::
Ptr
<
WfType
>
type
;
vl
::
parsing
::
ParsingToken
getter
;
vl
::
parsing
::
ParsingToken
setter
;
vl
::
parsing
::
ParsingToken
valueChangedEvent
;
void
Accept
(
WfDeclaration
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfPropertyDeclaration
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
enum
class
WfClassKind
{
Class
,
Interface
, };
enum
class
WfConstructorType
{
Undefined
,
SharedPtr
,
RawPtr
, };
class
WfBaseConstructorCall
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfBaseConstructorCall
> {
public
:
vl
::
Ptr
<
WfType
>
type
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfExpression
>>
arguments
;
static
vl
::
Ptr
<
WfBaseConstructorCall
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfConstructorDeclaration
:
public
WfDeclaration
,
vl
::
reflection
::
Description
<
WfConstructorDeclaration
> {
public
:
WfConstructorType
constructorType
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfBaseConstructorCall
>>
baseConstructorCalls
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfFunctionArgument
>>
arguments
;
vl
::
Ptr
<
WfStatement
>
statement
;
void
Accept
(
WfDeclaration
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfConstructorDeclaration
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfDestructorDeclaration
:
public
WfDeclaration
,
vl
::
reflection
::
Description
<
WfDestructorDeclaration
> {
public
:
vl
::
Ptr
<
WfStatement
>
statement
;
void
Accept
(
WfDeclaration
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfDestructorDeclaration
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfClassDeclaration
:
public
WfDeclaration
,
vl
::
reflection
::
Description
<
WfClassDeclaration
> {
public
:
WfClassKind
kind
;
WfConstructorType
constructorType
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfType
>>
baseTypes
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfDeclaration
>>
declarations
;
void
Accept
(
WfDeclaration
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfClassDeclaration
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
enum
class
WfEnumKind
{
Normal
,
Flag
, };
enum
class
WfEnumItemKind
{
Constant
,
Intersection
, };
class
WfEnumItemIntersection
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfEnumItemIntersection
> {
public
:
vl
::
parsing
::
ParsingToken
name
;
static
vl
::
Ptr
<
WfEnumItemIntersection
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfEnumItem
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfEnumItem
> {
public
:
vl
::
collections
::
List
<
vl
::
Ptr
<
WfAttribute
>>
attributes
;
vl
::
parsing
::
ParsingToken
name
;
WfEnumItemKind
kind
;
vl
::
parsing
::
ParsingToken
number
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfEnumItemIntersection
>>
intersections
;
static
vl
::
Ptr
<
WfEnumItem
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfEnumDeclaration
:
public
WfDeclaration
,
vl
::
reflection
::
Description
<
WfEnumDeclaration
> {
public
:
WfEnumKind
kind
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfEnumItem
>>
items
;
void
Accept
(
WfDeclaration
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfEnumDeclaration
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfStructMember
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfStructMember
> {
public
:
vl
::
collections
::
List
<
vl
::
Ptr
<
WfAttribute
>>
attributes
;
vl
::
parsing
::
ParsingToken
name
;
vl
::
Ptr
<
WfType
>
type
;
static
vl
::
Ptr
<
WfStructMember
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfStructDeclaration
:
public
WfDeclaration
,
vl
::
reflection
::
Description
<
WfStructDeclaration
> {
public
:
vl
::
collections
::
List
<
vl
::
Ptr
<
WfStructMember
>>
members
;
void
Accept
(
WfDeclaration
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfStructDeclaration
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfVirtualCfeDeclaration
abstract
:
public
WfDeclaration
,
vl
::
reflection
::
Description
<
WfVirtualCfeDeclaration
> {
public
:
class
IVisitor
:
public
vl
::
reflection
::
IDescriptable
,
vl
::
reflection
::
Description
<
IVisitor
> {
public
:
virtual
void
Visit
(
WfAutoPropertyDeclaration
*
node
)=
0
;
virtual
void
Visit
(
WfCastResultInterfaceDeclaration
*
node
)=
0
; };
virtual
void
Accept
(
WfVirtualCfeDeclaration
::
IVisitor
*
visitor
)=
0
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfDeclaration
>>
expandedDeclarations
;
void
Accept
(
WfDeclaration
::
IVisitor
*
visitor
)
override
; };
enum
class
WfAPConst
{
Readonly
,
Writable
, };
enum
class
WfAPObserve
{
Observable
,
NotObservable
, };
class
WfAutoPropertyDeclaration
:
public
WfVirtualCfeDeclaration
,
vl
::
reflection
::
Description
<
WfAutoPropertyDeclaration
> {
public
:
vl
::
Ptr
<
WfType
>
type
;
WfAPConst
configConst
;
WfAPObserve
configObserve
;
vl
::
Ptr
<
WfExpression
>
expression
;
void
Accept
(
WfVirtualCfeDeclaration
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfAutoPropertyDeclaration
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfCastResultInterfaceDeclaration
:
public
WfVirtualCfeDeclaration
,
vl
::
reflection
::
Description
<
WfCastResultInterfaceDeclaration
> {
public
:
vl
::
Ptr
<
WfType
>
baseType
;
vl
::
Ptr
<
WfType
>
elementType
;
void
Accept
(
WfVirtualCfeDeclaration
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfCastResultInterfaceDeclaration
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfVirtualCseDeclaration
abstract
:
public
WfDeclaration
,
vl
::
reflection
::
Description
<
WfVirtualCseDeclaration
> {
public
:
class
IVisitor
:
public
vl
::
reflection
::
IDescriptable
,
vl
::
reflection
::
Description
<
IVisitor
> {
public
:
virtual
void
Visit
(
WfStateMachineDeclaration
*
node
)=
0
; };
virtual
void
Accept
(
WfVirtualCseDeclaration
::
IVisitor
*
visitor
)=
0
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfDeclaration
>>
expandedDeclarations
;
void
Accept
(
WfDeclaration
::
IVisitor
*
visitor
)
override
; };
class
WfStateInput
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfStateInput
> {
public
:
vl
::
parsing
::
ParsingToken
name
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfFunctionArgument
>>
arguments
;
static
vl
::
Ptr
<
WfStateInput
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfStateDeclaration
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfStateDeclaration
> {
public
:
vl
::
parsing
::
ParsingToken
name
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfFunctionArgument
>>
arguments
;
vl
::
Ptr
<
WfStatement
>
statement
;
static
vl
::
Ptr
<
WfStateDeclaration
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfStateMachineDeclaration
:
public
WfVirtualCseDeclaration
,
vl
::
reflection
::
Description
<
WfStateMachineDeclaration
> {
public
:
vl
::
collections
::
List
<
vl
::
Ptr
<
WfStateInput
>>
inputs
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfStateDeclaration
>>
states
;
void
Accept
(
WfVirtualCseDeclaration
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfStateMachineDeclaration
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfBreakStatement
:
public
WfStatement
,
vl
::
reflection
::
Description
<
WfBreakStatement
> {
public
:
void
Accept
(
WfStatement
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfBreakStatement
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfContinueStatement
:
public
WfStatement
,
vl
::
reflection
::
Description
<
WfContinueStatement
> {
public
:
void
Accept
(
WfStatement
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfContinueStatement
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfReturnStatement
:
public
WfStatement
,
vl
::
reflection
::
Description
<
WfReturnStatement
> {
public
:
vl
::
Ptr
<
WfExpression
>
expression
;
void
Accept
(
WfStatement
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfReturnStatement
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfDeleteStatement
:
public
WfStatement
,
vl
::
reflection
::
Description
<
WfDeleteStatement
> {
public
:
vl
::
Ptr
<
WfExpression
>
expression
;
void
Accept
(
WfStatement
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfDeleteStatement
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfRaiseExceptionStatement
:
public
WfStatement
,
vl
::
reflection
::
Description
<
WfRaiseExceptionStatement
> {
public
:
vl
::
Ptr
<
WfExpression
>
expression
;
void
Accept
(
WfStatement
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfRaiseExceptionStatement
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfIfStatement
:
public
WfStatement
,
vl
::
reflection
::
Description
<
WfIfStatement
> {
public
:
vl
::
Ptr
<
WfType
>
type
;
vl
::
parsing
::
ParsingToken
name
;
vl
::
Ptr
<
WfExpression
>
expression
;
vl
::
Ptr
<
WfStatement
>
trueBranch
;
vl
::
Ptr
<
WfStatement
>
falseBranch
;
void
Accept
(
WfStatement
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfIfStatement
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfWhileStatement
:
public
WfStatement
,
vl
::
reflection
::
Description
<
WfWhileStatement
> {
public
:
vl
::
Ptr
<
WfExpression
>
condition
;
vl
::
Ptr
<
WfStatement
>
statement
;
void
Accept
(
WfStatement
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfWhileStatement
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfTryStatement
:
public
WfStatement
,
vl
::
reflection
::
Description
<
WfTryStatement
> {
public
:
vl
::
Ptr
<
WfStatement
>
protectedStatement
;
vl
::
parsing
::
ParsingToken
name
;
vl
::
Ptr
<
WfStatement
>
catchStatement
;
vl
::
Ptr
<
WfStatement
>
finallyStatement
;
void
Accept
(
WfStatement
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfTryStatement
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfBlockStatement
:
public
WfStatement
,
vl
::
reflection
::
Description
<
WfBlockStatement
> {
public
:
vl
::
collections
::
List
<
vl
::
Ptr
<
WfStatement
>>
statements
;
vl
::
parsing
::
ParsingToken
endLabel
;
void
Accept
(
WfStatement
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfBlockStatement
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfGotoStatement
:
public
WfStatement
,
vl
::
reflection
::
Description
<
WfGotoStatement
> {
public
:
vl
::
parsing
::
ParsingToken
label
;
void
Accept
(
WfStatement
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfGotoStatement
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfVariableStatement
:
public
WfStatement
,
vl
::
reflection
::
Description
<
WfVariableStatement
> {
public
:
vl
::
Ptr
<
WfVariableDeclaration
>
variable
;
void
Accept
(
WfStatement
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfVariableStatement
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfExpressionStatement
:
public
WfStatement
,
vl
::
reflection
::
Description
<
WfExpressionStatement
> {
public
:
vl
::
Ptr
<
WfExpression
>
expression
;
void
Accept
(
WfStatement
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfExpressionStatement
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfVirtualCseStatement
abstract
:
public
WfStatement
,
vl
::
reflection
::
Description
<
WfVirtualCseStatement
> {
public
:
class
IVisitor
:
public
vl
::
reflection
::
IDescriptable
,
vl
::
reflection
::
Description
<
IVisitor
> {
public
:
virtual
void
Visit
(
WfForEachStatement
*
node
)=
0
;
virtual
void
Visit
(
WfSwitchStatement
*
node
)=
0
;
virtual
void
Visit
(
WfCoProviderStatement
*
node
)=
0
; };
virtual
void
Accept
(
WfVirtualCseStatement
::
IVisitor
*
visitor
)=
0
;
vl
::
Ptr
<
WfStatement
>
expandedStatement
;
void
Accept
(
WfStatement
::
IVisitor
*
visitor
)
override
; };
enum
class
WfForEachDirection
{
Normal
,
Reversed
, };
class
WfForEachStatement
:
public
WfVirtualCseStatement
,
vl
::
reflection
::
Description
<
WfForEachStatement
> {
public
:
vl
::
parsing
::
ParsingToken
name
;
WfForEachDirection
direction
;
vl
::
Ptr
<
WfExpression
>
collection
;
vl
::
Ptr
<
WfStatement
>
statement
;
void
Accept
(
WfVirtualCseStatement
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfForEachStatement
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfSwitchCase
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfSwitchCase
> {
public
:
vl
::
Ptr
<
WfExpression
>
expression
;
vl
::
Ptr
<
WfStatement
>
statement
;
static
vl
::
Ptr
<
WfSwitchCase
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfSwitchStatement
:
public
WfVirtualCseStatement
,
vl
::
reflection
::
Description
<
WfSwitchStatement
> {
public
:
vl
::
Ptr
<
WfExpression
>
expression
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfSwitchCase
>>
caseBranches
;
vl
::
Ptr
<
WfStatement
>
defaultBranch
;
void
Accept
(
WfVirtualCseStatement
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfSwitchStatement
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfCoProviderStatement
:
public
WfVirtualCseStatement
,
vl
::
reflection
::
Description
<
WfCoProviderStatement
> {
public
:
vl
::
parsing
::
ParsingToken
name
;
vl
::
Ptr
<
WfStatement
>
statement
;
void
Accept
(
WfVirtualCseStatement
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfCoProviderStatement
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfCoroutineStatement
abstract
:
public
WfStatement
,
vl
::
reflection
::
Description
<
WfCoroutineStatement
> {
public
:
class
IVisitor
:
public
vl
::
reflection
::
IDescriptable
,
vl
::
reflection
::
Description
<
IVisitor
> {
public
:
virtual
void
Visit
(
WfCoPauseStatement
*
node
)=
0
;
virtual
void
Visit
(
WfCoOperatorStatement
*
node
)=
0
; };
virtual
void
Accept
(
WfCoroutineStatement
::
IVisitor
*
visitor
)=
0
;
void
Accept
(
WfStatement
::
IVisitor
*
visitor
)
override
; };
class
WfCoPauseStatement
:
public
WfCoroutineStatement
,
vl
::
reflection
::
Description
<
WfCoPauseStatement
> {
public
:
vl
::
Ptr
<
WfStatement
>
statement
;
void
Accept
(
WfCoroutineStatement
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfCoPauseStatement
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfCoOperatorStatement
:
public
WfCoroutineStatement
,
vl
::
reflection
::
Description
<
WfCoOperatorStatement
> {
public
:
vl
::
parsing
::
ParsingToken
varName
;
vl
::
parsing
::
ParsingToken
opName
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfExpression
>>
arguments
;
void
Accept
(
WfCoroutineStatement
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfCoOperatorStatement
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
enum
class
WfStateSwitchType
{
Default
,
Pass
,
PassAndReturn
,
Ignore
,
IgnoreAndReturn
, };
enum
class
WfStateInvokeType
{
Goto
,
Push
, };
class
WfStateMachineStatement
abstract
:
public
WfStatement
,
vl
::
reflection
::
Description
<
WfStateMachineStatement
> {
public
:
class
IVisitor
:
public
vl
::
reflection
::
IDescriptable
,
vl
::
reflection
::
Description
<
IVisitor
> {
public
:
virtual
void
Visit
(
WfStateSwitchStatement
*
node
)=
0
;
virtual
void
Visit
(
WfStateInvokeStatement
*
node
)=
0
; };
virtual
void
Accept
(
WfStateMachineStatement
::
IVisitor
*
visitor
)=
0
;
void
Accept
(
WfStatement
::
IVisitor
*
visitor
)
override
; };
class
WfStateSwitchArgument
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfStateSwitchArgument
> {
public
:
vl
::
parsing
::
ParsingToken
name
;
static
vl
::
Ptr
<
WfStateSwitchArgument
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfStateSwitchCase
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfStateSwitchCase
> {
public
:
vl
::
parsing
::
ParsingToken
name
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfStateSwitchArgument
>>
arguments
;
vl
::
Ptr
<
WfStatement
>
statement
;
static
vl
::
Ptr
<
WfStateSwitchCase
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfStateSwitchStatement
:
public
WfStateMachineStatement
,
vl
::
reflection
::
Description
<
WfStateSwitchStatement
> {
public
:
WfStateSwitchType
type
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfStateSwitchCase
>>
caseBranches
;
void
Accept
(
WfStateMachineStatement
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfStateSwitchStatement
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfStateInvokeStatement
:
public
WfStateMachineStatement
,
vl
::
reflection
::
Description
<
WfStateInvokeStatement
> {
public
:
WfStateInvokeType
type
;
vl
::
parsing
::
ParsingToken
name
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfExpression
>>
arguments
;
void
Accept
(
WfStateMachineStatement
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfStateInvokeStatement
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfThisExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfThisExpression
> {
public
:
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfThisExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfTopQualifiedExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfTopQualifiedExpression
> {
public
:
vl
::
parsing
::
ParsingToken
name
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfTopQualifiedExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfReferenceExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfReferenceExpression
> {
public
:
vl
::
parsing
::
ParsingToken
name
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfReferenceExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfOrderedNameExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfOrderedNameExpression
> {
public
:
vl
::
parsing
::
ParsingToken
name
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfOrderedNameExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfOrderedLambdaExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfOrderedLambdaExpression
> {
public
:
vl
::
Ptr
<
WfExpression
>
body
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfOrderedLambdaExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfMemberExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfMemberExpression
> {
public
:
vl
::
Ptr
<
WfExpression
>
parent
;
vl
::
parsing
::
ParsingToken
name
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfMemberExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfChildExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfChildExpression
> {
public
:
vl
::
Ptr
<
WfExpression
>
parent
;
vl
::
parsing
::
ParsingToken
name
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfChildExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
enum
class
WfLiteralValue
{
Null
,
True
,
False
, };
class
WfLiteralExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfLiteralExpression
> {
public
:
WfLiteralValue
value
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfLiteralExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfFloatingExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfFloatingExpression
> {
public
:
vl
::
parsing
::
ParsingToken
value
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfFloatingExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfIntegerExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfIntegerExpression
> {
public
:
vl
::
parsing
::
ParsingToken
value
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfIntegerExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfStringExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfStringExpression
> {
public
:
vl
::
parsing
::
ParsingToken
value
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfStringExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
enum
class
WfUnaryOperator
{
Positive
,
Negative
,
Not
, };
class
WfUnaryExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfUnaryExpression
> {
public
:
WfUnaryOperator
op
;
vl
::
Ptr
<
WfExpression
>
operand
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfUnaryExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
enum
class
WfBinaryOperator
{
Assign
,
Index
,
FlagAnd
,
FlagOr
,
FailedThen
,
Exp
,
Add
,
Sub
,
Mul
,
Div
,
Mod
,
Shl
,
Shr
,
LT
,
GT
,
LE
,
GE
,
EQ
,
NE
,
Xor
,
And
,
Or
, };
class
WfBinaryExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfBinaryExpression
> {
public
:
WfBinaryOperator
op
;
vl
::
Ptr
<
WfExpression
>
first
;
vl
::
Ptr
<
WfExpression
>
second
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfBinaryExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfLetVariable
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfLetVariable
> {
public
:
vl
::
parsing
::
ParsingToken
name
;
vl
::
Ptr
<
WfExpression
>
value
;
static
vl
::
Ptr
<
WfLetVariable
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfLetExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfLetExpression
> {
public
:
vl
::
collections
::
List
<
vl
::
Ptr
<
WfLetVariable
>>
variables
;
vl
::
Ptr
<
WfExpression
>
expression
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfLetExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfIfExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfIfExpression
> {
public
:
vl
::
Ptr
<
WfExpression
>
condition
;
vl
::
Ptr
<
WfExpression
>
trueBranch
;
vl
::
Ptr
<
WfExpression
>
falseBranch
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfIfExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
enum
class
WfRangeBoundary
{
Inclusive
,
Exclusive
, };
class
WfRangeExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfRangeExpression
> {
public
:
vl
::
Ptr
<
WfExpression
>
begin
;
WfRangeBoundary
beginBoundary
;
vl
::
Ptr
<
WfExpression
>
end
;
WfRangeBoundary
endBoundary
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfRangeExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
enum
class
WfSetTesting
{
In
,
NotIn
, };
class
WfSetTestingExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfSetTestingExpression
> {
public
:
WfSetTesting
test
;
vl
::
Ptr
<
WfExpression
>
element
;
vl
::
Ptr
<
WfExpression
>
collection
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfSetTestingExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfConstructorArgument
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfConstructorArgument
> {
public
:
vl
::
Ptr
<
WfExpression
>
key
;
vl
::
Ptr
<
WfExpression
>
value
;
static
vl
::
Ptr
<
WfConstructorArgument
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfConstructorExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfConstructorExpression
> {
public
:
vl
::
collections
::
List
<
vl
::
Ptr
<
WfConstructorArgument
>>
arguments
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfConstructorExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfInferExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfInferExpression
> {
public
:
vl
::
Ptr
<
WfExpression
>
expression
;
vl
::
Ptr
<
WfType
>
type
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfInferExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
enum
class
WfTypeCastingStrategy
{
Strong
,
Weak
, };
class
WfTypeCastingExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfTypeCastingExpression
> {
public
:
WfTypeCastingStrategy
strategy
;
vl
::
Ptr
<
WfExpression
>
expression
;
vl
::
Ptr
<
WfType
>
type
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfTypeCastingExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
enum
class
WfTypeTesting
{
IsType
,
IsNotType
,
IsNull
,
IsNotNull
, };
class
WfTypeTestingExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfTypeTestingExpression
> {
public
:
WfTypeTesting
test
;
vl
::
Ptr
<
WfExpression
>
expression
;
vl
::
Ptr
<
WfType
>
type
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfTypeTestingExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfTypeOfTypeExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfTypeOfTypeExpression
> {
public
:
vl
::
Ptr
<
WfType
>
type
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfTypeOfTypeExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfTypeOfExpressionExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfTypeOfExpressionExpression
> {
public
:
vl
::
Ptr
<
WfExpression
>
expression
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfTypeOfExpressionExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfAttachEventExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfAttachEventExpression
> {
public
:
vl
::
Ptr
<
WfExpression
>
event
;
vl
::
Ptr
<
WfExpression
>
function
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfAttachEventExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfDetachEventExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfDetachEventExpression
> {
public
:
vl
::
Ptr
<
WfExpression
>
event
;
vl
::
Ptr
<
WfExpression
>
handler
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfDetachEventExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
enum
class
WfObserveType
{
SimpleObserve
,
ExtendedObserve
, };
class
WfObserveExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfObserveExpression
> {
public
:
vl
::
Ptr
<
WfExpression
>
parent
;
WfObserveType
observeType
;
vl
::
parsing
::
ParsingToken
name
;
vl
::
Ptr
<
WfExpression
>
expression
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfExpression
>>
events
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfObserveExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfCallExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfCallExpression
> {
public
:
vl
::
Ptr
<
WfExpression
>
function
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfExpression
>>
arguments
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfCallExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfFunctionExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfFunctionExpression
> {
public
:
vl
::
Ptr
<
WfFunctionDeclaration
>
function
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfFunctionExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfNewClassExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfNewClassExpression
> {
public
:
vl
::
Ptr
<
WfType
>
type
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfExpression
>>
arguments
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfNewClassExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfNewInterfaceExpression
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfNewInterfaceExpression
> {
public
:
vl
::
Ptr
<
WfType
>
type
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfDeclaration
>>
declarations
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfNewInterfaceExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfVirtualCfeExpression
abstract
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfVirtualCfeExpression
> {
public
:
class
IVisitor
:
public
vl
::
reflection
::
IDescriptable
,
vl
::
reflection
::
Description
<
IVisitor
> {
public
:
virtual
void
Visit
(
WfFormatExpression
*
node
)=
0
; };
virtual
void
Accept
(
WfVirtualCfeExpression
::
IVisitor
*
visitor
)=
0
;
vl
::
Ptr
<
WfExpression
>
expandedExpression
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
; };
class
WfFormatExpression
:
public
WfVirtualCfeExpression
,
vl
::
reflection
::
Description
<
WfFormatExpression
> {
public
:
vl
::
parsing
::
ParsingToken
value
;
void
Accept
(
WfVirtualCfeExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfFormatExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfVirtualCseExpression
abstract
:
public
WfExpression
,
vl
::
reflection
::
Description
<
WfVirtualCseExpression
> {
public
:
class
IVisitor
:
public
vl
::
reflection
::
IDescriptable
,
vl
::
reflection
::
Description
<
IVisitor
> {
public
:
virtual
void
Visit
(
WfBindExpression
*
node
)=
0
;
virtual
void
Visit
(
WfNewCoroutineExpression
*
node
)=
0
;
virtual
void
Visit
(
WfMixinCastExpression
*
node
)=
0
;
virtual
void
Visit
(
WfExpectedTypeCastExpression
*
node
)=
0
;
virtual
void
Visit
(
WfCoOperatorExpression
*
node
)=
0
; };
virtual
void
Accept
(
WfVirtualCseExpression
::
IVisitor
*
visitor
)=
0
;
vl
::
Ptr
<
WfExpression
>
expandedExpression
;
void
Accept
(
WfExpression
::
IVisitor
*
visitor
)
override
; };
class
WfBindExpression
:
public
WfVirtualCseExpression
,
vl
::
reflection
::
Description
<
WfBindExpression
> {
public
:
vl
::
Ptr
<
WfExpression
>
expression
;
void
Accept
(
WfVirtualCseExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfBindExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfNewCoroutineExpression
:
public
WfVirtualCseExpression
,
vl
::
reflection
::
Description
<
WfNewCoroutineExpression
> {
public
:
vl
::
parsing
::
ParsingToken
name
;
vl
::
Ptr
<
WfStatement
>
statement
;
void
Accept
(
WfVirtualCseExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfNewCoroutineExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfMixinCastExpression
:
public
WfVirtualCseExpression
,
vl
::
reflection
::
Description
<
WfMixinCastExpression
> {
public
:
vl
::
Ptr
<
WfType
>
type
;
vl
::
Ptr
<
WfExpression
>
expression
;
void
Accept
(
WfVirtualCseExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfMixinCastExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfExpectedTypeCastExpression
:
public
WfVirtualCseExpression
,
vl
::
reflection
::
Description
<
WfExpectedTypeCastExpression
> {
public
:
WfTypeCastingStrategy
strategy
;
vl
::
Ptr
<
WfExpression
>
expression
;
void
Accept
(
WfVirtualCseExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfExpectedTypeCastExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfCoOperatorExpression
:
public
WfVirtualCseExpression
,
vl
::
reflection
::
Description
<
WfCoOperatorExpression
> {
public
:
vl
::
parsing
::
ParsingToken
name
;
void
Accept
(
WfVirtualCseExpression
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfCoOperatorExpression
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfModuleUsingFragment
abstract
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfModuleUsingFragment
> {
public
:
class
IVisitor
:
public
vl
::
reflection
::
IDescriptable
,
vl
::
reflection
::
Description
<
IVisitor
> {
public
:
virtual
void
Visit
(
WfModuleUsingNameFragment
*
node
)=
0
;
virtual
void
Visit
(
WfModuleUsingWildCardFragment
*
node
)=
0
; };
virtual
void
Accept
(
WfModuleUsingFragment
::
IVisitor
*
visitor
)=
0
; };
class
WfModuleUsingNameFragment
:
public
WfModuleUsingFragment
,
vl
::
reflection
::
Description
<
WfModuleUsingNameFragment
> {
public
:
vl
::
parsing
::
ParsingToken
name
;
void
Accept
(
WfModuleUsingFragment
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfModuleUsingNameFragment
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfModuleUsingWildCardFragment
:
public
WfModuleUsingFragment
,
vl
::
reflection
::
Description
<
WfModuleUsingWildCardFragment
> {
public
:
void
Accept
(
WfModuleUsingFragment
::
IVisitor
*
visitor
)
override
;
static
vl
::
Ptr
<
WfModuleUsingWildCardFragment
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfModuleUsingItem
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfModuleUsingItem
> {
public
:
vl
::
collections
::
List
<
vl
::
Ptr
<
WfModuleUsingFragment
>>
fragments
;
static
vl
::
Ptr
<
WfModuleUsingItem
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
class
WfModuleUsingPath
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfModuleUsingPath
> {
public
:
vl
::
collections
::
List
<
vl
::
Ptr
<
WfModuleUsingItem
>>
items
;
static
vl
::
Ptr
<
WfModuleUsingPath
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); };
enum
class
WfModuleType
{
Module
,
Unit
, };
class
WfModule
:
public
vl
::
parsing
::
ParsingTreeCustomBase
,
vl
::
reflection
::
Description
<
WfModule
> {
public
:
WfModuleType
moduleType
;
vl
::
parsing
::
ParsingToken
name
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfModuleUsingPath
>>
paths
;
vl
::
collections
::
List
<
vl
::
Ptr
<
WfDeclaration
>>
declarations
;
static
vl
::
Ptr
<
WfModule
>
Convert
(
vl
::
Ptr
<
vl
::
parsing
::
ParsingTreeNode
>
node
,
const
vl
::
collections
::
List
<
vl
::
regex
::
RegexToken
>&
tokens
); }; } }
namespace
vl
{
namespace
reflection
{
namespace
description
{
#ifndef VCZH_DEBUG_NO_REFLECTION
#ifdef VCZH_DESCRIPTABLEOBJECT_WITH_METADATA
void
Visit
(
vl
::
workflow
::
WfPredefinedType
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfTopQualifiedType
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfReferenceType
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfRawPointerType
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfSharedPointerType
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfNullableType
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfEnumerableType
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfMapType
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfObservableListType
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfFunctionType
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfChildType
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfThisExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfTopQualifiedExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfReferenceExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfOrderedNameExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfOrderedLambdaExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfMemberExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfChildExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfLiteralExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfFloatingExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfIntegerExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfStringExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfUnaryExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfBinaryExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfLetExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfIfExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfRangeExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfSetTestingExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfConstructorExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfInferExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfTypeCastingExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfTypeTestingExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfTypeOfTypeExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfTypeOfExpressionExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfAttachEventExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfDetachEventExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfObserveExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfCallExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfFunctionExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfNewClassExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfNewInterfaceExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfVirtualCfeExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfVirtualCseExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfBreakStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfContinueStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfReturnStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfDeleteStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfRaiseExceptionStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfIfStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfWhileStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfTryStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfBlockStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfGotoStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfVariableStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfExpressionStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfVirtualCseStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfCoroutineStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfStateMachineStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfNamespaceDeclaration
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfFunctionDeclaration
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfVariableDeclaration
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfEventDeclaration
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfPropertyDeclaration
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfConstructorDeclaration
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfDestructorDeclaration
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfClassDeclaration
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfEnumDeclaration
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfStructDeclaration
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfVirtualCfeDeclaration
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfVirtualCseDeclaration
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfAutoPropertyDeclaration
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfCastResultInterfaceDeclaration
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfStateMachineDeclaration
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfForEachStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfSwitchStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfCoProviderStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfCoPauseStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfCoOperatorStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfStateSwitchStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfStateInvokeStatement
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfFormatExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfBindExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfNewCoroutineExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfMixinCastExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfExpectedTypeCastExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfCoOperatorExpression
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfModuleUsingNameFragment
*
node
)
override
{ }
void
Visit
(
vl
::
workflow
::
WfModuleUsingWildCardFragment
*
node
)
override
{ }
#endif #endif
/// <summary>Load all reflectable AST types, only available when <b>VCZH_DEBUG_NO_REFLECTION</b> is off.</summary>
/// <returns>Returns true if this operation succeeded.</returns>
extern
bool
WfLoadTypes
(); } } }
#endif