ParsingTree.cpp

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

#include "ParsingTree.h"

#if defined(VCZH_GCC) && defined(__clang__)

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wnull-dereference" #endif

namespace

{

using

namespace

collections

;

namespace

parsing

{

vint

CompareTextRange

(

Ptr

ParsingTreeNode

Ptr

ParsingTreeNode

) {

return

ParsingTextPos

Compare

(

GetCodeRange

().

start

GetCodeRange

().

start

); }

/*********************************************************************** ParsingTreeNode::TraversalVisitor ***********************************************************************/

ParsingTreeNode

TraversalVisitor

(

TraverseDirection

_direction

) :direction(

_direction

) { }

void

ParsingTreeNode

TraversalVisitor

BeforeVisit

(

ParsingTreeToken

node

) { }

void

ParsingTreeNode

TraversalVisitor

AfterVisit

(

ParsingTreeToken

node

) { }

void

ParsingTreeNode

TraversalVisitor

BeforeVisit

(

ParsingTreeObject

node

) { }

void

ParsingTreeNode

TraversalVisitor

AfterVisit

(

ParsingTreeObject

node

) { }

void

ParsingTreeNode

TraversalVisitor

BeforeVisit

(

ParsingTreeArray

node

) { }

void

ParsingTreeNode

TraversalVisitor

AfterVisit

(

ParsingTreeArray

node

) { }

void

ParsingTreeNode

TraversalVisitor

Visit

(

ParsingTreeToken

node

) {

BeforeVisit

(

node

);

AfterVisit

(

node

); }

void

ParsingTreeNode

TraversalVisitor

Visit

(

ParsingTreeObject

node

) {

BeforeVisit

(

node

);

switch

(

direction

) {

case

TraverseDirection

ByTextPosition

: {

FOREACH(Ptr<ParsingTreeNode>, node, node->GetSubNodes())

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

ParsingTreeNode

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

GetSubNodes

());

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

ParsingTreeNode

node

;

__foreach_iterator__

(

node

);)

{

node

(

this

); } }

break

;

case

TraverseDirection

ByStorePosition

: {

FOREACH(Ptr<ParsingTreeNode>, node, node->GetMembers().Values())

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

ParsingTreeNode

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

GetMembers

().

Values

());

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

ParsingTreeNode

node

;

__foreach_iterator__

(

node

);)

{

node

(

this

); } }

break

; }

AfterVisit

(

node

); }

void

ParsingTreeNode

TraversalVisitor

Visit

(

ParsingTreeArray

node

) {

BeforeVisit

(

node

);

switch

(

direction

) {

case

TraverseDirection

ByTextPosition

: {

FOREACH(Ptr<ParsingTreeNode>, node, node->GetSubNodes())

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

ParsingTreeNode

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

GetSubNodes

());

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

ParsingTreeNode

node

;

__foreach_iterator__

(

node

);)

{

node

(

this

); } }

break

;

case

TraverseDirection

ByStorePosition

: {

FOREACH(Ptr<ParsingTreeNode>, node, node->GetItems())

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

ParsingTreeNode

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

GetItems

());

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

ParsingTreeNode

node

;

__foreach_iterator__

(

node

);)

{

node

(

this

); } }

break

; }

AfterVisit

(

node

); }

/*********************************************************************** ParsingTreeNode ***********************************************************************/

bool

ParsingTreeNode

BeforeAddChild

(

Ptr

ParsingTreeNode

node

) {

return

node

parent

; }

void

ParsingTreeNode

AfterAddChild

(

Ptr

ParsingTreeNode

node

) {

node

parent

this

;

ClearQueryCache

(); }

bool

ParsingTreeNode

BeforeRemoveChild

(

Ptr

ParsingTreeNode

node

) {

return

node

parent

; }

void

ParsingTreeNode

AfterRemoveChild

(

Ptr

ParsingTreeNode

node

) {

node

parent

;

ClearQueryCache

(); }

ParsingTreeNode

(

const

ParsingTextRange

_codeRange

) :codeRange(

_codeRange

) ,parent(

) { }

ParsingTreeNode

() { }

ParsingTextRange

ParsingTreeNode

GetCodeRange

() {

return

codeRange

; }

void

ParsingTreeNode

SetCodeRange

(

const

ParsingTextRange

range

) {

codeRange

range

; }

void

ParsingTreeNode

InitializeQueryCache

() {

const

NodeList

subNodes

GetSubNodesInternal

();

ClearQueryCache

();

auto

subNodesExists

= &

subNodes

;

(

subNodesExists

) {

FOREACH(Ptr<ParsingTreeNode>, node, subNodes)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

ParsingTreeNode

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

subNodes

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

ParsingTreeNode

node

;

__foreach_iterator__

(

node

);)

{

node

InitializeQueryCache

(); }

//if (codeRange.start.IsInvalid() || codeRange.start.IsInvalid())

{

FOREACH(Ptr<ParsingTreeNode>, subNode, subNodes)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

ParsingTreeNode

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

subNodes

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

ParsingTreeNode

subNode

;

__foreach_iterator__

(

subNode

);)

{

const

auto

subRange

subNode

codeRange

;

const

auto

min

= !

subRange

start

IsInvalid

() ?

subRange

start

subRange

end

;

const

auto

max

= !

subRange

end

IsInvalid

() ?

subRange

end

subRange

start

;

(

codeRange

start

IsInvalid

() || (!

min

IsInvalid

() &&

codeRange

start

min

)) {

codeRange

start

min

; }

(

codeRange

end

IsInvalid

() || (!

max

IsInvalid

() &&

codeRange

end

max

)) {

codeRange

end

max

; } } }

CopyFrom

(

cachedOrderedSubNodes

From

(

subNodes

) .

Where

([=](

Ptr

ParsingTreeNode

node

) {

const

auto

range

node

GetCodeRange

();

return

range

start

IsInvalid

() && !

range

end

IsInvalid

(); }) .

OrderBy

CompareTextRange

) ); } }

void

ParsingTreeNode

ClearQueryCache

() {

cachedOrderedSubNodes

Clear

(); }

ParsingTreeNode

GetParent

() {

return

parent

; }

const

ParsingTreeNode

NodeList

ParsingTreeNode

GetSubNodes

() {

return

cachedOrderedSubNodes

; }

ParsingTreeNode

FindSubNode

(

const

ParsingTextPos

position

) {

return

FindSubNode

(

ParsingTextRange

(

position

)); }

ParsingTreeNode

FindSubNode

(

const

ParsingTextRange

range

) {

(

codeRange

start

range

start

range

end

codeRange

end

) {

vint

start

;

vint

end

cachedOrderedSubNodes

Count

() -

;

while

(

start

end

) {

vint

selected

= (

start

end

) /

;

ParsingTreeNode

selectedNode

cachedOrderedSubNodes

[

selected

Obj

();

const

ParsingTextRange

selectedRange

selectedNode

codeRange

;

(

range

end

selectedRange

start

) {

end

selected

; }

else

(

range

start

selectedRange

end

) {

start

selected

; }

else

(

selectedRange

start

range

start

range

end

selectedRange

end

) {

return

selectedNode

; }

else

{

return

this

; } } }

return

this

; }

ParsingTreeNode

FindDeepestNode

(

const

ParsingTextPos

position

) {

return

FindDeepestNode

(

ParsingTextRange

(

position

)); }

ParsingTreeNode

FindDeepestNode

(

const

ParsingTextRange

range

) {

ParsingTreeNode

result

;

ParsingTreeNode

node

this

;

{

result

node

;

node

FindSubNode

(

range

); }

while

(

result

node

);

return

result

; }

/*********************************************************************** ParsingTreeToken ***********************************************************************/

const

ParsingTreeToken

NodeList

ParsingTreeToken

GetSubNodesInternal

() {

return

NodeList

; }

ParsingTreeToken

(

const

WString

_value

vint

_tokenIndex

const

ParsingTextRange

_codeRange

) :

ParsingTreeNode

(

_codeRange

) ,value(

_value

) ,tokenIndex(

_tokenIndex

) { }

ParsingTreeToken

() { }

void

ParsingTreeToken

(

IVisitor

visitor

) {

visitor

Visit

(

this

); }

Ptr

ParsingTreeNode

ParsingTreeToken

Clone

() {

Ptr

ParsingTreeToken

clone

new

ParsingTreeToken

(

value

tokenIndex

codeRange

);

return

clone

; }

vint

ParsingTreeToken

GetTokenIndex

() {

return

tokenIndex

; }

void

ParsingTreeToken

SetTokenIndex

(

vint

_tokenIndex

) {

tokenIndex

_tokenIndex

; }

const

WString

ParsingTreeToken

GetValue

() {

return

value

; }

void

ParsingTreeToken

SetValue

(

const

WString

_value

) {

value

_value

; }

/*********************************************************************** ParsingTreeObject ***********************************************************************/

const

ParsingTreeObject

NodeList

ParsingTreeObject

GetSubNodesInternal

() {

return

members

Values

(); }

ParsingTreeObject

(

const

WString

_type

const

ParsingTextRange

_codeRange

) :

ParsingTreeNode

(

_codeRange

) ,type(

_type

) { }

ParsingTreeObject

() { }

void

ParsingTreeObject

(

IVisitor

visitor

) {

visitor

Visit

(

this

); }

Ptr

ParsingTreeNode

ParsingTreeObject

Clone

() {

Ptr

ParsingTreeObject

clone

new

ParsingTreeObject

(

type

codeRange

);

CopyFrom

(

clone

rules

);

for

(

vint

;

members

Count

();

++) {

WString

name

members

Keys

().

Get

(

);

Ptr

ParsingTreeNode

node

members

Values

().

Get

(

)

Clone

();

clone

SetMember

(

name

node

); }

return

clone

; }

const

WString

ParsingTreeObject

GetType

() {

return

type

; }

void

ParsingTreeObject

SetType

(

const

WString

_type

) {

type

_type

; }

ParsingTreeObject

NodeMap

ParsingTreeObject

GetMembers

() {

return

members

; }

Ptr

ParsingTreeNode

ParsingTreeObject

GetMember

(

const

WString

name

) {

vint

index

members

Keys

().

IndexOf

(

name

);

(

index

==-

)

return

;

return

members

Values

().

Get

(

index

); }

bool

ParsingTreeObject

SetMember

(

const

WString

name

Ptr

ParsingTreeNode

node

) {

vint

index

members

Keys

().

IndexOf

(

name

);

(

index

!=-

) {

Ptr

ParsingTreeNode

members

Values

().

Get

(

index

);

(

node

)

return

true

;

BeforeRemoveChild

(

) || !

BeforeAddChild

(

node

))

return

false

;

members

Remove

(

name

);

AfterRemoveChild

(

); }

members

Add

(

name

node

);

AfterAddChild

(

node

);

return

true

; }

bool

ParsingTreeObject

RemoveMember

(

const

WString

name

) {

vint

index

members

Keys

().

IndexOf

(

name

);

(

index

!=-

) {

Ptr

ParsingTreeNode

members

Values

().

Get

(

index

);

(

BeforeRemoveChild

(

)) {

members

Remove

(

name

);

AfterRemoveChild

(

);

return

true

; } }

return

false

; }

const

ParsingTreeObject

NameList

ParsingTreeObject

GetMemberNames

() {

return

members

Keys

(); }

ParsingTreeObject

RuleList

ParsingTreeObject

GetCreatorRules

() {

return

rules

; }

/*********************************************************************** ParsingTreeArray ***********************************************************************/

const

ParsingTreeArray

NodeList

ParsingTreeArray

GetSubNodesInternal

() {

return

items

; }

ParsingTreeArray

(

const

WString

_elementType

const

ParsingTextRange

_codeRange

) :

ParsingTreeNode

(

_codeRange

) ,elementType(

_elementType

) { }

ParsingTreeArray

() { }

void

ParsingTreeArray

(

IVisitor

visitor

) {

visitor

Visit

(

this

); }

Ptr

ParsingTreeNode

ParsingTreeArray

Clone

() {

Ptr

ParsingTreeArray

clone

new

ParsingTreeArray

(

elementType

codeRange

);

for

(

vint

;

items

Count

();

++) {

Ptr

ParsingTreeNode

node

items

Get

(

)

Clone

();

clone

AddItem

(

node

); }

return

clone

; }

const

WString

ParsingTreeArray

GetElementType

() {

return

elementType

; }

void

ParsingTreeArray

SetElementType

(

const

WString

_elementType

) {

elementType

_elementType

; }

ParsingTreeArray

NodeArray

ParsingTreeArray

GetItems

() {

return

items

; }

Ptr

ParsingTreeNode

ParsingTreeArray

GetItem

(

vint

index

) {

(

index

items

Count

()) {

return

items

[

index

]; }

else

{

return

; } }

bool

ParsingTreeArray

SetItem

(

vint

index

Ptr

ParsingTreeNode

node

) {

(

index

items

Count

()) {

items

[

index

]

node

;

return

true

; }

else

{

return

false

; } }

bool

ParsingTreeArray

AddItem

(

Ptr

ParsingTreeNode

node

) {

return

InsertItem

(

items

Count

(),

node

); }

bool

ParsingTreeArray

InsertItem

(

vint

index

Ptr

ParsingTreeNode

node

) {

(

index

items

Count

()) {

(

BeforeAddChild

(

node

)) {

items

Insert

(

index

node

);

AfterAddChild

(

node

);

return

true

; } }

return

false

; }

bool

ParsingTreeArray

RemoveItem

(

vint

index

) {

(

index

items

Count

()) {

Ptr

ParsingTreeNode

items

[

index

];

(

BeforeRemoveChild

(

)) {

items

RemoveAt

(

index

);

AfterRemoveChild

(

);

return

true

; } }

return

false

; }

bool

ParsingTreeArray

RemoveItem

(

ParsingTreeNode

node

) {

return

RemoveItem

(

items

IndexOf

(

node

)); }

vint

ParsingTreeArray

IndexOfItem

(

ParsingTreeNode

node

) {

return

items

IndexOf

(

node

); }

bool

ParsingTreeArray

ContainsItem

(

ParsingTreeNode

node

) {

return

items

Contains

(

node

); }

vint

ParsingTreeArray

Count

() {

return

items

Count

(); }

bool

ParsingTreeArray

Clear

() {

FOREACH(Ptr<ParsingTreeNode>, node, items)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

ParsingTreeNode

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

items

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

ParsingTreeNode

node

;

__foreach_iterator__

(

node

);)

{

BeforeRemoveChild

(

node

))

return

false

; }

FOREACH(Ptr<ParsingTreeNode>, node, items)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

ParsingTreeNode

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

items

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

ParsingTreeNode

node

;

__foreach_iterator__

(

node

);)

{

AfterRemoveChild

(

node

); }

items

Clear

();

return

true

; }

/*********************************************************************** ParsingError ***********************************************************************/

ParsingError

() :token(

) ,parsingTree(

) { }

ParsingError

(

const

WString

_errorMessage

) :token(

) ,parsingTree(

) ,errorMessage(

_errorMessage

) { }

ParsingError

(

const

regex

RegexToken

_token

const

WString

_errorMessage

) :token(

_token

) ,parsingTree(

) ,errorMessage(

_errorMessage

) {

(

token

) {

codeRange

start

row

_token

rowStart

;

codeRange

start

column

_token

columnStart

;

codeRange

start

index

_token

start

;

codeRange

end

row

_token

rowEnd

;

codeRange

end

column

_token

columnEnd

;

codeRange

end

index

_token

start

_token

length

;

codeRange

codeIndex

_token

codeIndex

; } }

ParsingError

(

ParsingTreeCustomBase

_parsingTree

const

WString

_errorMessage

) :codeRange(

_parsingTree

codeRange

) ,token(

) ,parsingTree(

_parsingTree

) ,errorMessage(

_errorMessage

) { }

ParsingError

() { }

/*********************************************************************** ParsingEmptyPrintNodeRecorder ***********************************************************************/

ParsingEmptyPrintNodeRecorder

() { }

ParsingEmptyPrintNodeRecorder

() { }

void

ParsingEmptyPrintNodeRecorder

Record

(

ParsingTreeCustomBase

node

const

ParsingTextRange

range

) { }

/*********************************************************************** ParsingMultiplePrintNodeRecorder ***********************************************************************/

ParsingMultiplePrintNodeRecorder

() { }

ParsingMultiplePrintNodeRecorder

() { }

void

ParsingMultiplePrintNodeRecorder

AddRecorder

(

Ptr

IParsingPrintNodeRecorder

recorder

) {

recorders

Add

(

recorder

); }

void

ParsingMultiplePrintNodeRecorder

Record

(

ParsingTreeCustomBase

node

const

ParsingTextRange

range

) {

FOREACH(Ptr<IParsingPrintNodeRecorder>, recorder, recorders)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

IParsingPrintNodeRecorder

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

recorders

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

IParsingPrintNodeRecorder

recorder

;

__foreach_iterator__

(

recorder

);)

{

recorder

Record

(

node

range

); } }

/*********************************************************************** ParsingOriginalLocationRecorder ***********************************************************************/

ParsingOriginalLocationRecorder

(

Ptr

IParsingPrintNodeRecorder

_recorder

) :recorder(

_recorder

) { }

ParsingOriginalLocationRecorder

() { }

void

ParsingOriginalLocationRecorder

Record

(

ParsingTreeCustomBase

node

const

ParsingTextRange

range

) {

auto

codeRange

node

codeRange

;

codeRange

codeIndex

range

codeIndex

;

recorder

Record

(

node

codeRange

); }

/*********************************************************************** ParsingGeneratedLocationRecorder ***********************************************************************/

ParsingGeneratedLocationRecorder

(

RangeMap

_rangeMap

) :rangeMap(

_rangeMap

) { }

ParsingGeneratedLocationRecorder

() { }

void

ParsingGeneratedLocationRecorder

Record

(

ParsingTreeCustomBase

node

const

ParsingTextRange

range

) {

rangeMap

Add

(

node

range

); }

/*********************************************************************** ParsingUpdateLocationRecorder ***********************************************************************/

ParsingUpdateLocationRecorder

() { }

ParsingUpdateLocationRecorder

() { }

void

ParsingUpdateLocationRecorder

Record

(

ParsingTreeCustomBase

node

const

ParsingTextRange

range

) {

node

codeRange

range

; }

/*********************************************************************** ParsingWriter ***********************************************************************/

void

ParsingWriter

HandleChar

(

wchar_t

) {

lastPos

currentPos

;

switch

(

) {

case

L'\n'

currentPos

index

++;

currentPos

row

++;

currentPos

column

;

break

;

default

currentPos

index

++;

currentPos

column

++; } }

ParsingWriter

(

stream

TextWriter

_writer

Ptr

IParsingPrintNodeRecorder

_recorder

vint

_codeIndex

) :writer(

_writer

) , recorder(

_recorder

) , codeIndex(

_codeIndex

) , lastPos(-

, -

) , currentPos(

) { }

ParsingWriter

() { }

void

ParsingWriter

WriteChar

(

wchar_t

) {

writer

WriteChar

(

);

recorder

)

return

;

HandleChar

(

); }

void

ParsingWriter

WriteString

(

const

wchar_t

string

vint

charCount

) {

writer

WriteString

(

string

charCount

);

recorder

)

return

;

for

(

vint

;

charCount

;

++) {

HandleChar

(

string

[

]); } }

void

ParsingWriter

BeforePrint

(

ParsingTreeCustomBase

node

) {

recorder

)

return

;

nodePositions

Add

(

NodePosPair

(

node

currentPos

)); }

void

ParsingWriter

AfterPrint

(

ParsingTreeCustomBase

node

) {

recorder

)

return

;

auto

pair

nodePositions

[

nodePositions

Count

() -

];

nodePositions

RemoveAt

(

nodePositions

Count

() -

);

CHECK_ERROR(pair.key == node, L"vl::parsing::ParsingWriter::AfterPrint(ParsingTreeNode*)#BeforePrint and AfterPrint should be call in pairs.");

{

(!(

pair

key

node

))

throw

Error

(

L"vl::parsing::ParsingWriter::AfterPrint(ParsingTreeNode*)#BeforePrint and AfterPrint should be call in pairs."

);}

while

(

);

ParsingTextRange

range

(

pair

value

lastPos

codeIndex

);

recorder

Record

(

node

range

); } } }

#if defined(VCZH_GCC) && defined(__clang__)

#pragma clang diagnostic pop #endif