GuiLanguageOperations.cpp

#include "GuiLanguageOperations.h"

namespace

{

namespace

presentation

{

namespace

controls

{

using

namespace

collections

;

using

namespace

parsing

;

using

namespace

parsing

tabling

;

using

namespace

regex_internal

;

/*********************************************************************** ParsingContext ***********************************************************************/

bool

ParsingTokenContext

RetriveContext

(

ParsingTokenContext

output

parsing

ParsingTreeNode

foundNode

RepeatingParsingExecutor

executor

) {

ParsingTreeToken

foundToken

dynamic_cast

ParsingTreeToken

*>(

foundNode

);

foundToken

)

return

false

;

ParsingTreeObject

tokenParent

dynamic_cast

ParsingTreeObject

*>(

foundNode

GetParent

());

tokenParent

)

return

false

;

vint

index

tokenParent

GetMembers

().

Values

().

IndexOf

(

foundNode

);

(

index

==-

)

return

false

;

WString

type

tokenParent

GetType

();

WString

field

tokenParent

GetMembers

().

Keys

().

Get

(

index

);

const

RepeatingParsingExecutor

FieldMetaData

executor

GetFieldMetaData

(

type

field

);

output

foundToken

;

output

tokenParent

;

output

type

;

output

field

;

output

acceptableSemanticIds

semantics

;

return

true

; }

bool

ParsingTokenContext

RetriveContext

(

ParsingTokenContext

output

parsing

ParsingTextPos

pos

parsing

ParsingTreeObject

rootNode

RepeatingParsingExecutor

executor

) {

ParsingTreeNode

foundNode

rootNode

FindDeepestNode

(

pos

);

foundNode

)

return

false

;

return

RetriveContext

(

output

foundNode

executor

); }

bool

ParsingTokenContext

RetriveContext

(

ParsingTokenContext

output

parsing

ParsingTextRange

range

ParsingTreeObject

rootNode

RepeatingParsingExecutor

executor

) {

ParsingTreeNode

foundNode

rootNode

FindDeepestNode

(

range

);

foundNode

)

return

false

;

return

RetriveContext

(

output

foundNode

executor

); }

/*********************************************************************** RepeatingParsingExecutor::IParsingAnalyzer ***********************************************************************/

parsing

ParsingTreeNode

RepeatingParsingExecutor

IParsingAnalyzer

ToParent

(

parsing

ParsingTreeNode

node

const

RepeatingPartialParsingOutput

output

) {

output

|| !

output

modifiedNode

)

return

node

;

return

node

output

modifiedNode

Obj

() ?

output

originalNode

Obj

() :

node

; }

parsing

ParsingTreeObject

RepeatingParsingExecutor

IParsingAnalyzer

ToChild

(

parsing

ParsingTreeObject

node

const

RepeatingPartialParsingOutput

output

) {

output

|| !

output

modifiedNode

)

return

node

;

return

node

output

originalNode

Obj

() ?

output

modifiedNode

Obj

() :

node

; }

Ptr

parsing

ParsingTreeNode

RepeatingParsingExecutor

IParsingAnalyzer

ToChild

(

Ptr

parsing

ParsingTreeNode

node

const

RepeatingPartialParsingOutput

output

) {

output

)

return

node

;

return

node

output

originalNode

output

modifiedNode

Cast

ParsingTreeNode

>() :

node

; }

parsing

ParsingTreeNode

RepeatingParsingExecutor

IParsingAnalyzer

GetParent

(

parsing

ParsingTreeNode

node

const

RepeatingPartialParsingOutput

output

) {

return

ToParent

(

node

output

)->

GetParent

(); }

Ptr

parsing

ParsingTreeNode

RepeatingParsingExecutor

IParsingAnalyzer

GetMember

(

parsing

ParsingTreeObject

node

const

WString

name

const

RepeatingPartialParsingOutput

output

) {

return

ToChild

(

ToChild

(

node

output

)->

GetMember

(

name

output

); }

Ptr

parsing

ParsingTreeNode

RepeatingParsingExecutor

IParsingAnalyzer

GetItem

(

parsing

ParsingTreeArray

node

vint

index

const

RepeatingPartialParsingOutput

output

) {

return

ToChild

(

node

GetItem

(

index

output

); }

/*********************************************************************** RepeatingParsingExecutor::CallbackBase ***********************************************************************/

RepeatingParsingExecutor

CallbackBase

(

Ptr

RepeatingParsingExecutor

_parsingExecutor

) :parsingExecutor(

_parsingExecutor

) ,callbackAutoPushing(

false

) ,callbackElement(

) ,callbackElementModifyLock(

) { }

RepeatingParsingExecutor

CallbackBase

() { }

void

RepeatingParsingExecutor

CallbackBase

RequireAutoSubmitTask

(

bool

enabled

) {

callbackAutoPushing

enabled

; }

void

RepeatingParsingExecutor

CallbackBase

Attach

(

elements

GuiColorizedTextElement

_element

SpinLock

_elementModifyLock

compositions

GuiGraphicsComposition

_ownerComposition

vuint

editVersion

) {

(

_element

) {

SPIN_LOCK(_elementModifyLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

_elementModifyLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

callbackElement

_element

;

callbackElementModifyLock

_elementModifyLock

; } }

parsingExecutor

ActivateCallback

(

this

);

(

callbackElement

callbackElementModifyLock

callbackAutoPushing

) {

SPIN_LOCK(*callbackElementModifyLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

= *

callbackElementModifyLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

RepeatingParsingInput

input

;

input

editVersion

;

input

code

callbackElement

GetLines

().

GetText

();

parsingExecutor

SubmitTask

(

input

); } } }

void

RepeatingParsingExecutor

CallbackBase

Detach

() {

(

callbackElement

callbackElementModifyLock

) {

SPIN_LOCK(*callbackElementModifyLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

= *

callbackElementModifyLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

callbackElement

;

callbackElementModifyLock

; } }

parsingExecutor

DeactivateCallback

(

this

); }

void

RepeatingParsingExecutor

CallbackBase

TextEditPreview

(

TextEditPreviewStruct

arguments

) { }

void

RepeatingParsingExecutor

CallbackBase

TextEditNotify

(

const

TextEditNotifyStruct

arguments

) { }

void

RepeatingParsingExecutor

CallbackBase

TextCaretChanged

(

const

TextCaretChangedStruct

arguments

) { }

void

RepeatingParsingExecutor

CallbackBase

TextEditFinished

(

vuint

editVersion

) {

(

callbackElement

callbackElementModifyLock

callbackAutoPushing

) {

SPIN_LOCK(*callbackElementModifyLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

= *

callbackElementModifyLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

RepeatingParsingInput

input

;

input

editVersion

;

input

code

callbackElement

GetLines

().

GetText

();

parsingExecutor

SubmitTask

(

input

); } } }

/*********************************************************************** RepeatingParsingExecutor ***********************************************************************/

void

RepeatingParsingExecutor

Execute

(

const

RepeatingParsingInput

input

) {

List

Ptr

ParsingError

errors

;

Ptr

ParsingTreeObject

node

grammarParser

Parse

(

input

code

grammarRule

errors

Cast

ParsingTreeObject

>();

(

node

) {

node

InitializeQueryCache

(); }

RepeatingParsingOutput

result

;

result

node

;

result

editVersion

input

editVersion

;

result

code

input

code

;

(

node

) {

OnContextFinishedAsync

(

result

);

FOREACH(ICallback*, callback, callbacks)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

ICallback

*>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

callbacks

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

ICallback

callback

;

__foreach_iterator__

(

callback

);)

{

callback

OnParsingFinishedAsync

(

result

); } } }

void

RepeatingParsingExecutor

PrepareMetaData

() {

Ptr

ParsingTable

table

grammarParser

GetTable

();

tokenIndexMap

Clear

();

semanticIndexMap

Clear

();

tokenMetaDatas

Clear

();

fieldMetaDatas

Clear

();

Dictionary

vint

Ptr

ParsingTable

AttributeInfo

tokenColorAtts

tokenContextColorAtts

tokenCandidateAtts

tokenAutoCompleteAtts

;

Dictionary

FieldDesc

Ptr

ParsingTable

AttributeInfo

fieldColorAtts

fieldSemanticAtts

; {

vint

tokenCount

table

GetTokenCount

();

for

(

vint

token

ParsingTable

UserTokenStart

;

token

tokenCount

;

token

++) {

const

ParsingTable

TokenInfo

tokenInfo

table

GetTokenInfo

(

token

);

vint

tokenIndex

token

ParsingTable

UserTokenStart

;

tokenIndexMap

Add

(

tokenInfo

name

tokenIndex

);

(

Ptr

ParsingTable

AttributeInfo

att

GetColorAttribute

(

tokenInfo

attributeIndex

)) {

tokenColorAtts

Add

(

tokenIndex

att

); }

(

Ptr

ParsingTable

AttributeInfo

att

GetContextColorAttribute

(

tokenInfo

attributeIndex

)) {

tokenContextColorAtts

Add

(

tokenIndex

att

); }

(

Ptr

ParsingTable

AttributeInfo

att

GetCandidateAttribute

(

tokenInfo

attributeIndex

)) {

tokenCandidateAtts

Add

(

tokenIndex

att

); }

(

Ptr

ParsingTable

AttributeInfo

att

GetAutoCompleteAttribute

(

tokenInfo

attributeIndex

)) {

tokenAutoCompleteAtts

Add

(

tokenIndex

att

); } } } {

vint

fieldCount

table

GetTreeFieldInfoCount

();

for

(

vint

field

;

field

fieldCount

;

field

++) {

const

ParsingTable

TreeFieldInfo

fieldInfo

table

GetTreeFieldInfo

(

field

);

FieldDesc

fieldDesc

(

fieldInfo

type

fieldInfo

field

);

(

Ptr

ParsingTable

AttributeInfo

att

GetColorAttribute

(

fieldInfo

attributeIndex

)) {

fieldColorAtts

Add

(

fieldDesc

att

); }

(

Ptr

ParsingTable

AttributeInfo

att

GetSemanticAttribute

(

fieldInfo

attributeIndex

)) {

fieldSemanticAtts

Add

(

fieldDesc

att

); } } }

FOREACH(Ptr<ParsingTable::AttributeInfo>, att, From(tokenColorAtts.Values()) .Concat(tokenContextColorAtts.Values()) .Concat(fieldColorAtts.Values()) .Concat(fieldSemanticAtts.Values()) )

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

ParsingTable

AttributeInfo

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

From

(

tokenColorAtts

Values

()) .

Concat

(

tokenContextColorAtts

Values

()) .

Concat

(

fieldColorAtts

Values

()) .

Concat

(

fieldSemanticAtts

Values

()));

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

ParsingTable

AttributeInfo

att

;

__foreach_iterator__

(

att

);)

{

FOREACH(WString, argument, att->arguments)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

WString

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

att

arguments

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

WString

argument

;

__foreach_iterator__

(

argument

);)

{

semanticIndexMap

Contains

(

argument

)) {

semanticIndexMap

Add

(

argument

); } } }

vint

index

;

FOREACH(vint, tokenIndex, tokenIndexMap.Values())

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

vint

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

tokenIndexMap

Values

());

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

vint

tokenIndex

;

__foreach_iterator__

(

tokenIndex

);)

{

TokenMetaData

;

tableTokenIndex

tokenIndex

ParsingTable

UserTokenStart

;

lexerTokenIndex

tokenIndex

;

defaultColorIndex

;

hasContextColor

false

;

hasAutoComplete

false

;

isCandidate

false

;

((

index

tokenColorAtts

Keys

().

IndexOf

(

tokenIndex

))!=-

) {

defaultColorIndex

semanticIndexMap

IndexOf

(

tokenColorAtts

Values

()

[

index

]

arguments

[

]); }

hasContextColor

tokenContextColorAtts

Keys

().

Contains

(

tokenIndex

);

hasAutoComplete

tokenAutoCompleteAtts

Keys

().

Contains

(

tokenIndex

);

((

isCandidate

tokenCandidateAtts

Keys

().

Contains

(

tokenIndex

))) {

const

ParsingTable

TokenInfo

tokenInfo

table

GetTokenInfo

(

tableTokenIndex

);

(

IsRegexEscapedLiteralString

(

tokenInfo

regex

)) {

unescapedRegexText

UnescapeTextForRegex

(

tokenInfo

regex

); }

else

{

isCandidate

false

; } }

tokenMetaDatas

Add

(

tokenIndex

); } {

vint

fieldCount

table

GetTreeFieldInfoCount

();

for

(

vint

field

;

field

fieldCount

;

field

++) {

const

ParsingTable

TreeFieldInfo

fieldInfo

table

GetTreeFieldInfo

(

field

);

FieldDesc

fieldDesc

(

fieldInfo

type

fieldInfo

field

);

FieldMetaData

;

colorIndex

;

((

index

fieldColorAtts

Keys

().

IndexOf

(

fieldDesc

))!=-

) {

colorIndex

semanticIndexMap

IndexOf

(

fieldColorAtts

Values

()

[

index

]

arguments

[

]); }

((

index

fieldSemanticAtts

Keys

().

IndexOf

(

fieldDesc

))!=-

) {

semantics

new

List

vint

FOREACH(WString, argument, fieldSemanticAtts.Values()[index]->arguments)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

WString

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

fieldSemanticAtts

Values

()

[

index

]

arguments

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

WString

argument

;

__foreach_iterator__

(

argument

);)

{

semantics

Add

(

semanticIndexMap

IndexOf

(

argument

)); } }

fieldMetaDatas

Add

(

fieldDesc

); } } }

void

RepeatingParsingExecutor

OnContextFinishedAsync

(

RepeatingParsingOutput

context

) {

(

analyzer

) {

context

cache

analyzer

CreateCacheAsync

(

context

); } }

RepeatingParsingExecutor

(

Ptr

parsing

tabling

ParsingGeneralParser

_grammarParser

const

WString

_grammarRule

Ptr

IParsingAnalyzer

_analyzer

) :grammarParser(

_grammarParser

) ,grammarRule(

_grammarRule

) ,analyzer(

_analyzer

) ,autoPushingCallback(

) {

PrepareMetaData

();

(

analyzer

) {

analyzer

Attach

(

this

); } }

RepeatingParsingExecutor

() {

EnsureTaskFinished

();

(

analyzer

) {

analyzer

Detach

(

this

); } }

Ptr

parsing

tabling

ParsingGeneralParser

RepeatingParsingExecutor

GetParser

() {

return

grammarParser

; }

bool

RepeatingParsingExecutor

AttachCallback

(

ICallback

value

) {

value

)

return

false

;

(

callbacks

Contains

(

value

))

return

false

;

callbacks

Add

(

value

);

return

true

; }

bool

RepeatingParsingExecutor

DetachCallback

(

ICallback

value

) {

value

)

return

false

;

callbacks

Contains

(

value

))

return

false

;

DeactivateCallback

(

value

);

callbacks

Remove

(

value

);

return

true

; }

bool

RepeatingParsingExecutor

ActivateCallback

(

ICallback

value

) {

value

)

return

false

;

callbacks

Contains

(

value

))

return

false

;

(

activatedCallbacks

Contains

(

value

))

return

false

;

activatedCallbacks

Add

(

value

);

autoPushingCallback

) {

autoPushingCallback

value

;

autoPushingCallback

RequireAutoSubmitTask

(

true

); }

return

true

; }

bool

RepeatingParsingExecutor

DeactivateCallback

(

ICallback

value

) {

value

)

return

false

;

callbacks

Contains

(

value

))

return

false

;

activatedCallbacks

Contains

(

value

))

return

false

;

(

autoPushingCallback

value

) {

autoPushingCallback

RequireAutoSubmitTask

(

false

);

autoPushingCallback

; }

activatedCallbacks

Remove

(

value

);

autoPushingCallback

activatedCallbacks

Count

()>

) {

autoPushingCallback

activatedCallbacks

[

];

autoPushingCallback

RequireAutoSubmitTask

(

true

); }

return

true

; }

Ptr

RepeatingParsingExecutor

IParsingAnalyzer

RepeatingParsingExecutor

GetAnalyzer

() {

return

analyzer

; }

vint

RepeatingParsingExecutor

GetTokenIndex

(

const

WString

tokenName

) {

vint

index

tokenIndexMap

Keys

().

IndexOf

(

tokenName

);

return

index

==-

tokenIndexMap

Values

()

[

index

]; }

vint

RepeatingParsingExecutor

GetSemanticId

(

const

WString

name

) {

return

semanticIndexMap

IndexOf

(

name

); }

WString

RepeatingParsingExecutor

GetSemanticName

(

vint

) {

return

semanticIndexMap

Count

()?

semanticIndexMap

[

L""

; }

const

RepeatingParsingExecutor

TokenMetaData

RepeatingParsingExecutor

GetTokenMetaData

(

vint

regexTokenIndex

) {

return

tokenMetaDatas

[

regexTokenIndex

]; }

const

RepeatingParsingExecutor

FieldMetaData

RepeatingParsingExecutor

GetFieldMetaData

(

const

WString

type

const

WString

field

) {

return

fieldMetaDatas

[

FieldDesc

(

type

field

)]; }

Ptr

parsing

tabling

ParsingTable

AttributeInfo

RepeatingParsingExecutor

GetAttribute

(

vint

index

const

WString

name

vint

argumentCount

) {

(

index

!=-

) {

Ptr

ParsingTable

AttributeInfo

att

grammarParser

GetTable

()

GetAttributeInfo

(

index

)

FindFirst

(

name

);

(

att

&& (

argumentCount

==-

att

arguments

Count

()==

argumentCount

)) {

return

att

; } }

return

; }

Ptr

parsing

tabling

ParsingTable

AttributeInfo

RepeatingParsingExecutor

GetColorAttribute

(

vint

index

) {

return

GetAttribute

(

index

L"Color"

); }

Ptr

parsing

tabling

ParsingTable

AttributeInfo

RepeatingParsingExecutor

GetContextColorAttribute

(

vint

index

) {

return

GetAttribute

(

index

L"ContextColor"

); }

Ptr

parsing

tabling

ParsingTable

AttributeInfo

RepeatingParsingExecutor

GetSemanticAttribute

(

vint

index

) {

return

GetAttribute

(

index

L"Semantic"

, -

); }

Ptr

parsing

tabling

ParsingTable

AttributeInfo

RepeatingParsingExecutor

GetCandidateAttribute

(

vint

index

) {

return

GetAttribute

(

index

L"Candidate"

); }

Ptr

parsing

tabling

ParsingTable

AttributeInfo

RepeatingParsingExecutor

GetAutoCompleteAttribute

(

vint

index

) {

return

GetAttribute

(

index

L"AutoComplete"

); } } } }