WfAnalyzer_CompleteScope.cpp

#include "WfAnalyzer.h"

namespace

{

namespace

workflow

{

namespace

analyzer

{

using

namespace

collections

;

using

namespace

parsing

;

using

namespace

reflection

;

using

namespace

reflection

description

;

using

namespace

typeimpl

;

/*********************************************************************** CompleteScopeForClassMember ***********************************************************************/

class

CompleteScopeForClassMemberVisitor

public

Object

public

WfDeclaration

IVisitor

public

WfVirtualCseDeclaration

IVisitor

{

public

WfLexicalScopeManager

manager

;

Ptr

WfCustomType

;

Ptr

WfClassDeclaration

classDecl

;

CompleteScopeForClassMemberVisitor

(

WfLexicalScopeManager

_manager

Ptr

WfCustomType

_td

Ptr

WfClassDeclaration

_classDecl

) :manager(

_manager

) , td(

_td

) { }

void

Visit

(

WfNamespaceDeclaration

node

)

override

{ }

void

Visit

(

WfFunctionDeclaration

node

)

override

{

auto

scope

manager

nodeScopes

[

node

];

auto

info

manager

declarationMemberInfos

[

node

Cast

WfMethodBase

>();

FOREACH(Ptr<WfFunctionArgument>, argument, node->arguments)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfFunctionArgument

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

arguments

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfFunctionArgument

argument

;

__foreach_iterator__

(

argument

);)

{

(

auto

typeInfo

CreateTypeInfoFromType

(

scope

Obj

(),

argument

type

)) {

auto

paramInfo

MakePtr

ParameterInfoImpl

info

Obj

(),

argument

name

value

typeInfo

);

info

AddParameter

(

paramInfo

); } }

(

auto

typeInfo

CreateTypeInfoFromType

(

scope

Obj

(),

node

returnType

)) {

info

SetReturn

(

typeInfo

); } }

void

Visit

(

WfVariableDeclaration

node

)

override

{

auto

scope

manager

nodeScopes

[

node

];

(

auto

typeInfo

CreateTypeInfoFromType

(

scope

Obj

(),

node

type

)) {

auto

info

manager

declarationMemberInfos

[

node

Cast

WfField

>();

info

SetReturn

(

typeInfo

); } }

void

Visit

(

WfEventDeclaration

node

)

override

{

auto

scope

manager

nodeScopes

[

node

];

auto

type

MakePtr

WfFunctionType

>(); {

auto

voidType

MakePtr

WfPredefinedType

>();

voidType

name

WfPredefinedTypeName

Void

;

type

result

voidType

; }

FOREACH(Ptr<WfType>, argument, node->arguments)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfType

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

arguments

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfType

argument

;

__foreach_iterator__

(

argument

);)

{

type

arguments

Add

(

argument

); }

(

auto

typeInfo

CreateTypeInfoFromType

(

scope

Obj

(),

type

)) {

auto

info

manager

declarationMemberInfos

[

node

Cast

WfEvent

>();

info

SetHandlerType

(

typeInfo

); } }

void

Visit

(

WfPropertyDeclaration

node

)

override

{

auto

scope

manager

nodeScopes

[

node

];

auto

info

manager

declarationMemberInfos

[

node

Cast

WfProperty

>();

(

node

getter

value

L""

) {

info

SetGetter

(

dynamic_cast

MethodInfoImpl

*>(

GetMethodGroupByName

(

node

getter

value

false

)->

GetMethod

(

))); }

(

node

setter

value

L""

) {

info

SetSetter

(

dynamic_cast

MethodInfoImpl

*>(

GetMethodGroupByName

(

node

setter

value

false

)->

GetMethod

(

))); }

(

node

valueChangedEvent

value

L""

) {

info

SetValueChangedEvent

(

dynamic_cast

EventInfoImpl

*>(

GetEventByName

(

node

valueChangedEvent

value

false

))); } }

void

Visit

(

WfConstructorDeclaration

node

)

override

{

auto

scope

manager

nodeScopes

[

node

];

auto

info

manager

declarationMemberInfos

[

node

Cast

WfClassConstructor

>();

FOREACH(Ptr<WfFunctionArgument>, argument, node->arguments)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfFunctionArgument

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

arguments

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfFunctionArgument

argument

;

__foreach_iterator__

(

argument

);)

{

(

auto

typeInfo

CreateTypeInfoFromType

(

scope

Obj

(),

argument

type

)) {

auto

paramInfo

MakePtr

ParameterInfoImpl

info

Obj

(),

argument

name

value

typeInfo

);

info

AddParameter

(

paramInfo

); } } }

void

Visit

(

WfDestructorDeclaration

node

)

override

{ }

void

Visit

(

WfClassDeclaration

node

)

override

{

CompleteScopeForDeclaration

(

manager

node

); }

void

Visit

(

WfEnumDeclaration

node

)

override

{

CompleteScopeForDeclaration

(

manager

node

); }

void

Visit

(

WfStructDeclaration

node

)

override

{

CompleteScopeForDeclaration

(

manager

node

); }

void

Visit

(

WfVirtualCfeDeclaration

node

)

override

{

FOREACH(Ptr<WfDeclaration>, decl, node->expandedDeclarations)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

expandedDeclarations

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfDeclaration

decl

;

__foreach_iterator__

(

decl

);)

{

decl

(

this

); } }

void

Visit

(

WfVirtualCseDeclaration

node

)

override

{

node

((

WfVirtualCseDeclaration

IVisitor

this

); }

void

Visit

(

WfStateMachineDeclaration

node

)

override

{

auto

scope

manager

nodeScopes

[

node

];

FOREACH(Ptr<WfStateInput>, input, node->inputs)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfStateInput

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

inputs

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfStateInput

input

;

__foreach_iterator__

(

input

);)

{

auto

method

manager

stateInputMethods

[

input

Obj

()];

method

SetReturn

(

TypeInfoRetriver

void

>::

CreateTypeInfo

());

FOREACH(Ptr<WfFunctionArgument>, argument, input->arguments)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfFunctionArgument

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

input

arguments

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfFunctionArgument

argument

;

__foreach_iterator__

(

argument

);)

{

(

auto

typeInfo

CreateTypeInfoFromType

(

scope

Obj

(),

argument

type

)) {

auto

field

manager

stateInputArguments

[

argument

Obj

()];

field

SetReturn

(

typeInfo

);

method

AddParameter

(

MakePtr

ParameterInfoImpl

method

Obj

(),

argument

name

value

typeInfo

)); } } }

FOREACH(Ptr<WfStateDeclaration>, state, node->states)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfStateDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

states

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfStateDeclaration

state

;

__foreach_iterator__

(

state

);)

{

FOREACH(Ptr<WfFunctionArgument>, argument, state->arguments)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfFunctionArgument

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

state

arguments

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfFunctionArgument

argument

;

__foreach_iterator__

(

argument

);)

{

(

auto

typeInfo

CreateTypeInfoFromType

(

scope

Obj

(),

argument

type

)) {

auto

field

manager

stateDeclArguments

[

argument

Obj

()];

field

SetReturn

(

typeInfo

); } } }

auto

smInfo

manager

stateMachineInfos

[

node

];

smInfo

createCoroutineMethod

AddParameter

(

MakePtr

ParameterInfoImpl

smInfo

createCoroutineMethod

Obj

(),

L"<state>startState"

TypeInfoRetriver

vint

>::

CreateTypeInfo

()));

smInfo

createCoroutineMethod

SetReturn

(

TypeInfoRetriver

void

>::

CreateTypeInfo

()); }

static

void

Execute

(

WfLexicalScopeManager

manager

Ptr

WfCustomType

Ptr

WfClassDeclaration

classDecl

Ptr

WfDeclaration

memberDecl

) {

CompleteScopeForClassMemberVisitor

visitor

(

manager

classDecl

);

memberDecl

visitor

); } };

/*********************************************************************** CompleteScopeForDeclaration ***********************************************************************/

class

CompleteScopeForDeclarationVisitor

public

Object

public

WfDeclaration

IVisitor

public

WfVirtualCseDeclaration

IVisitor

{

public

WfLexicalScopeManager

manager

;

Ptr

WfDeclaration

declaration

;

CompleteScopeForDeclarationVisitor

(

WfLexicalScopeManager

_manager

Ptr

WfDeclaration

_declaration

) :manager(

_manager

) , declaration(

_declaration

) { }

void

Visit

(

WfNamespaceDeclaration

node

)

override

{

FOREACH(Ptr<WfDeclaration>, decl, node->declarations)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

declarations

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfDeclaration

decl

;

__foreach_iterator__

(

decl

);)

{

CompleteScopeForDeclaration

(

manager

decl

); } }

void

Visit

(

WfFunctionDeclaration

node

)

override

{ }

void

Visit

(

WfVariableDeclaration

node

)

override

{ }

void

Visit

(

WfEventDeclaration

node

)

override

{ }

void

Visit

(

WfPropertyDeclaration

node

)

override

{ }

void

Visit

(

WfConstructorDeclaration

node

)

override

{ }

void

Visit

(

WfDestructorDeclaration

node

)

override

{ }

void

Visit

(

WfClassDeclaration

node

)

override

{

auto

scope

manager

nodeScopes

[

node

];

auto

manager

declarationTypes

[

node

Cast

WfCustomType

>();

(

node

baseTypes

Count

() >

) {

FOREACH(Ptr<WfType>, baseType, node->baseTypes)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfType

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

baseTypes

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfType

baseType

;

__foreach_iterator__

(

baseType

);)

{

(

auto

scopeName

GetScopeNameFromReferenceType

(

scope

parentScope

Obj

(),

baseType

)) {

(

scopeName

typeDescriptor

) {

AddBaseType

(

scopeName

typeDescriptor

); } } } }

else

(

node

kind

WfClassKind

Class

) {

AddBaseType

(

description

GetTypeDescriptor

DescriptableObject

>()); }

else

(

node

kind

WfClassKind

Interface

) {

AddBaseType

(

description

GetTypeDescriptor

IDescriptable

>()); }

(

node

kind

WfClassKind

Interface

) {

switch

(

node

constructorType

) {

case

WfConstructorType

SharedPtr

: {

auto

elementType

MakePtr

TypeDescriptorTypeInfo

Obj

(),

TypeInfoHint

Normal

);

auto

pointerType

MakePtr

SharedPtrTypeInfo

elementType

);

auto

ctor

MakePtr

WfInterfaceConstructor

pointerType

);

AddMember

(

ctor

); }

break

;

case

WfConstructorType

RawPtr

: {

auto

elementType

MakePtr

TypeDescriptorTypeInfo

Obj

(),

TypeInfoHint

Normal

);

auto

pointerType

MakePtr

RawPtrTypeInfo

elementType

);

auto

ctor

MakePtr

WfInterfaceConstructor

pointerType

);

AddMember

(

ctor

); }

break

;

default

:; } }

FOREACH(Ptr<WfDeclaration>, memberDecl, node->declarations)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

declarations

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfDeclaration

memberDecl

;

__foreach_iterator__

(

memberDecl

);)

{

CompleteScopeForClassMember

(

manager

node

memberDecl

); } }

void

Visit

(

WfEnumDeclaration

node

)

override

{

auto

manager

declarationTypes

[

node

Cast

WfEnum

>();

Dictionary

WString

vuint64_t

items

;

FOREACH(Ptr<WfEnumItem>, item, node->items)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfEnumItem

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

items

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfEnumItem

item

;

__foreach_iterator__

(

item

);)

{

vuint64_t

value

;

switch

(

item

kind

) {

case

WfEnumItemKind

Constant

TypedValueSerializerProvider

vuint64_t

>::

Deserialize

(

item

number

value

);

break

;

case

WfEnumItemKind

Intersection

FOREACH(Ptr<WfEnumItemIntersection>, itemInt, item->intersections)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfEnumItemIntersection

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

item

intersections

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfEnumItemIntersection

itemInt

;

__foreach_iterator__

(

itemInt

);)

{

value

items

[

itemInt

name

value

]; }

break

; }

AddEnumItem

(

item

name

value

);

items

Add

(

item

name

value

); } }

void

Visit

(

WfStructDeclaration

node

)

override

{

auto

scope

manager

nodeScopes

[

node

];

auto

manager

declarationTypes

[

node

Cast

WfStruct

>();

FOREACH(Ptr<WfStructMember>, member, node->members)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfStructMember

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

members

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfStructMember

member

;

__foreach_iterator__

(

member

);)

{

(

auto

typeInfo

CreateTypeInfoFromType

(

scope

Obj

(),

member

type

)) {

auto

field

MakePtr

WfStructField

Obj

(),

member

name

value

);

field

SetReturn

(

typeInfo

);

AddMember

(

field

); } } }

void

Visit

(

WfVirtualCfeDeclaration

node

)

override

{

FOREACH(Ptr<WfDeclaration>, decl, node->expandedDeclarations)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

expandedDeclarations

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfDeclaration

decl

;

__foreach_iterator__

(

decl

);)

{

decl

(

this

); } }

void

Visit

(

WfVirtualCseDeclaration

node

)

override

{

node

((

WfVirtualCseDeclaration

IVisitor

this

);

FOREACH(Ptr<WfDeclaration>, decl, node->expandedDeclarations)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

expandedDeclarations

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfDeclaration

decl

;

__foreach_iterator__

(

decl

);)

{

decl

(

this

); } }

void

Visit

(

WfStateMachineDeclaration

node

)

override

{ }

static

void

Execute

(

WfLexicalScopeManager

manager

Ptr

WfDeclaration

declaration

) {

CompleteScopeForDeclarationVisitor

visitor

(

manager

declaration

);

declaration

visitor

); } };

/*********************************************************************** CompleteScope ***********************************************************************/

void

CompleteScopeForClassMember

(

WfLexicalScopeManager

manager

Ptr

WfCustomType

Ptr

WfClassDeclaration

classDecl

Ptr

WfDeclaration

memberDecl

) {

CompleteScopeForClassMemberVisitor

Execute

(

manager

classDecl

memberDecl

); }

void

CompleteScopeForDeclaration

(

WfLexicalScopeManager

manager

Ptr

WfDeclaration

declaration

) {

CompleteScopeForDeclarationVisitor

Execute

(

manager

declaration

); }

void

CompleteScopeForModule

(

WfLexicalScopeManager

manager

Ptr

WfModule

module

) {

FOREACH(Ptr<WfDeclaration>, declaration, module->declarations)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

module

declarations

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfDeclaration

declaration

;

__foreach_iterator__

(

declaration

);)

{

CompleteScopeForDeclaration

(

manager

declaration

); } } } } }