WfCpp_Class.cpp

#include "WfCpp.h"

namespace

{

namespace

workflow

{

namespace

cppcodegen

{

using

namespace

collections

;

using

namespace

reflection

;

using

namespace

reflection

description

;

using

namespace

analyzer

;

bool

IsVirtual

(

WfCppConfig

config

WfFunctionDeclaration

node

) {

vint

index

config

manager

declarationMemberInfos

Keys

().

IndexOf

(

node

);

(

index

!= -

) {

auto

methodInfo

dynamic_cast

IMethodInfo

*>(

config

manager

declarationMemberInfos

Values

()

[

index

Obj

());

(

methodInfo

IsStatic

()) {

return

false

; }

auto

methodInfo

GetOwnerTypeDescriptor

();

return

GetTypeDescriptorFlags

() ==

TypeDescriptorFlags

Interface

; }

return

false

; }

/*********************************************************************** WfGenerateClassMemberDeclVisitor ***********************************************************************/

class

WfGenerateClassMemberDeclVisitor

public

Object

public

WfDeclaration

IVisitor

{

public

WfCppConfig

config

;

stream

StreamWriter

writer

;

WString

className

;

WString

prefix

;

bool

forClassExpr

;

WfGenerateClassMemberDeclVisitor

(

WfCppConfig

_config

stream

StreamWriter

_writer

const

WString

_className

const

WString

_prefix

bool

_forClassExpr

) :config(

_config

) , writer(

_writer

) , className(

_className

) , prefix(

_prefix

) , forClassExpr(

_forClassExpr

) { }

void

Visit

(

WfNamespaceDeclaration

node

)

override

{ }

void

Visit

(

WfFunctionDeclaration

node

)

override

{

bool

isVirtual

IsVirtual

(

config

node

);

writer

WriteString

(

prefix

);

(

isVirtual

) {

writer

WriteString

(

L"virtual "

); }

else

(

node

classMember

kind

WfClassMemberKind

Static

) {

writer

WriteString

(

L"static "

); }

config

WriteFunctionHeader

(

writer

node

config

ConvertName

(

node

name

value

true

);

(

isVirtual

) {

writer

WriteString

(

L" = 0"

); }

else

(

node

classMember

kind

WfClassMemberKind

Override

) {

writer

WriteString

(

L" override"

); }

writer

WriteLine

(

L";"

); }

void

Visit

(

WfVariableDeclaration

node

)

override

{

auto

scope

config

manager

nodeScopes

[

node

Obj

();

auto

symbol

scope

symbols

[

node

name

value

]

[

];

auto

typeInfo

symbol

typeInfo

;

writer

WriteString

(

prefix

config

ConvertType

(

typeInfo

Obj

()) +

L" "

config

ConvertName

(

node

name

value

));

(

forClassExpr

) {

auto

defaultValue

config

DefaultValue

(

typeInfo

Obj

());

(

defaultValue

L""

) {

writer

WriteString

(

L" = "

);

writer

WriteString

(

defaultValue

); } }

writer

WriteLine

(

L";"

); }

void

Visit

(

WfEventDeclaration

node

)

override

{

auto

eventInfo

dynamic_cast

IEventInfo

*>(

config

manager

declarationMemberInfos

[

node

Obj

());

auto

typeInfo

eventInfo

GetHandlerType

();

writer

WriteString

(

prefix

);

writer

WriteString

(

L"::vl::Event<void("

);

vint

count

typeInfo

GetGenericArgumentCount

();

for

(

vint

;

count

;

++) {

(

)

writer

WriteString

(

L", "

);

writer

WriteString

(

config

ConvertType

(

typeInfo

GetGenericArgument

(

))); }

writer

WriteLine

(

L")> "

config

ConvertName

(

node

name

value

) +

L";"

); }

void

Visit

(

WfPropertyDeclaration

node

)

override

{ }

void

Visit

(

WfConstructorDeclaration

node

)

override

{

auto

methodInfo

dynamic_cast

IMethodInfo

*>(

config

manager

declarationMemberInfos

[

node

Obj

());

writer

WriteString

(

prefix

);

config

WriteFunctionHeader

(

writer

methodInfo

className

false

);

writer

WriteLine

(

L";"

); }

void

Visit

(

WfDestructorDeclaration

node

)

override

{

writer

WriteLine

(

prefix

L"~"

className

L"();"

); }

void

Visit

(

WfClassDeclaration

node

)

override

{ }

void

Visit

(

WfEnumDeclaration

node

)

override

{ }

void

Visit

(

WfStructDeclaration

node

)

override

{ }

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

{

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

); } } };

class

WfGenerateClassMemberInitVisitor

public

empty_visitor

DeclarationVisitor

{

public

WfCppConfig

config

;

stream

StreamWriter

writer

;

WString

prefix

;

vint

callIndex

;

WfGenerateClassMemberInitVisitor

(

WfCppConfig

_config

stream

StreamWriter

_writer

const

WString

_prefix

vint

_callIndex

) :config(

_config

) , writer(

_writer

) , prefix(

_prefix

) , callIndex(

_callIndex

) { }

void

WriteVariableHeader

(

WfVariableDeclaration

node

) {

writer

WriteString

(

prefix

);

(

callIndex

++ ==

) {

writer

WriteString

(

L"\t: "

); }

else

{

writer

WriteString

(

L"\t, "

); }

writer

WriteString

(

config

ConvertName

(

node

name

value

)); }

void

Visit

(

WfVariableDeclaration

node

)

override

{

auto

scope

config

manager

nodeScopes

[

node

Obj

();

auto

symbol

scope

symbols

[

node

name

value

]

[

];

auto

typeInfo

symbol

typeInfo

;

(

node

expression

) {

WriteVariableHeader

(

node

);

writer

WriteString

(

L"("

);

GenerateExpression

(

config

writer

node

expression

typeInfo

Obj

());

writer

WriteLine

(

L")"

); }

else

{

auto

defaultValue

config

DefaultValue

(

typeInfo

Obj

());

(

defaultValue

L""

) {

WriteVariableHeader

(

node

);

writer

WriteString

(

L"("

);

writer

WriteString

(

defaultValue

);

writer

WriteLine

(

L")"

); } } }

void

Dispatch

(

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

Dispatch

(

WfVirtualCseDeclaration

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

GenerateClassMemberDecl

(

WfCppConfig

config

stream

StreamWriter

writer

const

WString

className

Ptr

WfDeclaration

memberDecl

const

WString

prefix

bool

forClassExpr

) {

WfGenerateClassMemberDeclVisitor

visitor

(

config

writer

className

prefix

forClassExpr

);

memberDecl

visitor

); }

/*********************************************************************** WfGenerateClassMemberImplVisitor ***********************************************************************/

class

WfGenerateClassMemberImplVisitor

public

Object

public

WfDeclaration

IVisitor

{

public

WfCppConfig

config

;

stream

StreamWriter

writer

;

WfClassDeclaration

classDef

;

WString

classBaseName

;

WString

className

;

WString

classFullName

;

WString

prefix

;

bool

printableMember

false

;

WfGenerateClassMemberImplVisitor

(

WfCppConfig

_config

stream

StreamWriter

_writer

WfClassDeclaration

_classDef

const

WString

_classBaseName

const

WString

_className

const

WString

_classFullName

const

WString

_prefix

) :config(

_config

) , writer(

_writer

) , classDef(

_classDef

) , classBaseName(

_classBaseName

) , className(

_className

) , classFullName(

_classFullName

) , prefix(

_prefix

) { }

void

WriteNotImplemented

(

const

WString

classFullName

) {

writer

WriteString

(

prefix

);

writer

WriteLine

(

L"{/* USER_CONTENT_BEGIN("

classFullName

L") */"

);

writer

WriteString

(

prefix

);

writer

WriteLine

(

L"\tthrow ::vl::Exception(L\"You should implement this function.\");"

);

writer

WriteString

(

prefix

);

writer

WriteLine

(

L"}/* USER_CONTENT_END() */"

); }

void

Visit

(

WfNamespaceDeclaration

node

)

override

{ }

void

Visit

(

WfFunctionDeclaration

node

)

override

{

IsVirtual

(

config

node

)) {

printableMember

true

;

writer

WriteString

(

prefix

);

auto

returnType

config

WriteFunctionHeader

(

writer

node

classBaseName

L"::"

config

ConvertName

(

node

name

value

true

);

writer

WriteLine

(

L""

);

bool

userImpl

config

attributeEvaluator

GetAttribute

(

node

attributes

L"cpp"

L"UserImpl"

);

(

userImpl

) {

WriteNotImplemented

(

classFullName

); }

else

{

config

WriteFunctionBody

(

writer

node

statement

prefix

returnType

); } } }

void

Visit

(

WfVariableDeclaration

node

)

override

{ }

void

Visit

(

WfEventDeclaration

node

)

override

{ }

void

Visit

(

WfPropertyDeclaration

node

)

override

{ }

void

Visit

(

WfConstructorDeclaration

node

)

override

{

auto

scope

config

manager

nodeScopes

[

node

Obj

();

printableMember

true

;

auto

methodInfo

dynamic_cast

IMethodInfo

*>(

config

manager

declarationMemberInfos

[

node

Obj

());

List

WString

arguments

;

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

);)

{

arguments

Add

(

config

ConvertName

(

argument

name

value

)); }

writer

WriteString

(

prefix

);

config

WriteFunctionHeader

(

writer

methodInfo

arguments

classBaseName

L"::"

className

false

);

writer

WriteLine

(

L""

);

vint

callIndex

;

FOREACH(Ptr<WfBaseConstructorCall>, call, node->baseConstructorCalls)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfBaseConstructorCall

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

baseConstructorCalls

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfBaseConstructorCall

call

;

__foreach_iterator__

(

call

);)

{

auto

callType

CreateTypeInfoFromType

(

scope

call

type

false

);

auto

callCtor

config

manager

baseConstructorCallResolvings

[

{

node

callType

GetTypeDescriptor

()}].

value

;

writer

WriteString

(

prefix

);

(

callIndex

++ ==

) {

writer

WriteString

(

L"\t: "

); }

else

{

writer

WriteString

(

L"\t, "

); }

writer

WriteString

(

config

ConvertType

(

callType

GetTypeDescriptor

()));

writer

WriteString

(

L"("

);

FOREACH_INDEXER(Ptr<WfExpression>, argument, argumentIndex, call->arguments)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfExpression

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

call

arguments

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

(

bool

__scope_variable_flag__

true

)

for

(

vint

argumentIndex

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfExpression

argument

;

__foreach_iterator__

(

argument

);

argumentIndex

++)

{

(

argumentIndex

)

writer

WriteString

(

L", "

);

GenerateExpression

(

config

writer

argument

callCtor

GetParameter

(

argumentIndex

)->

GetType

()); }

writer

WriteLine

(

L")"

); }

(

classDef

) {

WfGenerateClassMemberInitVisitor

visitor

(

config

writer

prefix

callIndex

);

FOREACH(Ptr<WfDeclaration>, member, classDef->declarations)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

classDef

declarations

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfDeclaration

member

;

__foreach_iterator__

(

member

);)

{

member

visitor

); } }

bool

userImpl

config

attributeEvaluator

GetAttribute

(

node

attributes

L"cpp"

L"UserImpl"

);

(

userImpl

) {

WriteNotImplemented

(

classFullName

); }

else

{

config

WriteFunctionBody

(

writer

node

statement

prefix

nullptr

); } }

void

Visit

(

WfDestructorDeclaration

node

)

override

{

printableMember

true

;

writer

WriteLine

(

prefix

classBaseName

L"::~"

className

L"()"

);

bool

userImpl

config

attributeEvaluator

GetAttribute

(

node

attributes

L"cpp"

L"UserImpl"

);

(

userImpl

) {

WriteNotImplemented

(

classFullName

); }

else

{

config

WriteFunctionBody

(

writer

node

statement

prefix

nullptr

); } }

void

Visit

(

WfClassDeclaration

node

)

override

{ }

void

Visit

(

WfEnumDeclaration

node

)

override

{ }

void

Visit

(

WfStructDeclaration

node

)

override

{ }

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

{

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

); } } };

bool

GenerateClassMemberImpl

(

WfCppConfig

config

stream

StreamWriter

writer

WfClassDeclaration

classDef

const

WString

classBaseName

const

WString

className

const

WString

classFullName

Ptr

WfDeclaration

memberDecl

const

WString

prefix

) {

WfGenerateClassMemberImplVisitor

visitor

(

config

writer

classDef

classBaseName

className

classFullName

prefix

);

memberDecl

visitor

);

return

visitor

printableMember

; } } } }