WfEmitter_Declaration.cpp

#include "WfEmitter.h"

namespace

{

namespace

workflow

{

namespace

emitter

{

using

namespace

collections

;

using

namespace

parsing

;

using

namespace

reflection

description

;

using

namespace

analyzer

;

using

namespace

runtime

;

using

namespace

typeimpl

;

typedef

WfInstruction

Ins

;

#define INSTRUCTION(X) context.AddInstruction(node, X)

/*********************************************************************** GenerateInstructions(Initialize) ***********************************************************************/

class

GenerateInitializeInstructionsVisitor

public

Object

public

WfDeclaration

IVisitor

{

public

WfCodegenContext

context

;

GenerateInitializeInstructionsVisitor

(

WfCodegenContext

_context

) :context(

_context

) { }

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

);)

{

GenerateInitializeInstructions

(

context

decl

); } }

void

Visit

(

WfFunctionDeclaration

node

)

override

{ }

void

Visit

(

WfVariableDeclaration

node

)

override

{

auto

scope

context

manager

nodeScopes

[

node

Obj

();

auto

symbol

scope

symbols

[

node

name

value

]

[

];

vint

variableIndex

context

globalVariables

[

symbol

Obj

()];

GenerateExpressionInstructions

(

context

node

expression

);

INSTRUCTION(Ins::StoreGlobalVar(variableIndex));

context

AddInstruction

(

node

Ins

StoreGlobalVar

(

variableIndex

));

}

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

{ }

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

); } } };

void

GenerateInitializeInstructions

(

WfCodegenContext

context

Ptr

WfDeclaration

declaration

) {

GenerateInitializeInstructionsVisitor

visitor

(

context

);

declaration

visitor

); }

/*********************************************************************** GenerateInstructions(Declaration) ***********************************************************************/

Ptr

WfCodegenFunctionContext

GenerateFunctionInstructions_Prolog

(

WfCodegenContext

context

WfLexicalScope

scope

Ptr

WfAssemblyFunction

meta

Ptr

ITypeInfo

returnType

Ptr

WfLexicalSymbol

recursiveLambdaSymbol

const

List

Ptr

WfLexicalSymbol

>>&

argumentSymbols

const

List

Ptr

WfLexicalSymbol

>>&

capturedSymbols

ParsingTreeCustomBase

node

) {

auto

functionContext

MakePtr

WfCodegenFunctionContext

>();

functionContext

function

meta

;

context

functionContext

; {

FOREACH_INDEXER(Ptr<WfLexicalSymbol>, argumentSymbol, index, argumentSymbols)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfLexicalSymbol

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

argumentSymbols

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

(

bool

__scope_variable_flag__

true

)

for

(

vint

index

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfLexicalSymbol

argumentSymbol

;

__foreach_iterator__

(

argumentSymbol

);

index

++)

{

functionContext

arguments

Add

(

argumentSymbol

Obj

(),

index

); }

FOREACH_INDEXER(Ptr<WfLexicalSymbol>, capturedSymbol, index, capturedSymbols)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfLexicalSymbol

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

capturedSymbols

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

(

bool

__scope_variable_flag__

true

)

for

(

vint

index

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfLexicalSymbol

capturedSymbol

;

__foreach_iterator__

(

capturedSymbol

);

index

++)

{

functionContext

capturedVariables

Add

(

capturedSymbol

Obj

(),

index

); } }

(

recursiveLambdaSymbol

) {

vint

variableIndex

meta

argumentNames

Count

() +

meta

localVariableNames

Add

(

L"<recursive-lambda>"

recursiveLambdaSymbol

name

);

functionContext

localVariables

Add

(

recursiveLambdaSymbol

Obj

(),

variableIndex

); }

meta

firstInstruction

context

assembly

instructions

Count

();

(

recursiveLambdaSymbol

) {

INSTRUCTION(Ins::LoadClosureContext());

context

AddInstruction

(

node

Ins

LoadClosureContext

());

INSTRUCTION(Ins::LoadFunction(context.assembly->functions.IndexOf(meta.Obj())));

context

AddInstruction

(

node

Ins

LoadFunction

(

context

assembly

functions

IndexOf

(

meta

Obj

())));

INSTRUCTION(Ins::CreateClosure());

context

AddInstruction

(

node

Ins

CreateClosure

());

INSTRUCTION(Ins::StoreLocalVar(functionContext->localVariables[recursiveLambdaSymbol.Obj()]));

context

AddInstruction

(

node

Ins

StoreLocalVar

(

functionContext

localVariables

[

recursiveLambdaSymbol

Obj

()]));

}

return

functionContext

; }

void

GenerateFunctionInstructions_Epilog

(

WfCodegenContext

context

WfLexicalScope

scope

Ptr

WfAssemblyFunction

meta

Ptr

ITypeInfo

returnType

Ptr

WfLexicalSymbol

recursiveLambdaSymbol

const

List

Ptr

WfLexicalSymbol

>>&

argumentSymbols

const

List

Ptr

WfLexicalSymbol

>>&

capturedSymbols

Ptr

WfCodegenFunctionContext

functionContext

ParsingTreeCustomBase

node

) {

INSTRUCTION(Ins::LoadValue({}));

context

AddInstruction

(

node

Ins

LoadValue

({}));

INSTRUCTION(Ins::Return());

context

AddInstruction

(

node

Ins

Return

());

meta

lastInstruction

context

assembly

instructions

Count

() -

;

context

functionContext

;

GenerateClosureInstructions

(

context

functionContext

); }

void

GenerateFunctionInstructions

(

WfCodegenContext

context

WfLexicalScope

scope

Ptr

WfAssemblyFunction

meta

Ptr

ITypeInfo

returnType

Ptr

WfLexicalSymbol

recursiveLambdaSymbol

const

List

Ptr

WfLexicalSymbol

>>&

argumentSymbols

const

List

Ptr

WfLexicalSymbol

>>&

capturedSymbols

Ptr

WfStatement

statementBody

ParsingTreeCustomBase

node

) {

auto

functionContext

GenerateFunctionInstructions_Prolog

(

context

scope

meta

returnType

recursiveLambdaSymbol

argumentSymbols

capturedSymbols

node

);

GenerateStatementInstructions

(

context

statementBody

);

GenerateFunctionInstructions_Epilog

(

context

scope

meta

returnType

recursiveLambdaSymbol

argumentSymbols

capturedSymbols

functionContext

node

); }

void

GenerateFunctionInstructions

(

WfCodegenContext

context

WfLexicalScope

scope

Ptr

WfAssemblyFunction

meta

Ptr

ITypeInfo

returnType

Ptr

WfLexicalSymbol

recursiveLambdaSymbol

const

List

Ptr

WfLexicalSymbol

>>&

argumentSymbols

const

List

Ptr

WfLexicalSymbol

>>&

capturedSymbols

Ptr

WfExpression

expressionBody

ParsingTreeCustomBase

node

) {

auto

functionContext

GenerateFunctionInstructions_Prolog

(

context

scope

meta

returnType

recursiveLambdaSymbol

argumentSymbols

capturedSymbols

node

);

GenerateExpressionInstructions

(

context

expressionBody

);

INSTRUCTION(Ins::Return());

context

AddInstruction

(

node

Ins

Return

());

GenerateFunctionInstructions_Epilog

(

context

scope

meta

returnType

recursiveLambdaSymbol

argumentSymbols

capturedSymbols

functionContext

node

); }

void

GenerateFunctionDeclarationInstructions

(

WfCodegenContext

context

WfFunctionDeclaration

node

WfLexicalScope

scope

Ptr

WfAssemblyFunction

meta

Ptr

WfLexicalSymbol

recursiveLambdaSymbol

) {

List

Ptr

WfLexicalSymbol

argumentSymbols

capturedSymbols

; {

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

symbol

scope

symbols

[

argument

name

value

]

[

];

argumentSymbols

Add

(

symbol

); }

vint

index

context

manager

lambdaCaptures

Keys

().

IndexOf

(

node

);

(

index

!= -

) {

auto

capture

context

manager

lambdaCaptures

Values

()

[

index

];

FOREACH(Ptr<WfLexicalSymbol>, symbol, capture->symbols)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfLexicalSymbol

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

capture

symbols

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfLexicalSymbol

symbol

;

__foreach_iterator__

(

symbol

);)

{

capturedSymbols

Add

(

symbol

); } } }

auto

returnType

CreateTypeInfoFromType

(

scope

node

returnType

);

GenerateFunctionInstructions

(

context

scope

meta

returnType

recursiveLambdaSymbol

argumentSymbols

capturedSymbols

node

statement

node

); }

class

GenerateClassMemberInstructionsVisitor

public

Object

public

WfDeclaration

IVisitor

{

public

WfCodegenContext

context

;

Ptr

WfClassDeclaration

classDecl

;

GenerateClassMemberInstructionsVisitor

(

WfCodegenContext

_context

Ptr

WfClassDeclaration

_classDecl

) :context(

_context

) , classDecl(

_classDecl

) { }

void

Visit

(

WfNamespaceDeclaration

node

)

override

{ }

void

Visit

(

WfFunctionDeclaration

node

)

override

{

(

node

classMember

kind

WfClassMemberKind

Static

) {

GenerateDeclarationInstructions

(

context

node

); }

else

(

classDecl

kind

WfClassKind

Class

) {

GenerateDeclarationInstructions

(

context

node

); } }

void

Visit

(

WfVariableDeclaration

node

)

override

{ }

void

Visit

(

WfEventDeclaration

node

)

override

{ }

void

Visit

(

WfPropertyDeclaration

node

)

override

{ }

class

InitializeFieldVisitor

public

empty_visitor

DeclarationVisitor

{

public

WfCodegenContext

context

;

InitializeFieldVisitor

(

WfCodegenContext

_context

) :context(

_context

) { }

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

Visit

(

WfVariableDeclaration

node

)

override

{

auto

info

context

manager

declarationMemberInfos

[

node

Cast

WfField

>().

Obj

();

GenerateExpressionInstructions

(

context

node

expression

);

INSTRUCTION(Ins::LoadCapturedVar(0));

context

AddInstruction

(

node

Ins

LoadCapturedVar

(

));

INSTRUCTION(Ins::SetProperty(info));

context

AddInstruction

(

node

Ins

SetProperty

(

info

));

} };

void

Visit

(

WfConstructorDeclaration

node

)

override

{

auto

meta

context

assembly

functions

[

context

constructors

[

node

]];

auto

functionContext

MakePtr

WfCodegenFunctionContext

>();

functionContext

function

meta

;

context

functionContext

;

meta

firstInstruction

context

assembly

instructions

Count

();

auto

scope

context

manager

nodeScopes

[

node

Obj

(); {

FOREACH_INDEXER(Ptr<WfFunctionArgument>, argument, index, 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

)

(

bool

__scope_variable_flag__

true

)

for

(

vint

index

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfFunctionArgument

argument

;

__foreach_iterator__

(

argument

);

index

++)

{

auto

symbol

scope

symbols

[

argument

name

value

]

[

];

functionContext

arguments

Add

(

symbol

Obj

(),

index

); } }

(

classDecl

baseTypes

Count

() >

) {

auto

scope

parentScope

typeOfThisExpr

;

vint

count

GetBaseTypeDescriptorCount

();

for

(

vint

;

count

;

++) {

auto

baseTd

GetBaseTypeDescriptor

(

);

auto

ctor

context

manager

baseConstructorCallResolvings

[

{

node

baseTd

}];

(

ctor

key

) {

FOREACH(Ptr<WfExpression>, argument, ctor.key->arguments)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfExpression

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

ctor

key

arguments

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfExpression

argument

;

__foreach_iterator__

(

argument

);)

{

GenerateExpressionInstructions

(

context

argument

); }

INSTRUCTION(Ins::LoadCapturedVar(0));

context

AddInstruction

(

node

Ins

LoadCapturedVar

(

));

INSTRUCTION(Ins::InvokeBaseCtor(ctor.value, ctor.key->arguments.Count()));

context

AddInstruction

(

node

Ins

InvokeBaseCtor

(

ctor

value

ctor

key

arguments

Count

()));

}

else

{

INSTRUCTION(Ins::LoadCapturedVar(0));

context

AddInstruction

(

node

Ins

LoadCapturedVar

(

));

INSTRUCTION(Ins::InvokeBaseCtor(ctor.value, 0));

context

AddInstruction

(

node

Ins

InvokeBaseCtor

(

ctor

value

));

}

INSTRUCTION(Ins::Pop());

context

AddInstruction

(

node

Ins

Pop

());

} } {

InitializeFieldVisitor

visitor

(

context

);

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

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

classDecl

declarations

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfDeclaration

memberDecl

;

__foreach_iterator__

(

memberDecl

);)

{

memberDecl

visitor

); } }

GenerateStatementInstructions

(

context

node

statement

);

INSTRUCTION(Ins::LoadValue({}));

context

AddInstruction

(

node

Ins

LoadValue

({}));

INSTRUCTION(Ins::Return());

context

AddInstruction

(

node

Ins

Return

());

meta

lastInstruction

context

assembly

instructions

Count

() -

;

context

functionContext

;

GenerateClosureInstructions

(

context

functionContext

); }

void

Visit

(

WfDestructorDeclaration

node

)

override

{

auto

meta

context

assembly

functions

[

context

destructors

[

node

]];

auto

functionContext

MakePtr

WfCodegenFunctionContext

>();

functionContext

function

meta

;

context

functionContext

;

meta

firstInstruction

context

assembly

instructions

Count

();

auto

scope

context

manager

nodeScopes

[

node

Obj

();

GenerateStatementInstructions

(

context

node

statement

);

INSTRUCTION(Ins::LoadValue({}));

context

AddInstruction

(

node

Ins

LoadValue

({}));

INSTRUCTION(Ins::Return());

context

AddInstruction

(

node

Ins

Return

());

meta

lastInstruction

context

assembly

instructions

Count

() -

;

context

functionContext

;

GenerateClosureInstructions

(

context

functionContext

); }

void

Visit

(

WfClassDeclaration

node

)

override

{

GenerateDeclarationInstructions

(

context

node

); }

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

GenerateDeclarationInstructionsVisitor

public

Object

public

WfDeclaration

IVisitor

{

public

WfCodegenContext

context

;

GenerateDeclarationInstructionsVisitor

(

WfCodegenContext

_context

) :context(

_context

) { }

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

);)

{

GenerateDeclarationInstructions

(

context

decl

); } }

void

Visit

(

WfFunctionDeclaration

node

)

override

{

auto

scope

context

manager

nodeScopes

[

node

Obj

();

auto

symbol

context

manager

GetDeclarationSymbol

(

scope

node

);

auto

meta

context

assembly

functions

[

context

globalFunctions

[

symbol

Obj

()]];

GenerateFunctionDeclarationInstructions

(

context

node

scope

meta

); }

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

{

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

);)

{

GenerateClassMemberInstructionsVisitor

visitor

(

context

node

);

memberDecl

visitor

); } }

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

); } } };

void

GenerateDeclarationInstructions

(

WfCodegenContext

context

Ptr

WfDeclaration

declaration

) {

GenerateDeclarationInstructionsVisitor

visitor

(

context

);

declaration

visitor

); }

/*********************************************************************** GenerateInstructions(Closure) ***********************************************************************/

void

GenerateClosureInstructions_Function

(

WfCodegenContext

context

vint

functionIndex

WfFunctionDeclaration

node

bool

createInterface

) {

auto

scope

context

manager

nodeScopes

[

node

Obj

();

auto

meta

context

assembly

functions

[

functionIndex

];

GenerateFunctionDeclarationMetadata

(

context

node

meta

);

Ptr

WfLexicalSymbol

recursiveLambdaSymbol

;

createInterface

node

name

value

L""

) {

recursiveLambdaSymbol

scope

symbols

[

node

name

value

]

[

]; }

GenerateFunctionDeclarationInstructions

(

context

node

scope

meta

recursiveLambdaSymbol

); }

void

GenerateClosureInstructions_Ordered

(

WfCodegenContext

context

vint

functionIndex

WfOrderedLambdaExpression

node

) {

auto

scope

context

manager

nodeScopes

[

node

Obj

();

List

Ptr

WfLexicalSymbol

argumentSymbols

capturedSymbols

;

CopyFrom

(

argumentSymbols

Range

vint

scope

symbols

Count

()) .

Select

([scope](

vint

index

)->

Ptr

WfLexicalSymbol

return

scope

symbols

GetByIndex

(

index

)

[

];}) .

OrderBy

([](

Ptr

WfLexicalSymbol

Ptr

WfLexicalSymbol

) {

vint

aId

wtoi

(

name

Sub

(

name

Length

() -

));

vint

bId

wtoi

(

name

Sub

(

name

Length

() -

));

return

aId

bId

; }) );

auto

meta

context

assembly

functions

[

functionIndex

];

FOREACH(Ptr<WfLexicalSymbol>, symbol, argumentSymbols)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfLexicalSymbol

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

argumentSymbols

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfLexicalSymbol

symbol

;

__foreach_iterator__

(

symbol

);)

{

meta

argumentNames

Add

(

symbol

name

); } {

auto

capture

context

manager

lambdaCaptures

Get

(

node

);

FOREACH(Ptr<WfLexicalSymbol>, symbol, capture->symbols)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfLexicalSymbol

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

capture

symbols

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfLexicalSymbol

symbol

;

__foreach_iterator__

(

symbol

);)

{

meta

capturedVariableNames

Add

(

L"<captured>"

symbol

name

);

capturedSymbols

Add

(

symbol

); }

vint

count

context

GetThisStackCount

(

scope

);

for

(

vint

;

count

;

++) {

meta

capturedVariableNames

Add

(

L"<captured-this>"

itow

(

)); } }

auto

result

context

manager

expressionResolvings

[

node

];

auto

returnType

CopyTypeInfo

(

result

type

GetElementType

()->

GetGenericArgument

(

));

GenerateFunctionInstructions

(

context

scope

meta

returnType

argumentSymbols

capturedSymbols

node

body

node

); }

void

GenerateClosureInstructions

(

WfCodegenContext

context

Ptr

WfCodegenFunctionContext

functionContext

) {

for

(

vint

;

functionContext

closuresToCodegen

Count

();

++) {

vint

functionIndex

functionContext

closuresToCodegen

Keys

()

[

];

auto

closure

functionContext

closuresToCodegen

Values

()

[

];

(

closure

functionExpression

) {

GenerateClosureInstructions_Function

(

context

functionIndex

closure

functionExpression

function

Obj

(),

false

); }

else

(

closure

orderedLambdaExpression

) {

GenerateClosureInstructions_Ordered

(

context

functionIndex

closure

orderedLambdaExpression

); }

else

(

closure

functionDeclaration

) {

GenerateClosureInstructions_Function

(

context

functionIndex

closure

functionDeclaration

true

); } } }

#undef INSTRUCTION

} } }