Parsing.cpp

/*********************************************************************** Author: Zihan Chen (vczh) Licensed under https://github.com/vczh-libraries/License ***********************************************************************/

#include "Parsing.h"

#include "ParsingAutomaton.h"

namespace

{

namespace

parsing

{

namespace

tabling

{

using

namespace

definitions

;

using

namespace

analyzing

;

using

namespace

collections

;

using

namespace

regex

;

/*********************************************************************** ParsingGeneralParser ***********************************************************************/

ParsingGeneralParser

(

Ptr

ParsingTable

_table

) :table(

_table

) { }

ParsingGeneralParser

() { }

Ptr

ParsingTable

ParsingGeneralParser

GetTable

() {

return

table

; }

void

ParsingGeneralParser

BeginParse

() { }

bool

ParsingGeneralParser

Parse

(

ParsingState

state

ParsingTransitionProcessor

processor

collections

List

Ptr

ParsingError

>>&

errors

) {

BeginParse

();

processor

Reset

();

for

(

vint

;

state

GetTokens

().

Count

();

++) {

const

RegexToken

token

state

GetTokens

().

Get

(

);

(

token

==-

|| !

token

completeToken

) {

errors

Add

(

new

ParsingError

(

token

L"Unrecognizable token: \""

WString

(

token

reading

token

length

L"\"."

)); } }

while

(

true

) {

ParsingState

TransitionResult

result

ParseStep

(

state

errors

);

result

) {

const

RegexToken

token

state

GetToken

(

state

GetCurrentToken

());

errors

Add

(

new

ParsingError

(

token

L"Internal error when parsing."

));

return

false

; }

else

(

result

transitionType

ParsingState

TransitionResult

SkipToken

) {

(

state

GetCurrentTableTokenIndex

()==

ParsingTable

TokenFinish

) {

const

RegexToken

token

state

GetToken

(

state

GetCurrentToken

());

errors

Add

(

new

ParsingError

(

token

L"Failed to recover error when reaching the end of the input."

));

return

false

; }

else

{

state

SkipCurrentToken

();

continue

; } }

else

processor

Run

(

result

)) {

const

RegexToken

token

state

GetToken

(

state

GetCurrentToken

());

errors

Add

(

new

ParsingError

(

token

L"Internal error when building the parsing tree."

));

return

false

; }

(

result

tableTokenIndex

ParsingTable

TokenFinish

&& !

processor

GetProcessingAmbiguityBranch

()) {

break

; } }

return

true

; }

Ptr

ParsingTreeNode

ParsingGeneralParser

Parse

(

ParsingState

state

collections

List

Ptr

ParsingError

>>&

errors

) {

ParsingTreeBuilder

builder

;

Parse

(

state

builder

errors

);

Ptr

ParsingTreeNode

node

builder

GetNode

();

node

) {

errors

Add

(

new

ParsingError

(

L"Internal error when building the parsing tree after a succeeded parsing process."

));

return

; }

return

node

; }

Ptr

ParsingTreeNode

ParsingGeneralParser

Parse

(

const

WString

input

const

WString

rule

collections

List

Ptr

ParsingError

>>&

errors

vint

codeIndex

) {

ParsingState

state

(

input

table

codeIndex

);

(

state

Reset

(

rule

)==-

) {

errors

Add

(

new

ParsingError

(

L"Rule \""

rule

L"\" does not exist."

));

return

; }

return

Parse

(

state

errors

); }

/*********************************************************************** ParsingStrictParser ***********************************************************************/

bool

ParsingStrictParser

OnTestErrorRecoverExists

() {

return

false

; }

void

ParsingStrictParser

OnClearErrorRecover

() { }

ParsingState

TransitionResult

ParsingStrictParser

OnErrorRecover

(

ParsingState

state

vint

currentTokenIndex

collections

List

Ptr

ParsingError

>>&

errors

) {

const

RegexToken

token

state

GetToken

(

state

GetCurrentToken

());

errors

Add

(

new

ParsingError

(

token

, (

token

L"Error happened during parsing when reaching the end of the input."

L"Error happened during parsing."

)));

return

ParsingState

TransitionResult

(); }

ParsingStrictParser

(

Ptr

ParsingTable

_table

) :

ParsingGeneralParser

(

_table

) { }

ParsingStrictParser

() { }

ParsingState

TransitionResult

ParsingStrictParser

ParseStep

(

ParsingState

state

collections

List

Ptr

ParsingError

>>&

errors

) {

ParsingState

TransitionResult

result

;

(

OnTestErrorRecoverExists

()) {

result

OnErrorRecover

(

state

, -

errors

); }

else

{

result

state

ReadToken

();

(

result

) {

OnClearErrorRecover

(); }

else

{

vint

currentTokenIndex

state

GetCurrentTableTokenIndex

();

(

currentTokenIndex

!= -

) {

result

OnErrorRecover

(

state

currentTokenIndex

errors

); } } }

return

result

; }

/*********************************************************************** ParsingAutoRecoverParser ***********************************************************************/

ParsingAutoRecoverParser

RecoverFuture

ParsingAutoRecoverParser

GetRecoverFuture

(

vint

index

) {

return

recoverFutures

[

index

]; }

ParsingAutoRecoverParser

RecoverFuture

ParsingAutoRecoverParser

CreateRecoverFuture

(

vint

index

vint

previousIndex

) {

RecoverFuture

;

(

index

recoverFutures

Count

()) {

CHECK_ERROR(index == recoverFutures.Count(), L"ParsingAutoRecoverParser::CreateRecoverFuture(vint, vint)#Wrong argument: index.");

{

(!(

index

recoverFutures

Count

()))

throw

Error

(

L"ParsingAutoRecoverParser::CreateRecoverFuture(vint, vint)#Wrong argument: index."

);}

while

(

);

RecoverFuture

recoverFuture

;

recoverFuture

future

new

ParsingState

Future

;

index

recoverFutures

Add

(

recoverFuture

); }

= &

GetRecoverFuture

(

index

);

index

;

previousIndex

;

return

; }

bool

ParsingAutoRecoverParser

OnTestErrorRecoverExists

() {

return

recoveringFutureIndex

!= -

; }

void

ParsingAutoRecoverParser

OnClearErrorRecover

() {

recoveringFutureIndex

= -

; }

ParsingState

TransitionResult

ParsingAutoRecoverParser

OnErrorRecover

(

ParsingState

state

vint

currentTokenIndex

collections

List

Ptr

ParsingError

>>&

errors

) {

(

recoveringFutureIndex

==-

) {

List

vint

prioritizedTokens

;

prioritizedTokens

Add

(

ParsingTable

TokenFinish

);

CopyFrom

(

prioritizedTokens

Range

vint

ParsingTable

UserTokenStart

table

GetTokenCount

() -

ParsingTable

UserTokenStart

) );

prioritizedTokens

Add

(

ParsingTable

LeftRecursiveReduce

);

prioritizedTokens

Add

(

ParsingTable

NormalReduce

);

prioritizedTokens

Remove

(

currentTokenIndex

);

prioritizedTokens

Insert

(

currentTokenIndex

);

vint

processingFutureIndex

;

vint

usedFutureCount

;

while

(

processingFutureIndex

usedFutureCount

) {

RecoverFuture

;

(

processingFutureIndex

!=-

) {

GetRecoverFuture

(

processingFutureIndex

); }

processingFutureIndex

++;

(

future

currentState

==-

)

continue

;

FOREACH(vint, currentTableTokenIndex, prioritizedTokens)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

vint

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

prioritizedTokens

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

vint

currentTableTokenIndex

;

__foreach_iterator__

(

currentTableTokenIndex

);)

{

vint

newInsertedTokenCount

insertedTokenCount

;

(

currentTableTokenIndex

ParsingTable

NormalReduce

currentTableTokenIndex

ParsingTable

LeftRecursiveReduce

) {

newInsertedTokenCount

++; }

(

currentTableTokenIndex

currentTokenIndex

newInsertedTokenCount

maxInsertedTokenCount

) {

continue

; }

RecoverFuture

now

CreateRecoverFuture

(

usedFutureCount

index

);

now

insertedTokenCount

newInsertedTokenCount

;

(

state

ReadTokenInFuture

(

currentTableTokenIndex

future

now

future

)) {

(

currentTableTokenIndex

currentTokenIndex

) {

(

future

) {

recoveringFutureIndex

index

;

RecoverFuture

= &

GetRecoverFuture

(

index

);

while

(

future

) {

RecoverFuture

prf

= &

GetRecoverFuture

(

previousIndex

);

prf

nextIndex

index

;

prf

future

;

prf

; }

recoveringFutureIndex

index

; }

else

{

recoveringFutureIndex

; }

goto

FOUND_ERROR_RECOVER_SOLUTION; }

else

{

usedFutureCount

++; } } } } } FOUND_ERROR_RECOVER_SOLUTION:

RecoverFuture

;

(

recoveringFutureIndex

!= -

) {

= &

GetRecoverFuture

(

recoveringFutureIndex

);

(

future

) {

recoveringFutureIndex

nextIndex

; }

else

{

recoveringFutureIndex

= -

; } }

(

) {

return

state

RunTransition

(

future

selectedItem

); }

else

{

return

ParsingState

TransitionResult

(

ParsingState

TransitionResult

SkipToken

); } }

ParsingAutoRecoverParser

(

Ptr

ParsingTable

_table

vint

_maxInsertedTokenCount

) :

ParsingStrictParser

(

_table

) , recoveringFutureIndex(-

) , maxInsertedTokenCount(

_maxInsertedTokenCount

== -

_maxInsertedTokenCount

) { }

ParsingAutoRecoverParser

() {

FOREACH(RecoverFuture, future, recoverFutures)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

RecoverFuture

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

recoverFutures

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

RecoverFuture

future

;

__foreach_iterator__

(

future

);)

{

delete

future

; } }

void

ParsingAutoRecoverParser

BeginParse

() {

recoveringFutureIndex

= -

;

ParsingStrictParser

BeginParse

(); }

/*********************************************************************** ParsingAmbiguousParser ***********************************************************************/

ParsingAmbiguousParser

(

Ptr

ParsingTable

_table

) :

ParsingGeneralParser

(

_table

) ,consumedDecisionCount(

) { }

ParsingAmbiguousParser

() { }

void

ParsingAmbiguousParser

OnErrorRecover

(

ParsingState

state

vint

currentTokenIndex

collections

List

ParsingState

Future

*>&

futures

vint

begin

vint

end

collections

List

Ptr

ParsingError

>>&

errors

) {

begin

end

; }

vint

ParsingAmbiguousParser

GetResolvableFutureLevels

(

collections

List

ParsingState

Future

*>&

futures

vint

begin

vint

end

) {

(

end

begin

) {

return

; }

List

ParsingState

Future

resolvingFutures

;

for

(

vint

begin

;

end

;

++) {

resolvingFutures

Add

(

futures

[

]); }

vint

level

;

while

(

true

) {

for

(

vint

;

resolvingFutures

Count

()-

;

++) {

ParsingState

Future

first

resolvingFutures

[

];

ParsingState

Future

second

resolvingFutures

[

];

(

first

currentState

second

currentState

first

reduceStateCount

second

reduceStateCount

first

shiftStates

Count

()!=

second

shiftStates

Count

() ) {

return

level

; }

else

{

for

(

vint

;

first

shiftStates

Count

();

++) {

(

first

shiftStates

[

]!=

second

shiftStates

[

]) {

return

level

; } } } }

level

++;

for

(

vint

;

resolvingFutures

Count

();

++) {

(!(

resolvingFutures

[

resolvingFutures

[

]->

)) {

return

level

; } } } }

vint

ParsingAmbiguousParser

SearchPathForOneStep

(

ParsingState

state

collections

List

ParsingState

Future

*>&

futures

vint

begin

vint

end

collections

List

Ptr

ParsingError

>>&

errors

) {

futures

Add

(

state

ExploreCreateRootFuture

());

vint

previousBegin

;

vint

previousEnd

;

vint

resolvableFutureLevels

;

bool

errorRecovered

false

;

while

(

true

) {

// keep all futures that consumed a token in a list

List

ParsingState

Future

consumedTokenFutures

;

vint

processBegin

previousBegin

;

vint

processEnd

previousEnd

;

while

(

processEnd

processBegin

) {

// explore the current token

(

state

ExploreStep

(

futures

processBegin

processEnd

processBegin

futures

)) {

CopyFrom

(

consumedTokenFutures

From

(

futures

) .Skip(

processEnd

) .Take(

futures

Count

() -

processEnd

true

);

futures

RemoveRange

(

processEnd

futures

Count

() -

processEnd

); }

// explore left recursive reduce and normal reduce

state

ExploreLeftRecursiveReduce

(

futures

processBegin

processEnd

processBegin

futures

);

state

ExploreNormalReduce

(

futures

processBegin

processEnd

processBegin

futures

);

// if a token is consumed, then for those reduce futures, explore them until a token is consumed, and discard all failed futures

processBegin

processEnd

;

processEnd

futures

Count

(); }

(

consumedTokenFutures

Count

() ==

) {

// failed to get any future that consumed a token, do error recovering

vint

tokenIndex

state

GetCurrentTableTokenIndex

();

OnErrorRecover

(

state

tokenIndex

futures

previousBegin

previousEnd

errors

);

(

previousBegin

previousEnd

) {

break

; } }

else

{

state

SkipCurrentToken

();

// put all futures that consumed a token from consumedTokenFutures back to future list

previousBegin

futures

Count

();

CopyFrom

(

futures

consumedTokenFutures

true

);

previousEnd

futures

Count

();

// resolve all futures and see if all futures collapsed into a equivalent single future

resolvableFutureLevels

GetResolvableFutureLevels

(

futures

previousBegin

previousEnd

);

(

resolvableFutureLevels

) {

break

; } } }

begin

previousBegin

;

end

previousEnd

;

return

resolvableFutureLevels

; }

vint

ParsingAmbiguousParser

GetConflictReduceCount

(

collections

List

ParsingState

Future

*>&

futures

) {

vint

conflictReduceCount

;

for

(

vint

;

futures

Count

()-

;

++) {

vint

count

;

ParsingState

Future

first

futures

[

];

ParsingState

Future

second

futures

[

];

vint

firstIndex

first

selectedItem

instructions

Count

();

vint

secondIndex

second

selectedItem

instructions

Count

();

while

(--

firstIndex

&& --

secondIndex

) {

ParsingTable

Instruction

firstIns

first

selectedItem

instructions

[

firstIndex

];

ParsingTable

Instruction

secondIns

second

selectedItem

instructions

[

secondIndex

];

(

firstIns

secondIns

) {

(

firstIns

instructionType

secondIns

instructionType

firstIns

nameParameter

secondIns

nameParameter

firstIns

stateParameter

secondIns

stateParameter

firstIns

value

secondIns

value

) {

(

firstIns

instructionType

ParsingTable

Instruction

Reduce

firstIns

instructionType

ParsingTable

Instruction

LeftRecursiveReduce

) {

count

++; }

continue

; } }

break

; }

(

conflictReduceCount

==-

conflictReduceCount

count

) {

conflictReduceCount

count

; } }

(

conflictReduceCount

==-

) {

conflictReduceCount

; }

return

conflictReduceCount

; }

void

ParsingAmbiguousParser

GetConflictReduceIndices

(

collections

List

ParsingState

Future

*>&

futures

vint

conflictReduceCount

collections

Array

vint

conflictReduceIndices

) {

conflictReduceIndices

Resize

(

futures

Count

());

for

(

vint

;

futures

Count

();

++) {

ParsingState

Future

future

futures

[

];

vint

index

future

selectedItem

instructions

Count

();

vint

count

;

while

(

count

conflictReduceCount

index

) {

switch

(

future

selectedItem

instructions

[

index

instructionType

) {

case

ParsingTable

Instruction

Reduce

case

ParsingTable

Instruction

LeftRecursiveReduce

count

++;

break

;

default

:; } }

conflictReduceIndices

[

index

; } }

vint

ParsingAmbiguousParser

GetAffectedStackNodeCount

(

collections

List

ParsingState

Future

*>&

futures

collections

Array

vint

conflictReduceIndices

) {

vint

affectedStackNodeCount

;

for

(

vint

;

futures

Count

();

++) {

ParsingState

Future

future

futures

[

];

vint

count

;

while

(

future

selectedItem

) {

vint

start

future

futures

[

conflictReduceIndices

[

future

selectedItem

instructions

Count

())-

;

for

(

vint

start

;

--) {

switch

(

future

selectedItem

instructions

[

instructionType

) {

case

ParsingTable

Instruction

Reduce

count

++;

break

;

case

ParsingTable

Instruction

Shift

count

--;

break

;

default

:; } }

future

; }

(

affectedStackNodeCount

==-

) {

affectedStackNodeCount

count

; }

else

(

affectedStackNodeCount

count

) {

return

; } }

return

affectedStackNodeCount

; }

void

ParsingAmbiguousParser

BuildSingleDecisionPath

(

ParsingState

state

ParsingState

Future

future

vint

lastAvailableInstructionCount

) {

List

Pair

ParsingTable

TransitionItem

regex

RegexToken

*>>

path

;

while

(

future

selectedToken

!=-

) {

path

Add

(

Pair

ParsingTable

TransitionItem

regex

RegexToken

*>(

future

selectedItem

future

selectedRegexToken

));

future

; }

for

(

vint

path

Count

() -

;

--) {

(

lastAvailableInstructionCount

!=-

) {

decisions

Add

(

state

RunTransition

(

path

[

key

path

[

value

lastAvailableInstructionCount

false

)); }

else

{

decisions

Add

(

state

RunTransition

(

path

[

key

path

[

value

)); } } }

void

ParsingAmbiguousParser

BuildAmbiguousDecisions

(

ParsingState

state

collections

List

ParsingState

Future

*>&

futures

vint

begin

vint

end

vint

resolvableFutureLevels

collections

List

Ptr

ParsingError

>>&

errors

) {

List

ParsingState

Future

resolvingFutures

;

CopyFrom

(

resolvingFutures

From

(

futures

) .Skip(

begin

) .Take(

end

begin

) );

for

(

vint

;

resolvableFutureLevels

;

++) {

for

(

vint

;

resolvingFutures

Count

();

++) {

resolvingFutures

[

] =

resolvingFutures

[

]->

; } }

Array

vint

conflictReduceIndices

;

vint

conflictReduceCount

GetConflictReduceCount

(

resolvingFutures

);

GetConflictReduceIndices

(

resolvingFutures

conflictReduceCount

conflictReduceIndices

);

WString

ambiguityNodeType

ambiguityRuleName

;

(

resolvingFutures

[

]->

selectedItem

instructions

Count

()==

conflictReduceIndices

[

]) {

vint

rootStartState

state

GetParsingRuleStartState

();

ambiguityNodeType

state

GetTable

()

GetStateInfo

(

rootStartState

ruleAmbiguousType

;

ambiguityRuleName

state

GetParsingRule

(); }

else

{

ParsingTable

Instruction

ins

resolvingFutures

[

]->

selectedItem

instructions

[

conflictReduceIndices

[

]];

ambiguityNodeType

state

GetTable

()

GetStateInfo

(

ins

stateParameter

ruleAmbiguousType

;

ambiguityRuleName

state

GetTable

()

GetStateInfo

(

ins

stateParameter

ruleName

; }

(

ambiguityNodeType

L""

) {

const

RegexToken

token

state

GetToken

(

state

GetCurrentToken

());

errors

Add

(

new

ParsingError

(

token

L"Ambiguity happens when reducing rule \""

ambiguityRuleName

L"\" but this rule does not have an associated ambiguous node type."

));

return

; }

vint

affectedStackNodeCount

GetAffectedStackNodeCount

(

resolvingFutures

conflictReduceIndices

);

(

affectedStackNodeCount

==-

) {

const

RegexToken

token

state

GetToken

(

state

GetCurrentToken

());

errors

Add

(

new

ParsingError

(

token

, (

token

L"Failed to pass ambiguity checking during parsing when reaching to the end of the input."

L"Failed to pass ambiguity checking during parsing."

)));

return

; }

Ptr

ParsingState

StateGroup

stateGroup

;

for

(

vint

;

resolvingFutures

Count

();

++) {

(

stateGroup

) {

state

RestoreSnapshot

(

stateGroup

); }

else

{

stateGroup

state

TakeSnapshot

(); } {

ParsingState

TransitionResult

result

(

ParsingState

TransitionResult

AmbiguityBegin

ParsingState

TransitionResult

AmbiguityBranch

);

(

) {

result

ambiguityAffectedStackNodeCount

affectedStackNodeCount

; }

decisions

Add

(

result

); } {

BuildSingleDecisionPath

(

state

resolvingFutures

[

conflictReduceIndices

[

]);

(

resolvingFutures

Count

()-

) {

ParsingState

TransitionResult

result

(

ParsingState

TransitionResult

AmbiguityEnd

);

result

ambiguityNodeType

;

decisions

Add

(

result

);

vint

start

conflictReduceIndices

[

];

ParsingState

TransitionResult

lastDecision

decisions

[

decisions

Count

()-

];

decisions

Add

(

state

RunTransition

(

lastDecision

transition

lastDecision

token

start

lastDecision

transition

instructions

Count

()-

start

true

)); } } }

ParsingState

Future

lastFuture

futures

[

end

];

ParsingState

Future

futureCleaner

lastFuture

;

for

(

int

;

resolvableFutureLevels

;

++) {

futureCleaner

=&(*

futureCleaner

)->

; } *

futureCleaner

;

(

lastFuture

) {

BuildSingleDecisionPath

(

state

lastFuture

, -

); } }

void

ParsingAmbiguousParser

BuildDecisions

(

ParsingState

state

collections

List

ParsingState

Future

*>&

futures

vint

begin

vint

end

vint

resolvableFutureLevels

collections

List

Ptr

ParsingError

>>&

errors

) {

(

end

begin

) {

const

RegexToken

token

state

GetToken

(

state

GetCurrentToken

());

errors

Add

(

new

ParsingError

(

token

, (

token

L"Error happened during parsing when reaching to the end of the input."

L"Error happened during parsing."

))); }

else

(

end

begin

) {

BuildSingleDecisionPath

(

state

futures

[

begin

], -

); }

else

{

BuildAmbiguousDecisions

(

state

futures

begin

end

resolvableFutureLevels

errors

); } }

ParsingState

TransitionResult

ParsingAmbiguousParser

ParseStep

(

ParsingState

state

collections

List

Ptr

ParsingError

>>&

errors

) {

(

decisions

Count

()==

consumedDecisionCount

) {

List

ParsingState

Future

futures

;

vint

resultBegin

;

vint

resultEnd

;

vint

resolvableFutureLevels

SearchPathForOneStep

(

state

futures

resultBegin

resultEnd

errors

);

BuildDecisions

(

state

futures

resultBegin

resultEnd

resolvableFutureLevels

errors

);

FOREACH(ParsingState::Future*, future, futures)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

ParsingState

Future

*>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

futures

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

ParsingState

Future

future

;

__foreach_iterator__

(

future

);)

{

delete

future

; } }

(

decisions

Count

()>

consumedDecisionCount

) {

ParsingState

TransitionResult

result

decisions

[

consumedDecisionCount

++];

(

consumedDecisionCount

decisions

Count

()) {

decisions

Clear

();

consumedDecisionCount

; }

return

result

; }

else

{

return

ParsingState

TransitionResult

(); } }

void

ParsingAmbiguousParser

BeginParse

() {

decisions

Clear

();

consumedDecisionCount

;

ParsingGeneralParser

BeginParse

(); }

/*********************************************************************** ParsingAutoRecoverAmbiguousParser ***********************************************************************/

void

ParsingAutoRecoverAmbiguousParser

OnErrorRecover

(

ParsingState

state

vint

currentTokenIndex

collections

List

ParsingState

Future

*>&

futures

vint

begin

vint

end

collections

List

Ptr

ParsingError

>>&

errors

) {

vint

insertedTokenCount

;

while

(

insertedTokenCount

++ <

maxInsertedTokenCount

) {

// keep all futures that consumed a token in a list

List

ParsingState

Future

consumedTokenFutures

;

vint

processBegin

begin

;

vint

processEnd

end

;

while

(

processEnd

processBegin

) {

// explore all tokens

for

(

vint

processBegin

;

processEnd

;

++) {

state

Explore

(

ParsingTable

TokenFinish

futures

[

futures

);

for

(

vint

token

ParsingTable

UserTokenStart

;

token

state

GetTable

()

GetTokenCount

();

token

++) {

state

Explore

(

token

futures

[

futures

); } }

// copy all futures that consumed a token to consumedTokenFutures

(

futures

Count

() >

processEnd

) {

CopyFrom

(

consumedTokenFutures

From

(

futures

) .Skip(

processEnd

) .Take(

futures

Count

() -

processEnd

true

);

futures

RemoveRange

(

processEnd

futures

Count

() -

processEnd

); }

// explore left recursive reduce and normal reduce

state

ExploreLeftRecursiveReduce

(

futures

processBegin

processEnd

processBegin

futures

);

state

ExploreNormalReduce

(

futures

processBegin

processEnd

processBegin

futures

);

// if a token is consumed, then for those reduce futures, explore them until a token is consumed, and discard all failed futures

processBegin

processEnd

;

processEnd

futures

Count

(); }

(

consumedTokenFutures

Count

() ==

) {

// failed to get any future that consumed a token

goto

ERROR_RECOVERY_FAILED; }

else

{

// try to see if the target token is reached

List

ParsingState

Future

recoveryFutures

;

FOREACH(ParsingState::Future*, future, consumedTokenFutures)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

ParsingState

Future

*>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

consumedTokenFutures

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

ParsingState

Future

future

;

__foreach_iterator__

(

future

);)

{

(

future

selectedToken

currentTokenIndex

) {

// because this is reached by error recoverying, so all futures in availableFutures should have previous futures

recoveryFutures

Add

(

future

); } }

(

recoveryFutures

Count

()>

) {

// finally reached the expected currentTokenIndex

// move these previous futures to the end

// then the original parser algorith, will use these previous futures to reach the currentTokenIndex in the next step

FOREACH(ParsingState::Future*, future, recoveryFutures)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

ParsingState

Future

*>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

recoveryFutures

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

ParsingState

Future

future

;

__foreach_iterator__

(

future

);)

{

futures

Remove

(

future

);

futures

Add

(

future

); }

begin

futures

Count

() -

recoveryFutures

Count

();

end

futures

Count

();

// delete all futures in consumedTokenFutures

FOREACH(ParsingState::Future*, future, consumedTokenFutures)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

ParsingState

Future

*>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

consumedTokenFutures

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

ParsingState

Future

future

;

__foreach_iterator__

(

future

);)

{

delete

future

; }

goto

ERROR_RECOVERY_SUCCEEDED; }

else

{

// put all futures that consumed a token from consumedTokenFutures back to future list

begin

futures

Count

();

CopyFrom

(

futures

consumedTokenFutures

true

);

end

futures

Count

(); } } }

// if the maxInsertedTokenCount is exceeded, then we get here

ERROR_RECOVERY_FAILED:

begin

end

futures

Count

();

return

; ERROR_RECOVERY_SUCCEEDED:

return

; }

ParsingAutoRecoverAmbiguousParser

(

Ptr

ParsingTable

_table

vint

_maxInsertedTokenCount

) :

ParsingAmbiguousParser

(

_table

) , maxInsertedTokenCount(

_maxInsertedTokenCount

== -

_maxInsertedTokenCount

) { }

ParsingAutoRecoverAmbiguousParser

() { }

/*********************************************************************** Helper Functions ***********************************************************************/

Ptr

ParsingGeneralParser

CreateStrictParser

(

Ptr

ParsingTable

table

) {

(

table

) {

(

table

GetAmbiguity

()) {

return

new

ParsingAmbiguousParser

(

table

); }

else

{

return

new

ParsingStrictParser

(

table

); } }

else

{

return

; } }

Ptr

ParsingGeneralParser

CreateAutoRecoverParser

(

Ptr

ParsingTable

table

) {

(

table

) {

(

table

GetAmbiguity

()) {

return

new

ParsingAutoRecoverAmbiguousParser

(

table

); }

else

{

return

new

ParsingAutoRecoverParser

(

table

); } }

else

{

return

; } }

Ptr

ParsingGeneralParser

CreateBootstrapStrictParser

() {

List

Ptr

ParsingError

errors

;

Ptr

ParsingDefinition

definition

CreateParserDefinition

();

Ptr

ParsingTable

table

GenerateTable

(

definition

false

errors

);

return

CreateStrictParser

(

table

); }

Ptr

ParsingGeneralParser

CreateBootstrapAutoRecoverParser

() {

List

Ptr

ParsingError

errors

;

Ptr

ParsingDefinition

definition

CreateParserDefinition

();

Ptr

ParsingTable

table

GenerateTable

(

definition

false

errors

);

return

CreateAutoRecoverParser

(

table

); } } } }

/*********************************************************************** Reflection ***********************************************************************/

#ifndef VCZH_DEBUG_NO_REFLECTION

namespace

{

namespace

reflection

{

namespace

description

{

using

namespace

parsing

;

PARSINGREFLECTION_TYPELIST(IMPL_VL_TYPE_INFO)

const

TypeInfoContent

TypeInfo

parsing

ParsingTextPos

>::

content

= {

L"parsing::ParsingTextPos"

nullptr

TypeInfoContent

VlppType

};

const

TypeInfoContent

TypeInfo

parsing

ParsingTextRange

>::

content

= {

L"parsing::ParsingTextRange"

nullptr

TypeInfoContent

VlppType

};

const

TypeInfoContent

TypeInfo

parsing

ParsingTreeNode

>::

content

= {

L"parsing::ParsingTreeNode"

nullptr

TypeInfoContent

VlppType

};

const

TypeInfoContent

TypeInfo

parsing

ParsingTreeToken

>::

content

= {

L"parsing::ParsingTreeToken"

nullptr

TypeInfoContent

VlppType

};

const

TypeInfoContent

TypeInfo

parsing

ParsingTreeObject

>::

content

= {

L"parsing::ParsingTreeObject"

nullptr

TypeInfoContent

VlppType

};

const

TypeInfoContent

TypeInfo

parsing

ParsingTreeArray

>::

content

= {

L"parsing::ParsingTreeArray"

nullptr

TypeInfoContent

VlppType

};

const

TypeInfoContent

TypeInfo

parsing

ParsingTreeCustomBase

>::

content

= {

L"parsing::ParsingTreeCustomBase"

nullptr

TypeInfoContent

VlppType

};

const

TypeInfoContent

TypeInfo

parsing

ParsingToken

>::

content

= {

L"parsing::ParsingToken"

nullptr

TypeInfoContent

VlppType

};

const

TypeInfoContent

TypeInfo

parsing

ParsingError

>::

content

= {

L"parsing::ParsingError"

nullptr

TypeInfoContent

VlppType

};

/*********************************************************************** Type Declaration ***********************************************************************/

#ifdef VCZH_DESCRIPTABLEOBJECT_WITH_METADATA

#define _ ,

BEGIN_STRUCT_MEMBER(ParsingTextPos)

template

struct

CustomTypeDescriptorSelector

ParsingTextPos

> {

public

class

CustomTypeDescriptorImpl

public

StructTypeDescriptor

ParsingTextPos

TypeDescriptorFlags

Struct

> {

typedef

ParsingTextPos

StructType

;

protected

void

LoadInternal

()

override

{

STRUCT_MEMBER(index)

fields

Add

(

L"index"

new

StructFieldInfo

decltype

(((

StructType

)->

index

)>(

this

, &

StructType

index

L"index"

));

STRUCT_MEMBER(row)

fields

Add

(

L"row"

new

StructFieldInfo

decltype

(((

StructType

)->

row

)>(

this

, &

StructType

row

L"row"

));

STRUCT_MEMBER(column)

fields

Add

(

L"column"

new

StructFieldInfo

decltype

(((

StructType

)->

column

)>(

this

, &

StructType

column

L"column"

));

END_STRUCT_MEMBER(ParsingTextPos)

} }; };

BEGIN_STRUCT_MEMBER(ParsingTextRange)

template

struct

CustomTypeDescriptorSelector

ParsingTextRange

> {

public

class

CustomTypeDescriptorImpl

public

StructTypeDescriptor

ParsingTextRange

TypeDescriptorFlags

Struct

> {

typedef

ParsingTextRange

StructType

;

protected

void

LoadInternal

()

override

{

STRUCT_MEMBER(start)

fields

Add

(

L"start"

new

StructFieldInfo

decltype

(((

StructType

)->

start

)>(

this

, &

StructType

start

L"start"

));

STRUCT_MEMBER(end)

fields

Add

(

L"end"

new

StructFieldInfo

decltype

(((

StructType

)->

end

)>(

this

, &

StructType

end

L"end"

));

END_STRUCT_MEMBER(ParsingTextRange)

} }; };

BEGIN_CLASS_MEMBER(ParsingTreeNode)

template

struct

CustomTypeDescriptorSelector

ParsingTreeNode

> {

public

class

CustomTypeDescriptorImpl

public

TypeDescriptorImpl

{

typedef

ParsingTreeNode

ClassType

;

static

const

TypeDescriptorFlags

TDFlags

TypeDescriptorFlags

Class

;

public

CustomTypeDescriptorImpl

() :

TypeDescriptorImpl

(

TDFlags

, &

TypeInfo

ParsingTreeNode

>::

content

) {

Description

ParsingTreeNode

>::

SetAssociatedTypeDescriptor

(

this

); }

CustomTypeDescriptorImpl

() {

Description

ParsingTreeNode

>::

SetAssociatedTypeDescriptor

(

); }

protected

bool

IsAggregatable

()

override

{

return

AcceptValue

typename

PointerConvertable

ParsingTreeNode

AggregatableDescription

ParsingTreeNode

>>::

YesNoType

>::

Result

; }

void

LoadInternal

()

override

{

CLASS_MEMBER_PROPERTY_FAST(CodeRange)

{

const

wchar_t

parameterNames

[]={

L""

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

GetCodeRange

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

GetCodeRange

))&

ClassType

GetCodeRange

nullptr

);

AddMethod

(

L"GetCodeRange"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

GetCodeRange

binaryDataRetriver

ClassType

GetCodeRange

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); } {

const

wchar_t

parameterNames

[]={

L"value"

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

SetCodeRange

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

SetCodeRange

))&

ClassType

SetCodeRange

nullptr

);

AddMethod

(

L"SetCodeRange"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

SetCodeRange

binaryDataRetriver

ClassType

SetCodeRange

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

AddProperty

(

new

PropertyInfoImpl

(

this

L"CodeRange"

dynamic_cast

MethodInfoImpl

*>(

GetMethodGroupByName

(

L"GetCodeRange"

true

)->GetMethod(

)),

dynamic_cast

MethodInfoImpl

*>(

GetMethodGroupByName

(

L"SetCodeRange"

true

)->GetMethod(

)),

nullptr

) );

CLASS_MEMBER_PROPERTY_READONLY_FAST(Parent)

{

const

wchar_t

parameterNames

[]={

L""

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

GetParent

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

GetParent

))&

ClassType

GetParent

nullptr

);

AddMethod

(

L"GetParent"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

GetParent

binaryDataRetriver

ClassType

GetParent

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

AddProperty

(

new

PropertyInfoImpl

(

this

L"Parent"

dynamic_cast

MethodInfoImpl

*>(

GetMethodGroupByName

(

L"GetParent"

true

)->GetMethod(

)),

nullptr

) );

CLASS_MEMBER_PROPERTY_READONLY_FAST(SubNodes)

{

const

wchar_t

parameterNames

[]={

L""

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

GetSubNodes

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

GetSubNodes

))&

ClassType

GetSubNodes

nullptr

);

AddMethod

(

L"GetSubNodes"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

GetSubNodes

binaryDataRetriver

ClassType

GetSubNodes

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

AddProperty

(

new

PropertyInfoImpl

(

this

L"SubNodes"

dynamic_cast

MethodInfoImpl

*>(

GetMethodGroupByName

(

L"GetSubNodes"

true

)->GetMethod(

)),

nullptr

) );

CLASS_MEMBER_METHOD(Clone, NO_PARAMETER)

{

const

wchar_t

parameterNames

[]={

L""

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

Clone

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

Clone

))&

ClassType

Clone

nullptr

);

AddMethod

(

L"Clone"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

Clone

binaryDataRetriver

ClassType

Clone

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

CLASS_MEMBER_METHOD(InitializeQueryCache, NO_PARAMETER)

{

const

wchar_t

parameterNames

[]={

L""

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

InitializeQueryCache

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

InitializeQueryCache

))&

ClassType

InitializeQueryCache

nullptr

);

AddMethod

(

L"InitializeQueryCache"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

InitializeQueryCache

binaryDataRetriver

ClassType

InitializeQueryCache

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

CLASS_MEMBER_METHOD(ClearQueryCache, NO_PARAMETER)

{

const

wchar_t

parameterNames

[]={

L""

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

ClearQueryCache

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

ClearQueryCache

))&

ClassType

ClearQueryCache

nullptr

);

AddMethod

(

L"ClearQueryCache"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

ClearQueryCache

binaryDataRetriver

ClassType

ClearQueryCache

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

CLASS_MEMBER_METHOD_OVERLOAD(FindSubNode, {L"position"}, ParsingTreeNode*(ParsingTreeNode::*)(const ParsingTextPos&))

{

const

wchar_t

parameterNames

[]={

L"position"

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

ParsingTreeNode

::*)(

const

ParsingTextPos

&)>::

FunctionType

> (

parameterNames

, (

ParsingTreeNode

::*)(

const

ParsingTextPos

&))&

ClassType

FindSubNode

nullptr

);

AddMethod

(

L"FindSubNode"

methodInfo

);

MethodPointerBinaryDataRetriver

ParsingTreeNode

::*)(

const

ParsingTextPos

&)>

binaryDataRetriver

ClassType

FindSubNode

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

CLASS_MEMBER_METHOD_OVERLOAD(FindSubNode, {L"range"}, ParsingTreeNode*(ParsingTreeNode::*)(const ParsingTextRange&))

{

const

wchar_t

parameterNames

[]={

L"range"

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

ParsingTreeNode

::*)(

const

ParsingTextRange

&)>::

FunctionType

> (

parameterNames

, (

ParsingTreeNode

::*)(

const

ParsingTextRange

&))&

ClassType

FindSubNode

nullptr

);

AddMethod

(

L"FindSubNode"

methodInfo

);

MethodPointerBinaryDataRetriver

ParsingTreeNode

::*)(

const

ParsingTextRange

&)>

binaryDataRetriver

ClassType

FindSubNode

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

CLASS_MEMBER_METHOD_OVERLOAD(FindDeepestNode, {L"position"}, ParsingTreeNode*(ParsingTreeNode::*)(const ParsingTextPos&))

{

const

wchar_t

parameterNames

[]={

L"position"

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

ParsingTreeNode

::*)(

const

ParsingTextPos

&)>::

FunctionType

> (

parameterNames

, (

ParsingTreeNode

::*)(

const

ParsingTextPos

&))&

ClassType

FindDeepestNode

nullptr

);

AddMethod

(

L"FindDeepestNode"

methodInfo

);

MethodPointerBinaryDataRetriver

ParsingTreeNode

::*)(

const

ParsingTextPos

&)>

binaryDataRetriver

ClassType

FindDeepestNode

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

CLASS_MEMBER_METHOD_OVERLOAD(FindDeepestNode, {L"range"}, ParsingTreeNode*(ParsingTreeNode::*)(const ParsingTextRange&))

{

const

wchar_t

parameterNames

[]={

L"range"

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

ParsingTreeNode

::*)(

const

ParsingTextRange

&)>::

FunctionType

> (

parameterNames

, (

ParsingTreeNode

::*)(

const

ParsingTextRange

&))&

ClassType

FindDeepestNode

nullptr

);

AddMethod

(

L"FindDeepestNode"

methodInfo

);

MethodPointerBinaryDataRetriver

ParsingTreeNode

::*)(

const

ParsingTextRange

&)>

binaryDataRetriver

ClassType

FindDeepestNode

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

END_CLASS_MEMBER(ParsingTreeNode)

(

GetBaseTypeDescriptorCount

() ==

)

AddBaseType

(

description

GetTypeDescriptor

DescriptableObject

>()); } }; };

BEGIN_CLASS_MEMBER(ParsingTreeToken)

template

struct

CustomTypeDescriptorSelector

ParsingTreeToken

> {

public

class

CustomTypeDescriptorImpl

public

TypeDescriptorImpl

{

typedef

ParsingTreeToken

ClassType

;

static

const

TypeDescriptorFlags

TDFlags

TypeDescriptorFlags

Class

;

public

CustomTypeDescriptorImpl

() :

TypeDescriptorImpl

(

TDFlags

, &

TypeInfo

ParsingTreeToken

>::

content

) {

Description

ParsingTreeToken

>::

SetAssociatedTypeDescriptor

(

this

); }

CustomTypeDescriptorImpl

() {

Description

ParsingTreeToken

>::

SetAssociatedTypeDescriptor

(

); }

protected

bool

IsAggregatable

()

override

{

return

AcceptValue

typename

PointerConvertable

ParsingTreeToken

AggregatableDescription

ParsingTreeToken

>>::

YesNoType

>::

Result

; }

void

LoadInternal

()

override

{

CLASS_MEMBER_CONSTRUCTOR(Ptr<ParsingTreeToken>(const WString&, vint), {L"value" _ L"tokenIndex"})

{

const

wchar_t

parameterNames

[]={

L"value"

L"tokenIndex"

};

AddConstructor

(

new

CustomConstructorInfoImpl

Ptr

ParsingTreeToken

const

WString

vint

)>(

parameterNames

)); }

CLASS_MEMBER_PROPERTY_FAST(TokenIndex)

{

const

wchar_t

parameterNames

[]={

L""

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

GetTokenIndex

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

GetTokenIndex

))&

ClassType

GetTokenIndex

nullptr

);

AddMethod

(

L"GetTokenIndex"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

GetTokenIndex

binaryDataRetriver

ClassType

GetTokenIndex

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); } {

const

wchar_t

parameterNames

[]={

L"value"

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

SetTokenIndex

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

SetTokenIndex

))&

ClassType

SetTokenIndex

nullptr

);

AddMethod

(

L"SetTokenIndex"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

SetTokenIndex

binaryDataRetriver

ClassType

SetTokenIndex

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

AddProperty

(

new

PropertyInfoImpl

(

this

L"TokenIndex"

dynamic_cast

MethodInfoImpl

*>(

GetMethodGroupByName

(

L"GetTokenIndex"

true

)->GetMethod(

)),

dynamic_cast

MethodInfoImpl

*>(

GetMethodGroupByName

(

L"SetTokenIndex"

true

)->GetMethod(

)),

nullptr

) );

CLASS_MEMBER_PROPERTY_FAST(Value)

{

const

wchar_t

parameterNames

[]={

L""

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

GetValue

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

GetValue

))&

ClassType

GetValue

nullptr

);

AddMethod

(

L"GetValue"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

GetValue

binaryDataRetriver

ClassType

GetValue

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); } {

const

wchar_t

parameterNames

[]={

L"value"

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

SetValue

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

SetValue

))&

ClassType

SetValue

nullptr

);

AddMethod

(

L"SetValue"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

SetValue

binaryDataRetriver

ClassType

SetValue

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

AddProperty

(

new

PropertyInfoImpl

(

this

L"Value"

dynamic_cast

MethodInfoImpl

*>(

GetMethodGroupByName

(

L"GetValue"

true

)->GetMethod(

)),

dynamic_cast

MethodInfoImpl

*>(

GetMethodGroupByName

(

L"SetValue"

true

)->GetMethod(

)),

nullptr

) );

END_CLASS_MEMBER(ParsingTreeToken)

(

GetBaseTypeDescriptorCount

() ==

)

AddBaseType

(

description

GetTypeDescriptor

DescriptableObject

>()); } }; };

BEGIN_CLASS_MEMBER(ParsingTreeObject)

template

struct

CustomTypeDescriptorSelector

ParsingTreeObject

> {

public

class

CustomTypeDescriptorImpl

public

TypeDescriptorImpl

{

typedef

ParsingTreeObject

ClassType

;

static

const

TypeDescriptorFlags

TDFlags

TypeDescriptorFlags

Class

;

public

CustomTypeDescriptorImpl

() :

TypeDescriptorImpl

(

TDFlags

, &

TypeInfo

ParsingTreeObject

>::

content

) {

Description

ParsingTreeObject

>::

SetAssociatedTypeDescriptor

(

this

); }

CustomTypeDescriptorImpl

() {

Description

ParsingTreeObject

>::

SetAssociatedTypeDescriptor

(

); }

protected

bool

IsAggregatable

()

override

{

return

AcceptValue

typename

PointerConvertable

ParsingTreeObject

AggregatableDescription

ParsingTreeObject

>>::

YesNoType

>::

Result

; }

void

LoadInternal

()

override

{

CLASS_MEMBER_CONSTRUCTOR(Ptr<ParsingTreeObject>(const WString&), {L"type"})

{

const

wchar_t

parameterNames

[]={

L"type"

};

AddConstructor

(

new

CustomConstructorInfoImpl

Ptr

ParsingTreeObject

const

WString

&)>(

parameterNames

)); }

CLASS_MEMBER_PROPERTY_FAST(Type)

{

const

wchar_t

parameterNames

[]={

L""

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

GetType

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

GetType

))&

ClassType

GetType

nullptr

);

AddMethod

(

L"GetType"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

GetType

binaryDataRetriver

ClassType

GetType

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); } {

const

wchar_t

parameterNames

[]={

L"value"

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

SetType

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

SetType

))&

ClassType

SetType

nullptr

);

AddMethod

(

L"SetType"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

SetType

binaryDataRetriver

ClassType

SetType

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

AddProperty

(

new

PropertyInfoImpl

(

this

L"Type"

dynamic_cast

MethodInfoImpl

*>(

GetMethodGroupByName

(

L"GetType"

true

)->GetMethod(

)),

dynamic_cast

MethodInfoImpl

*>(

GetMethodGroupByName

(

L"SetType"

true

)->GetMethod(

)),

nullptr

) );

CLASS_MEMBER_PROPERTY_READONLY_FAST(Members)

{

const

wchar_t

parameterNames

[]={

L""

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

GetMembers

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

GetMembers

))&

ClassType

GetMembers

nullptr

);

AddMethod

(

L"GetMembers"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

GetMembers

binaryDataRetriver

ClassType

GetMembers

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

AddProperty

(

new

PropertyInfoImpl

(

this

L"Members"

dynamic_cast

MethodInfoImpl

*>(

GetMethodGroupByName

(

L"GetMembers"

true

)->GetMethod(

)),

nullptr

) );

CLASS_MEMBER_PROPERTY_READONLY_FAST(MemberNames)

{

const

wchar_t

parameterNames

[]={

L""

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

GetMemberNames

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

GetMemberNames

))&

ClassType

GetMemberNames

nullptr

);

AddMethod

(

L"GetMemberNames"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

GetMemberNames

binaryDataRetriver

ClassType

GetMemberNames

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

AddProperty

(

new

PropertyInfoImpl

(

this

L"MemberNames"

dynamic_cast

MethodInfoImpl

*>(

GetMethodGroupByName

(

L"GetMemberNames"

true

)->GetMethod(

)),

nullptr

) );

CLASS_MEMBER_PROPERTY_READONLY_FAST(CreatorRules)

{

const

wchar_t

parameterNames

[]={

L""

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

GetCreatorRules

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

GetCreatorRules

))&

ClassType

GetCreatorRules

nullptr

);

AddMethod

(

L"GetCreatorRules"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

GetCreatorRules

binaryDataRetriver

ClassType

GetCreatorRules

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

AddProperty

(

new

PropertyInfoImpl

(

this

L"CreatorRules"

dynamic_cast

MethodInfoImpl

*>(

GetMethodGroupByName

(

L"GetCreatorRules"

true

)->GetMethod(

)),

nullptr

) );

CLASS_MEMBER_METHOD(GetMember, {L"name"})

{

const

wchar_t

parameterNames

[]={

L"name"

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

GetMember

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

GetMember

))&

ClassType

GetMember

nullptr

);

AddMethod

(

L"GetMember"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

GetMember

binaryDataRetriver

ClassType

GetMember

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

CLASS_MEMBER_METHOD(SetMember, {L"name" _ L"node"})

{

const

wchar_t

parameterNames

[]={

L"name"

L"node"

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

SetMember

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

SetMember

))&

ClassType

SetMember

nullptr

);

AddMethod

(

L"SetMember"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

SetMember

binaryDataRetriver

ClassType

SetMember

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

END_CLASS_MEMBER(ParsingTreeObject)

(

GetBaseTypeDescriptorCount

() ==

)

AddBaseType

(

description

GetTypeDescriptor

DescriptableObject

>()); } }; };

BEGIN_CLASS_MEMBER(ParsingTreeArray)

template

struct

CustomTypeDescriptorSelector

ParsingTreeArray

> {

public

class

CustomTypeDescriptorImpl

public

TypeDescriptorImpl

{

typedef

ParsingTreeArray

ClassType

;

static

const

TypeDescriptorFlags

TDFlags

TypeDescriptorFlags

Class

;

public

CustomTypeDescriptorImpl

() :

TypeDescriptorImpl

(

TDFlags

, &

TypeInfo

ParsingTreeArray

>::

content

) {

Description

ParsingTreeArray

>::

SetAssociatedTypeDescriptor

(

this

); }

CustomTypeDescriptorImpl

() {

Description

ParsingTreeArray

>::

SetAssociatedTypeDescriptor

(

); }

protected

bool

IsAggregatable

()

override

{

return

AcceptValue

typename

PointerConvertable

ParsingTreeArray

AggregatableDescription

ParsingTreeArray

>>::

YesNoType

>::

Result

; }

void

LoadInternal

()

override

{

CLASS_MEMBER_CONSTRUCTOR(Ptr<ParsingTreeObject>(const WString&), {L"elementType"})

{

const

wchar_t

parameterNames

[]={

L"elementType"

};

AddConstructor

(

new

CustomConstructorInfoImpl

Ptr

ParsingTreeObject

const

WString

&)>(

parameterNames

)); }

CLASS_MEMBER_PROPERTY_FAST(ElementType)

{

const

wchar_t

parameterNames

[]={

L""

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

GetElementType

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

GetElementType

))&

ClassType

GetElementType

nullptr

);

AddMethod

(

L"GetElementType"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

GetElementType

binaryDataRetriver

ClassType

GetElementType

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); } {

const

wchar_t

parameterNames

[]={

L"value"

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

SetElementType

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

SetElementType

))&

ClassType

SetElementType

nullptr

);

AddMethod

(

L"SetElementType"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

SetElementType

binaryDataRetriver

ClassType

SetElementType

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

AddProperty

(

new

PropertyInfoImpl

(

this

L"ElementType"

dynamic_cast

MethodInfoImpl

*>(

GetMethodGroupByName

(

L"GetElementType"

true

)->GetMethod(

)),

dynamic_cast

MethodInfoImpl

*>(

GetMethodGroupByName

(

L"SetElementType"

true

)->GetMethod(

)),

nullptr

) );

CLASS_MEMBER_PROPERTY_READONLY_FAST(Items)

{

const

wchar_t

parameterNames

[]={

L""

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

GetItems

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

GetItems

))&

ClassType

GetItems

nullptr

);

AddMethod

(

L"GetItems"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

GetItems

binaryDataRetriver

ClassType

GetItems

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

AddProperty

(

new

PropertyInfoImpl

(

this

L"Items"

dynamic_cast

MethodInfoImpl

*>(

GetMethodGroupByName

(

L"GetItems"

true

)->GetMethod(

)),

nullptr

) );

CLASS_MEMBER_METHOD(GetItem, {L"index"})

{

const

wchar_t

parameterNames

[]={

L"index"

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

GetItem

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

GetItem

))&

ClassType

GetItem

nullptr

);

AddMethod

(

L"GetItem"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

GetItem

binaryDataRetriver

ClassType

GetItem

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

CLASS_MEMBER_METHOD(SetItem, {L"index" _ L"node"})

{

const

wchar_t

parameterNames

[]={

L"index"

L"node"

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

SetItem

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

SetItem

))&

ClassType

SetItem

nullptr

);

AddMethod

(

L"SetItem"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

SetItem

binaryDataRetriver

ClassType

SetItem

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

CLASS_MEMBER_METHOD(AddItem, {L"node"})

{

const

wchar_t

parameterNames

[]={

L"node"

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

AddItem

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

AddItem

))&

ClassType

AddItem

nullptr

);

AddMethod

(

L"AddItem"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

AddItem

binaryDataRetriver

ClassType

AddItem

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

CLASS_MEMBER_METHOD(InsertItem, {L"index" _ L"node"})

{

const

wchar_t

parameterNames

[]={

L"index"

L"node"

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

InsertItem

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

InsertItem

))&

ClassType

InsertItem

nullptr

);

AddMethod

(

L"InsertItem"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

InsertItem

binaryDataRetriver

ClassType

InsertItem

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

CLASS_MEMBER_METHOD_OVERLOAD(RemoveItem, {L"index"}, bool(ParsingTreeArray::*)(vint))

{

const

wchar_t

parameterNames

[]={

L"index"

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

bool

(

ParsingTreeArray

::*)(

vint

)>::

FunctionType

> (

parameterNames

, (

bool

(

ParsingTreeArray

::*)(

vint

))&

ClassType

RemoveItem

nullptr

);

AddMethod

(

L"RemoveItem"

methodInfo

);

MethodPointerBinaryDataRetriver

bool

(

ParsingTreeArray

::*)(

vint

binaryDataRetriver

ClassType

RemoveItem

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

CLASS_MEMBER_METHOD_OVERLOAD(RemoveItem, {L"node"}, bool(ParsingTreeArray::*)(ParsingTreeNode*))

{

const

wchar_t

parameterNames

[]={

L"node"

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

bool

(

ParsingTreeArray

::*)(

ParsingTreeNode

*)>::

FunctionType

> (

parameterNames

, (

bool

(

ParsingTreeArray

::*)(

ParsingTreeNode

*))&

ClassType

RemoveItem

nullptr

);

AddMethod

(

L"RemoveItem"

methodInfo

);

MethodPointerBinaryDataRetriver

bool

(

ParsingTreeArray

::*)(

ParsingTreeNode

*)>

binaryDataRetriver

ClassType

RemoveItem

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

CLASS_MEMBER_METHOD(IndexOfItem, {L"node"})

{

const

wchar_t

parameterNames

[]={

L"node"

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

IndexOfItem

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

IndexOfItem

))&

ClassType

IndexOfItem

nullptr

);

AddMethod

(

L"IndexOfItem"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

IndexOfItem

binaryDataRetriver

ClassType

IndexOfItem

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

CLASS_MEMBER_METHOD(ContainsItem, {L"node"})

{

const

wchar_t

parameterNames

[]={

L"node"

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

ContainsItem

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

ContainsItem

))&

ClassType

ContainsItem

nullptr

);

AddMethod

(

L"ContainsItem"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

ContainsItem

binaryDataRetriver

ClassType

ContainsItem

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

CLASS_MEMBER_METHOD(Clone, NO_PARAMETER)

{

const

wchar_t

parameterNames

[]={

L""

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

Clone

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

Clone

))&

ClassType

Clone

nullptr

);

AddMethod

(

L"Clone"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

Clone

binaryDataRetriver

ClassType

Clone

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

CLASS_MEMBER_METHOD_RENAME(GetCount, Count, NO_PARAMETER)

{

const

wchar_t

parameterNames

[]={

L""

};

auto

methodInfo

new

CustomMethodInfoImpl

ClassType

function_lambda

LambdaRetriveType

decltype

ClassType

Count

)>::

FunctionType

> (

parameterNames

, (

decltype

ClassType

Count

))&

ClassType

Count

L"$This->"

L"Count"

L"($Arguments)"

L"::vl::Func<$Func>($This, &$Type::"

L"Count"

L")"

);

AddMethod

(

L"GetCount"

methodInfo

);

MethodPointerBinaryDataRetriver

decltype

ClassType

Count

binaryDataRetriver

ClassType

Count

);

MethodPointerBinaryDataRecorder

ClassType

TDFlags

>::

RecordMethod

(

binaryDataRetriver

GetBinaryData

(),

this

methodInfo

); }

CLASS_MEMBER_PROPERTY_READONLY(Count, GetCount)

AddProperty

(

new

PropertyInfoImpl

(

this

L"Count"

dynamic_cast

MethodInfoImpl

*>(

GetMethodGroupByName

(

L"GetCount"

true

)->GetMethod(

)),

nullptr

) );

END_CLASS_MEMBER(ParsingTreeArray)

(

GetBaseTypeDescriptorCount

() ==

)

AddBaseType

(

description

GetTypeDescriptor

DescriptableObject

>()); } }; };

BEGIN_CLASS_MEMBER(ParsingTreeCustomBase)

template

struct

CustomTypeDescriptorSelector

ParsingTreeCustomBase

> {

public

class

CustomTypeDescriptorImpl

public

TypeDescriptorImpl

{

typedef

ParsingTreeCustomBase

ClassType

;

static

const

TypeDescriptorFlags

TDFlags

TypeDescriptorFlags

Class

;

public

CustomTypeDescriptorImpl

() :

TypeDescriptorImpl

(

TDFlags

, &

TypeInfo

ParsingTreeCustomBase

>::

content

) {

Description

ParsingTreeCustomBase

>::

SetAssociatedTypeDescriptor

(

this

); }

CustomTypeDescriptorImpl

() {

Description

ParsingTreeCustomBase

>::

SetAssociatedTypeDescriptor

(

); }

protected

bool

IsAggregatable

()

override

{

return

AcceptValue

typename

PointerConvertable

ParsingTreeCustomBase

AggregatableDescription

ParsingTreeCustomBase

>>::

YesNoType

>::

Result

; }

void

LoadInternal

()

override

{

CLASS_MEMBER_FIELD(codeRange)

AddProperty

(

new

CustomFieldInfoImpl

ClassType

decltype

(((

ClassType

)->

codeRange

) >(

this

L"codeRange"

, &

ClassType

codeRange

) );

CLASS_MEMBER_FIELD(creatorRules)

AddProperty

(

new

CustomFieldInfoImpl

ClassType

decltype

(((

ClassType

)->

creatorRules

) >(

this

L"creatorRules"

, &

ClassType

creatorRules

) );

END_CLASS_MEMBER(ParsingTreeCustomBase)

(

GetBaseTypeDescriptorCount

() ==

)

AddBaseType

(

description

GetTypeDescriptor

DescriptableObject

>()); } }; };

BEGIN_CLASS_MEMBER(ParsingToken)

template

struct

CustomTypeDescriptorSelector

ParsingToken

> {

public

class

CustomTypeDescriptorImpl

public

TypeDescriptorImpl

{

typedef

ParsingToken

ClassType

;

static

const

TypeDescriptorFlags

TDFlags

TypeDescriptorFlags

Class

;

public

CustomTypeDescriptorImpl

() :

TypeDescriptorImpl

(

TDFlags

, &

TypeInfo

ParsingToken

>::

content

) {

Description

ParsingToken

>::

SetAssociatedTypeDescriptor

(

this

); }

CustomTypeDescriptorImpl

() {

Description

ParsingToken

>::

SetAssociatedTypeDescriptor

(

); }

protected

bool

IsAggregatable

()

override

{

return

AcceptValue

typename

PointerConvertable

ParsingToken

AggregatableDescription

ParsingToken

>>::

YesNoType

>::

Result

; }

void

LoadInternal

()

override

{

CLASS_MEMBER_BASE(ParsingTreeCustomBase)

AddBaseType

(

description

GetTypeDescriptor

ParsingTreeCustomBase

>());

CLASS_MEMBER_FIELD(tokenIndex)

AddProperty

(

new

CustomFieldInfoImpl

ClassType

decltype

(((

ClassType

)->

tokenIndex

) >(

this

L"tokenIndex"

, &

ClassType

tokenIndex

) );

CLASS_MEMBER_FIELD(value)

AddProperty

(

new

CustomFieldInfoImpl

ClassType

decltype

(((

ClassType

)->

value

) >(

this

L"value"

, &

ClassType

value

) );

END_CLASS_MEMBER(ParsingToken)

(

GetBaseTypeDescriptorCount

() ==

)

AddBaseType

(

description

GetTypeDescriptor

DescriptableObject

>()); } }; };

BEGIN_CLASS_MEMBER(ParsingError)

template

struct

CustomTypeDescriptorSelector

ParsingError

> {

public

class

CustomTypeDescriptorImpl

public

TypeDescriptorImpl

{

typedef

ParsingError

ClassType

;

static

const

TypeDescriptorFlags

TDFlags

TypeDescriptorFlags

Class

;

public

CustomTypeDescriptorImpl

() :

TypeDescriptorImpl

(

TDFlags

, &

TypeInfo

ParsingError

>::

content

) {

Description

ParsingError

>::

SetAssociatedTypeDescriptor

(

this

); }

CustomTypeDescriptorImpl

() {

Description

ParsingError

>::

SetAssociatedTypeDescriptor

(

); }

protected

bool

IsAggregatable

()

override

{

return

AcceptValue

typename

PointerConvertable

ParsingError

AggregatableDescription

ParsingError

>>::

YesNoType

>::

Result

; }

void

LoadInternal

()

override

{

CLASS_MEMBER_CONSTRUCTOR(Ptr<ParsingError>(), NO_PARAMETER)

{

const

wchar_t

parameterNames

[]={

L""

};

AddConstructor

(

new

CustomConstructorInfoImpl

Ptr

ParsingError

>()>(

parameterNames

)); }

CLASS_MEMBER_CONSTRUCTOR(Ptr<ParsingError>(const WString&), {L"errorMessage"})

{

const

wchar_t

parameterNames

[]={

L"errorMessage"

};

AddConstructor

(

new

CustomConstructorInfoImpl

Ptr

ParsingError

const

WString

&)>(

parameterNames

)); }

CLASS_MEMBER_CONSTRUCTOR(Ptr<ParsingError>(ParsingTreeCustomBase*, const WString&), {L"parsingTree" _ L"errorMessage"})

{

const

wchar_t

parameterNames

[]={

L"parsingTree"

L"errorMessage"

};

AddConstructor

(

new

CustomConstructorInfoImpl

Ptr

ParsingError

ParsingTreeCustomBase

const

WString

&)>(

parameterNames

)); }

CLASS_MEMBER_FIELD(codeRange)

AddProperty

(

new

CustomFieldInfoImpl

ClassType

decltype

(((

ClassType

)->

codeRange

) >(

this

L"codeRange"

, &

ClassType

codeRange

) );

CLASS_MEMBER_FIELD(parsingTree)

AddProperty

(

new

CustomFieldInfoImpl

ClassType

decltype

(((

ClassType

)->

parsingTree

) >(

this

L"parsingTree"

, &

ClassType

parsingTree

) );

CLASS_MEMBER_FIELD(errorMessage)

AddProperty

(

new

CustomFieldInfoImpl

ClassType

decltype

(((

ClassType

)->

errorMessage

) >(

this

L"errorMessage"

, &

ClassType

errorMessage

) );

END_CLASS_MEMBER(ParsingError)

(

GetBaseTypeDescriptorCount

() ==

)

AddBaseType

(

description

GetTypeDescriptor

DescriptableObject

>()); } }; };

#undef _ #endif

} } }

#endif

namespace

{

namespace

reflection

{

namespace

description

{

/*********************************************************************** Type Loader ***********************************************************************/

#ifdef VCZH_DESCRIPTABLEOBJECT_WITH_METADATA

class

ParsingTypeLoader

public

Object

public

ITypeLoader

{

public

void

Load

(

ITypeManager

manager

) {

PARSINGREFLECTION_TYPELIST(ADD_TYPE_INFO)

{

Ptr

ITypeDescriptor

type

new

CustomTypeDescriptorSelector

parsing

ParsingTextPos

>::

CustomTypeDescriptorImpl

();

manager

SetTypeDescriptor

(

TypeInfo

parsing

ParsingTextPos

>::

content

.typeName,

type

); } {

Ptr

ITypeDescriptor

type

new

CustomTypeDescriptorSelector

parsing

ParsingTextRange

>::

CustomTypeDescriptorImpl

();

manager

SetTypeDescriptor

(

TypeInfo

parsing

ParsingTextRange

>::

content

.typeName,

type

); } {

Ptr

ITypeDescriptor

type

new

CustomTypeDescriptorSelector

parsing

ParsingTreeNode

>::

CustomTypeDescriptorImpl

();

manager

SetTypeDescriptor

(

TypeInfo

parsing

ParsingTreeNode

>::

content

.typeName,

type

); } {

Ptr

ITypeDescriptor

type

new

CustomTypeDescriptorSelector

parsing

ParsingTreeToken

>::

CustomTypeDescriptorImpl

();

manager

SetTypeDescriptor

(

TypeInfo

parsing

ParsingTreeToken

>::

content

.typeName,

type

); } {

Ptr

ITypeDescriptor

type

new

CustomTypeDescriptorSelector

parsing

ParsingTreeObject

>::

CustomTypeDescriptorImpl

();

manager

SetTypeDescriptor

(

TypeInfo

parsing

ParsingTreeObject

>::

content

.typeName,

type

); } {

Ptr

ITypeDescriptor

type

new

CustomTypeDescriptorSelector

parsing

ParsingTreeArray

>::

CustomTypeDescriptorImpl

();

manager

SetTypeDescriptor

(

TypeInfo

parsing

ParsingTreeArray

>::

content

.typeName,

type

); } {

Ptr

ITypeDescriptor

type

new

CustomTypeDescriptorSelector

parsing

ParsingTreeCustomBase

>::

CustomTypeDescriptorImpl

();

manager

SetTypeDescriptor

(

TypeInfo

parsing

ParsingTreeCustomBase

>::

content

.typeName,

type

); } {

Ptr

ITypeDescriptor

type

new

CustomTypeDescriptorSelector

parsing

ParsingToken

>::

CustomTypeDescriptorImpl

();

manager

SetTypeDescriptor

(

TypeInfo

parsing

ParsingToken

>::

content

.typeName,

type

); } {

Ptr

ITypeDescriptor

type

new

CustomTypeDescriptorSelector

parsing

ParsingError

>::

CustomTypeDescriptorImpl

();

manager

SetTypeDescriptor

(

TypeInfo

parsing

ParsingError

>::

content

.typeName,

type

); }

}

void

Unload

(

ITypeManager

manager

) { } };

#endif

bool

LoadParsingTypes

() {

#ifdef VCZH_DESCRIPTABLEOBJECT_WITH_METADATA

ITypeManager

manager

GetGlobalTypeManager

();

(

manager

) {

Ptr

ITypeLoader

loader

new

ParsingTypeLoader

;

return

manager

AddTypeLoader

(

loader

); }

#endif

return

false

; } } } }