GuiLanguageAutoComplete.cpp

#include "GuiLanguageAutoComplete.h"

#include "../../GuiApplication.h"

namespace

{

namespace

presentation

{

namespace

controls

{

using

namespace

elements

;

using

namespace

regex

;

using

namespace

parsing

;

using

namespace

parsing

tabling

;

using

namespace

collections

;

/*********************************************************************** GuiGrammarAutoComplete ***********************************************************************/

void

GuiGrammarAutoComplete

Attach

(

elements

GuiColorizedTextElement

_element

SpinLock

_elementModifyLock

compositions

GuiGraphicsComposition

_ownerComposition

vuint

editVersion

) {

GuiTextBoxAutoCompleteBase

Attach

(

_element

_elementModifyLock

_ownerComposition

editVersion

);

RepeatingParsingExecutor

CallbackBase

Attach

(

_element

_elementModifyLock

_ownerComposition

editVersion

); }

void

GuiGrammarAutoComplete

Detach

() {

GuiTextBoxAutoCompleteBase

Detach

();

RepeatingParsingExecutor

CallbackBase

Detach

();

(

element

elementModifyLock

) {

EnsureAutoCompleteFinished

(); } }

void

GuiGrammarAutoComplete

TextEditPreview

(

TextEditPreviewStruct

arguments

) {

GuiTextBoxAutoCompleteBase

TextEditPreview

(

arguments

);

RepeatingParsingExecutor

CallbackBase

TextEditPreview

(

arguments

);

(

element

elementModifyLock

) {

(

IsListOpening

() &&

arguments

keyInput

arguments

originalText

L""

arguments

inputText

L""

) {

WString

selectedItem

GetSelectedListItem

();

(

selectedItem

L""

) {

TextPos

begin

GetListStartPosition

();

TextPos

end

arguments

originalStart

;

WString

editingText

element

GetLines

().

GetText

(

begin

end

);

editingText

arguments

inputText

;

(

grammarParser

GetTable

()

GetLexer

().

Walk

().

IsClosedToken

(

editingText

)) {

arguments

originalStart

begin

;

arguments

inputText

selectedItem

arguments

inputText

;

CloseList

(); } } } } }

void

GuiGrammarAutoComplete

TextEditNotify

(

const

TextEditNotifyStruct

arguments

) {

GuiTextBoxAutoCompleteBase

TextEditNotify

(

arguments

);

RepeatingParsingExecutor

CallbackBase

TextEditNotify

(

arguments

);

(

element

elementModifyLock

) {

editing

true

;

SPIN_LOCK(editTraceLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

editTraceLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

editTrace

Add

(

arguments

); } } }

void

GuiGrammarAutoComplete

TextCaretChanged

(

const

TextCaretChangedStruct

arguments

) {

GuiTextBoxAutoCompleteBase

TextCaretChanged

(

arguments

);

RepeatingParsingExecutor

CallbackBase

TextCaretChanged

(

arguments

);

(

element

elementModifyLock

) {

SPIN_LOCK(editTraceLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

editTraceLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

// queue a fake TextEditNotifyStruct

// a fake struct can be detected by (trace.originalText==L"" && trace.inputText==L"")

TextEditNotifyStruct

trace

;

trace

editVersion

arguments

editVersion

;

trace

originalStart

arguments

oldBegin

;

trace

originalEnd

arguments

oldEnd

;

trace

inputStart

arguments

newBegin

;

trace

inputEnd

arguments

newEnd

;

// ensure trace.originalStart<=trace.originalEnd

(

trace

originalStart

trace

originalEnd

) {

TextPos

temp

trace

originalStart

;

trace

originalStart

trace

originalEnd

;

trace

originalEnd

temp

; }

// ensure trace.inputStart<=trace.inputEnd

(

trace

inputStart

trace

inputEnd

) {

TextPos

temp

trace

inputStart

;

trace

inputStart

trace

inputEnd

;

trace

inputEnd

temp

; }

editTrace

Add

(

trace

); }

SPIN_LOCK(contextLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

contextLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

(

context

input

node

) {

(

editing

) {

// if the current caret changing is caused by editing

// submit a task with valid editVersion and invalid node and code

RepeatingParsingOutput

input

;

input

editVersion

context

input

editVersion

;

SubmitTask

(

input

); }

else

(

context

input

editVersion

arguments

editVersion

) {

// if the current caret changing is not caused by editing

// submit a task with the previous input

SubmitTask

(

context

input

); } } } } }

void

GuiGrammarAutoComplete

TextEditFinished

(

vuint

editVersion

) {

GuiTextBoxAutoCompleteBase

TextEditFinished

(

editVersion

);

RepeatingParsingExecutor

CallbackBase

TextEditFinished

(

editVersion

);

(

element

elementModifyLock

) {

editing

false

; } }

void

GuiGrammarAutoComplete

OnParsingFinishedAsync

(

const

RepeatingParsingOutput

arguments

) {

(

element

elementModifyLock

) {

GetApplication

()->

InvokeInMainThread

(

ownerComposition

GetRelatedControlHost

(), [=]() {

// submit a task if the RepeatingParsingExecutor notices a new parsing result

SubmitTask

(

arguments

); }); } }

void

GuiGrammarAutoComplete

CollectLeftRecursiveRules

() {

leftRecursiveRules

Clear

();

Ptr

ParsingGeneralParser

parser

parsingExecutor

GetParser

();

Ptr

ParsingTable

table

parser

GetTable

();

vint

stateCount

table

GetStateCount

();

vint

tokenCount

table

GetTokenCount

();

for

(

vint

;

stateCount

;

++) {

for

(

vint

;

tokenCount

;

++) {

Ptr

ParsingTable

TransitionBag

bag

table

GetTransitionBag

(

);

(

bag

) {

FOREACH(Ptr<ParsingTable::TransitionItem>, item, bag->transitionItems)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

ParsingTable

TransitionItem

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

bag

transitionItems

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

ParsingTable

TransitionItem

item

;

__foreach_iterator__

(

item

);)

{

FOREACH(ParsingTable::Instruction, ins, item->instructions)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

ParsingTable

Instruction

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

item

instructions

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

ParsingTable

Instruction

ins

;

__foreach_iterator__

(

ins

);)

{

(

ins

instructionType

ParsingTable

Instruction

LeftRecursiveReduce

) {

leftRecursiveRules

Contains

(

ins

creatorRule

)) {

leftRecursiveRules

Add

(

ins

creatorRule

); } } } } } } } }

vint

GuiGrammarAutoComplete

UnsafeGetEditTraceIndex

(

vuint

editVersion

) {

// get the index of the latest TextEditNotifyStruct of a specified edit version

// this function should be called inside SPIN_LOCK(editTraceLock)

// perform a binary search

vint

start

;

vint

end

editTrace

Count

() -

;

while

(

start

end

) {

vint

middle

= (

start

end

) /

;

TextEditNotifyStruct

trace

editTrace

[

middle

];

(

editVersion

trace

editVersion

) {

end

middle

; }

else

(

editVersion

trace

editVersion

) {

start

middle

; }

else

{

// if multiple TextEditNotifyStruct is found, choose the latest one

while

(

middle

editTrace

Count

() -

) {

(

editTrace

[

middle

editVersion

editTrace

[

middle

editVersion

) {

middle

++; }

else

{

break

; } }

return

middle

; } }

return

; }

TextPos

GuiGrammarAutoComplete

ChooseCorrectTextPos

(

TextPos

pos

const

regex

RegexTokens

tokens

) {

Ptr

ParsingTable

table

grammarParser

GetTable

();

RegexToken

lastToken

;

lastToken

reading

;

FOREACH(RegexToken, token, tokens)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

RegexToken

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

tokens

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

RegexToken

token

;

__foreach_iterator__

(

token

);)

{

// we treat "class| Name" as editing the first token

(

TextPos

(

token

rowEnd

token

columnEnd

)

pos

) {

(

table

GetTableTokenIndex

(

token

)!=-

lastToken

reading

) {

pos

TextPos

(

lastToken

rowStart

lastToken

columnStart

); }

break

; }

lastToken

token

; }

return

pos

; }

void

GuiGrammarAutoComplete

ExecuteRefresh

(

AutoCompleteContext

newContext

) {

// process the input of a task is submitted not by text editing

// find the text selection by the edit version of the input

TextPos

startPos

endPos

; {

SPIN_LOCK(editTraceLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

editTraceLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

vint

traceIndex

UnsafeGetEditTraceIndex

(

newContext

input

editVersion

);

(

traceIndex

== -

)

return

;

TextEditNotifyStruct

trace

editTrace

[

traceIndex

];

startPos

trace

inputStart

;

endPos

trace

inputEnd

; }

const

RegexLexer

lexer

grammarParser

GetTable

()

GetLexer

();

RegexTokens

tokens

lexer

Parse

(

newContext

input

code

);

startPos

ChooseCorrectTextPos

(

startPos

tokens

); }

// locate the deepest node using the text selection

ParsingTextPos

start

(

startPos

row

startPos

column

);

ParsingTextPos

end

(

endPos

row

endPos

column

);

ParsingTextRange

range

(

start

end

);

ParsingTreeNode

found

newContext

input

node

FindDeepestNode

(

range

);

ParsingTreeObject

selectedNode

;

// if the location failed, choose the root node

found

startPos

TextPos

(

)) {

found

newContext

input

node

Obj

(); }

selectedNode

) {

// from the deepest node, traverse towards the root node

// find the deepest node whose created rule is a left recursive rule and whose parent is not

ParsingTreeObject

lrec

;

ParsingTreeNode

current

found

;

while

(

current

) {

ParsingTreeObject

obj

dynamic_cast

ParsingTreeObject

*>(

current

);

(

obj

) {

FOREACH(WString, rule, obj->GetCreatorRules())

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

WString

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

obj

GetCreatorRules

());

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

WString

rule

;

__foreach_iterator__

(

rule

);)

{

(

leftRecursiveRules

Contains

(

rule

)) {

lrec

obj

;

break

; } }

(

obj

lrec

obj

) {

selectedNode

lrec

;

break

; } }

current

GetParent

(); } }

selectedNode

) {

// if there is no left recursive rule that creates the deepest node and all indirect parents

// choose the deepest ParsingTreeObject

ParsingTreeNode

current

found

;

while

(

current

) {

ParsingTreeObject

obj

dynamic_cast

ParsingTreeObject

*>(

current

);

(

obj

) {

selectedNode

obj

;

break

; }

current

GetParent

(); } }

(

selectedNode

) {

// get the code range of the selected node

start

selectedNode

GetCodeRange

().

start

;

end

selectedNode

GetCodeRange

().

end

;

// get all properties from the selected node

newContext

rule

selectedNode

GetCreatorRules

()

[

selectedNode

GetCreatorRules

().

Count

() -

];

newContext

originalRange

selectedNode

GetCodeRange

();

newContext

originalNode

dynamic_cast

ParsingTreeObject

*>(

selectedNode

);

newContext

modifiedNode

newContext

originalNode

;

newContext

modifiedEditVersion

newContext

input

editVersion

;

// get the corresponding code of the selected node

(

start

index

end

index

) {

newContext

modifiedCode

newContext

input

code

Sub

(

start

index

end

index

start

index

Buffer

(); } } }

bool

GuiGrammarAutoComplete

NormalizeTextPos

(

AutoCompleteContext

newContext

elements

text

TextLines

lines

TextPos

pos

) {

// get the start position

TextPos

start

(

newContext

originalRange

start

row

newContext

originalRange

start

column

);

// get the end position of the end of lines

TextPos

end

lines

GetCount

() <=

TextPos

(

start

row

start

column

lines

GetLine

(

dataLength

) :

TextPos

(

start

row

lines

GetCount

() -

lines

GetLine

(

lines

GetCount

() -

dataLength

) ;

(

start

pos

end

) {

// if the pos is inside the range

// normalize the pos to a new coordinate that the beginning position of lines is (row=0, column=0)

pos

row

start

row

;

(

pos

row

) {

pos

column

start

column

; }

return

true

; }

else

{

return

false

; } }

void

GuiGrammarAutoComplete

ExecuteEdit

(

AutoCompleteContext

newContext

) {

// process the input of a task that is submitted by text editing

// this function make an approximiation to the context if the RepeatingParsingExecutor is not fast enough

// copy all TextEditNotifyStruct that is caused by a text editing before (and including) the edit version of the input

List

TextEditNotifyStruct

usedTrace

; {

SPIN_LOCK(editTraceLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

editTraceLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

CopyFrom

(

usedTrace

From

(

editTrace

) .Where([&newContext](

const

TextEditNotifyStruct

value

) {

return

(

value

originalText

L""

value

inputText

L""

) &&

value

editVersion

newContext

modifiedEditVersion

; }) ); } }

// apply all modification to get the new modifiedCode

bool

failed

false

;

(

usedTrace

Count

() >

) {

(

usedTrace

[

editVersion

newContext

modifiedEditVersion

) {

// failed if any TextEditNotifyStruct is missing

failed

true

; }

else

{

// initialize a TextLines with the latest modifiedCode

text

TextLines

lines

(

nullptr

);

lines

SetText

(

newContext

modifiedCode

);

FOREACH(TextEditNotifyStruct, trace, usedTrace)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

TextEditNotifyStruct

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

usedTrace

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

TextEditNotifyStruct

trace

;

__foreach_iterator__

(

trace

);)

{

// apply a modification to lines

TextPos

start

trace

originalStart

;

TextPos

end

trace

originalEnd

;

// only if the modification is meaningful

(

NormalizeTextPos

(

newContext

lines

start

) &&

NormalizeTextPos

(

newContext

lines

end

)) {

lines

Modify

(

start

end

trace

inputText

); }

else

{

// otherwise, failed

failed

true

;

break

; } }

failed

) {

newContext

modifiedCode

lines

GetText

(); } } }

(

failed

) {

// clear originalNode to notify that the current context goes wrong

newContext

originalNode

; }

(

usedTrace

Count

() >

) {

// update the edit version

newContext

modifiedEditVersion

usedTrace

[

usedTrace

Count

() -

editVersion

; } }

void

GuiGrammarAutoComplete

DeleteFutures

(

collections

List

parsing

tabling

ParsingState

Future

*>&

futures

) {

// delete all futures and clear the list

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

; }

futures

Clear

(); }

regex

RegexToken

GuiGrammarAutoComplete

TraverseTransitions

(

parsing

tabling

ParsingState

state

parsing

tabling

ParsingTransitionCollector

transitionCollector

TextPos

stopPosition

collections

List

parsing

tabling

ParsingState

Future

*>&

nonRecoveryFutures

collections

List

parsing

tabling

ParsingState

Future

*>&

recoveryFutures

) {

const

List

ParsingState

TransitionResult

transitions

transitionCollector

GetTransitions

();

for

(

vint

index

;

index

transitions

Count

();

index

++) {

const

ParsingState

TransitionResult

transition

transitions

[

index

];

switch

(

transition

transitionType

) {

case

ParsingState

TransitionResult

AmbiguityBegin

break

;

case

ParsingState

TransitionResult

AmbiguityBranch

// ambiguity branches are not nested

// tokens in different braches are the same

// so we only need to run one branch, and skip the others

index

transitionCollector

GetAmbiguityEndFromBegin

(

transitionCollector

GetAmbiguityBeginFromBranch

(

index

));

break

;

case

ParsingState

TransitionResult

AmbiguityEnd

break

;

case

ParsingState

TransitionResult

ExecuteInstructions

: {

// test does the token reach the stop position

(

transition

token

) {

// we treat "A|B" as editing A if token A is endless, otherwise treated as editing B

TextPos

tokenEnd

(

transition

token

rowEnd

transition

token

columnEnd

);

// if the caret is not at the end of the token

(

tokenEnd

stopPosition

) {

// stop the traversing and return the editing token

return

transition

token

; }

else

(

tokenEnd

stopPosition

) {

// if the caret is at the end of the token, and it is a closed token

// e.g. identifier is not a closed token, string is a closed token

grammarParser

GetTable

()

GetLexer

().

Walk

().

IsClosedToken

(

transition

token

reading

transition

token

length

)) {

// stop the traversing and return the editing token

return

transition

token

; } } }

// traverse the PDA using the token specified in the current transition

vint

tableTokenIndex

transition

tableTokenIndex

;

List

ParsingState

Future

possibilities

;

(

recoveryFutures

Count

() >

) {

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

);)

{

state

Explore

(

tableTokenIndex

future

possibilities

); } }

else

{

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

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

ParsingState

Future

*>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

nonRecoveryFutures

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

ParsingState

Future

future

;

__foreach_iterator__

(

future

);)

{

state

Explore

(

tableTokenIndex

future

possibilities

); } }

// delete duplicated futures

List

ParsingState

Future

selectedPossibilities

;

for

(

vint

;

possibilities

Count

();

++) {

ParsingState

Future

candidateFuture

possibilities

[

];

bool

duplicated

false

;

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

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

ParsingState

Future

*>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

selectedPossibilities

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

ParsingState

Future

future

;

__foreach_iterator__

(

future

);)

{

(

candidateFuture

currentState

future

currentState

candidateFuture

reduceStateCount

future

reduceStateCount

candidateFuture

shiftStates

Count

() ==

future

shiftStates

Count

() ) {

bool

same

true

;

for

(

vint

;

future

shiftStates

Count

();

++) {

(

candidateFuture

shiftStates

[

] !=

future

shiftStates

[

]) {

same

false

;

break

; } }

((

duplicated

same

)) {

break

; } } }

(

duplicated

) {

delete

candidateFuture

; }

else

{

selectedPossibilities

Add

(

candidateFuture

); } }

// step forward

(

transition

token

transition

tableTokenIndex

ParsingTable

TokenBegin

) {

DeleteFutures

(

nonRecoveryFutures

);

DeleteFutures

(

recoveryFutures

);

CopyFrom

(

nonRecoveryFutures

selectedPossibilities

); }

else

{

DeleteFutures

(

recoveryFutures

);

CopyFrom

(

recoveryFutures

selectedPossibilities

); } }

break

;

default

:; } }

return

; }

regex

RegexToken

GuiGrammarAutoComplete

SearchValidInputToken

(

parsing

tabling

ParsingState

state

parsing

tabling

ParsingTransitionCollector

transitionCollector

TextPos

stopPosition

AutoCompleteContext

newContext

collections

SortedList

vint

tableTokenIndices

) {

// initialize the PDA state

state

Reset

(

newContext

rule

);

List

ParsingState

Future

nonRecoveryFutures

recoveryFutures

;

nonRecoveryFutures

Add

(

state

ExploreCreateRootFuture

());

// traverse the PDA until it reach the stop position

// nonRecoveryFutures store the state when the last token (existing) is reached

// recoveryFutures store the state when the last token (inserted by error recovery) is reached

RegexToken

token

TraverseTransitions

(

state

transitionCollector

stopPosition

nonRecoveryFutures

recoveryFutures

);

// explore all possibilities from the last token before the stop position

List

ParsingState

Future

possibilities

;

for

(

vint

;

nonRecoveryFutures

Count

();

++) {

state

Explore

(

ParsingTable

NormalReduce

nonRecoveryFutures

[

nonRecoveryFutures

);

state

Explore

(

ParsingTable

LeftRecursiveReduce

nonRecoveryFutures

[

nonRecoveryFutures

); }

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

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

ParsingState

Future

*>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

nonRecoveryFutures

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

ParsingState

Future

future

;

__foreach_iterator__

(

future

);)

{

vint

count

state

GetTable

()

GetTokenCount

();

for

(

vint

ParsingTable

UserTokenStart

;

count

;

++) {

state

Explore

(

future

possibilities

); } }

// get all possible tokens that marked using @AutoCompleteCandidate

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

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

ParsingState

Future

*>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

possibilities

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

ParsingState

Future

future

;

__foreach_iterator__

(

future

);)

{

tableTokenIndices

Contains

(

future

selectedToken

)) {

tableTokenIndices

Add

(

future

selectedToken

); } }

// release all data

DeleteFutures

(

possibilities

);

DeleteFutures

(

nonRecoveryFutures

);

DeleteFutures

(

recoveryFutures

);

// return the editing token

return

token

; }

TextPos

GuiGrammarAutoComplete

GlobalTextPosToModifiedTextPos

(

AutoCompleteContext

newContext

TextPos

pos

) {

pos

row

newContext

originalRange

start

row

;

(

pos

row

) {

pos

column

newContext

originalRange

start

column

; }

return

pos

; }

TextPos

GuiGrammarAutoComplete

ModifiedTextPosToGlobalTextPos

(

AutoCompleteContext

newContext

TextPos

pos

) {

(

pos

row

) {

pos

column

newContext

originalRange

start

column

; }

pos

row

newContext

originalRange

start

row

;

return

pos

; }

void

GuiGrammarAutoComplete

ExecuteCalculateList

(

AutoCompleteContext

newContext

) {

// calcuate the content of the auto complete list

// it is sad that, because the parser's algorithm is too complex

// we need to reparse and track the internal state of the PDA(push-down automaton) here.

// initialize the PDA

ParsingState

state

(

newContext

modifiedCode

grammarParser

GetTable

());

state

Reset

(

newContext

rule

);

// prepare to get all transitions

ParsingTransitionCollector

collector

;

List

Ptr

ParsingError

errors

;

// reparse and get all transitions during parsing

(

grammarParser

Parse

(

state

collector

errors

)) {

// if modifiedNode is not prepared (the task is submitted because of text editing)

// use the transition to build the syntax tree

newContext

modifiedNode

) {

ParsingTreeBuilder

builder

;

builder

Reset

();

bool

succeeded

true

;

FOREACH(ParsingState::TransitionResult, transition, collector.GetTransitions())

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

ParsingState

TransitionResult

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

collector

GetTransitions

());

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

ParsingState

TransitionResult

transition

;

__foreach_iterator__

(

transition

);)

{

(!(

succeeded

builder

Run

(

transition

))) {

break

; } }

(

succeeded

) {

Ptr

ParsingTreeNode

parsedNode

builder

GetNode

();

newContext

modifiedNode

parsedNode

Cast

ParsingTreeObject

>();

newContext

modifiedNode

InitializeQueryCache

(); } }

(

newContext

modifiedNode

) {

// get the latest text editing trace

TextEditNotifyStruct

trace

;

SPIN_LOCK(editTraceLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

editTraceLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

vint

index

UnsafeGetEditTraceIndex

(

newContext

modifiedEditVersion

);

(

index

== -

) {

return

; }

else

{

trace

editTrace

[

index

]; } }

// calculate the stop position for PDA traversing

TextPos

stopPosition

GlobalTextPosToModifiedTextPos

(

newContext

trace

inputStart

);

// find all possible token before the current caret using the PDA

Ptr

AutoCompleteData

autoComplete

new

AutoCompleteData

;

SortedList

vint

tableTokenIndices

;

RegexToken

editingToken

SearchValidInputToken

(

state

collector

stopPosition

newContext

tableTokenIndices

);

// collect all auto complete types

{

// collect all keywords that can be put into the auto complete list

FOREACH(vint, token, tableTokenIndices)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

vint

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

tableTokenIndices

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

vint

token

;

__foreach_iterator__

(

token

);)

{

vint

regexToken

token

ParsingTable

UserTokenStart

;

(

regexToken

) {

autoComplete

candidates

Add

(

regexToken

);

(

parsingExecutor

GetTokenMetaData

(

regexToken

isCandidate

) {

autoComplete

shownCandidates

Add

(

regexToken

); } } }

// calculate the arranged stopPosition

(

editingToken

) {

TextPos

tokenPos

(

editingToken

rowStart

editingToken

columnStart

);

(

tokenPos

stopPosition

) {

stopPosition

tokenPos

; } }

// calculate the start/end position for PDA traversing

TextPos

startPos

endPos

; {

startPos

ModifiedTextPosToGlobalTextPos

(

newContext

stopPosition

);

autoComplete

startPosition

startPos

;

endPos

trace

inputEnd

;

(

newContext

modifiedNode

newContext

originalNode

) {

startPos

GlobalTextPosToModifiedTextPos

(

newContext

startPos

);

endPos

GlobalTextPosToModifiedTextPos

(

newContext

endPos

); }

(

startPos

endPos

column

) {

endPos

column

--; } }

// calculate the auto complete type

(

editingToken

parsingExecutor

GetTokenMetaData

(

editingToken

token

hasAutoComplete

) {

ParsingTextRange

range

(

ParsingTextPos

(

startPos

row

startPos

column

ParsingTextPos

(

endPos

row

endPos

column

));

AutoCompleteData

RetriveContext

autoComplete

Obj

(),

range

newContext

modifiedNode

Obj

(),

parsingExecutor

Obj

()); } }

newContext

autoComplete

; } } }

void

GuiGrammarAutoComplete

Execute

(

const

RepeatingParsingOutput

input

) {

SPIN_LOCK(contextLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

contextLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

(

input

editVersion

context

input

editVersion

) {

return

; } }

AutoCompleteContext

newContext

;

bool

byGlobalCorrection

false

;

(

input

node

) {

newContext

input

;

ExecuteRefresh

(

newContext

);

byGlobalCorrection

true

; }

else

{

SPIN_LOCK(contextLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

contextLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

newContext

context

;

newContext

modifiedNode

;

newContext

autoComplete

; }

(

newContext

originalNode

) {

ExecuteEdit

(

newContext

); } }

(

newContext

originalNode

) {

ExecuteCalculateList

(

newContext

); }

SPIN_LOCK(contextLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

contextLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

context

newContext

; }

(

newContext

modifiedNode

) {

OnContextFinishedAsync

(

context

);

GetApplication

()->

InvokeInMainThread

(

ownerComposition

GetRelatedControlHost

(), [=]() {

PostList

(

newContext

byGlobalCorrection

); }); } }

void

GuiGrammarAutoComplete

PostList

(

const

AutoCompleteContext

newContext

bool

byGlobalCorrection

) {

bool

openList

true

;

// true: make the list visible

bool

keepListState

false

;

// true: don't change the list visibility

Ptr

AutoCompleteData

autoComplete

newContext

autoComplete

;

// if failed to get the auto complete list, close

autoComplete

) {

openList

false

; }

(

openList

) {

(

autoComplete

shownCandidates

Count

() +

autoComplete

candidateItems

Count

() ==

) {

openList

false

; } }

TextPos

startPosition

endPosition

;

WString

editingText

;

(

openList

) {

SPIN_LOCK(editTraceLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

editTraceLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

// if the edit version is invalid, cancel

vint

traceIndex

UnsafeGetEditTraceIndex

(

newContext

modifiedEditVersion

);

(

traceIndex

== -

) {

return

; }

// an edit version has two trace at most, for text change and caret change, here we peak the text change

(

traceIndex

editTrace

[

traceIndex

editVersion

context

modifiedEditVersion

) {

traceIndex

--; }

// if the edit version is not created by keyboard input, close

(

traceIndex

) {

TextEditNotifyStruct

trace

editTrace

[

traceIndex

];

trace

keyInput

) {

openList

false

; } }

// scan all traces from the calculation's edit version until now

(

openList

) {

keepListState

true

;

startPosition

autoComplete

startPosition

;

endPosition

editTrace

[

editTrace

Count

() -

inputEnd

;

for

(

vint

traceIndex

;

editTrace

Count

();

++) {

TextEditNotifyStruct

trace

editTrace

[

];

// if there are no text change trace until now, don't change the list

(

trace

originalText

L""

trace

inputText

L""

) {

keepListState

false

; }

// if the edit position goes before the start position of the auto complete, refresh

(

trace

inputEnd

startPosition

) {

openList

false

;

break

; } } }

(

traceIndex

) {

editTrace

RemoveRange

(

traceIndex

); } } }

// if there is a global correction send to the UI thread but the list is not opening, cancel

(

byGlobalCorrection

&& !

IsListOpening

()) {

return

; }

// if the input text from the start position to the current position crosses a token, close

(

openList

element

) {

editingText

element

GetLines

().

GetText

(

startPosition

endPosition

);

(

grammarParser

GetTable

()

GetLexer

().

Walk

().

IsClosedToken

(

editingText

)) {

openList

false

; } }

// calculate the content of the list

(

autoComplete

&& ((!

keepListState

openList

) ||

IsListOpening

())) {

SortedList

WString

itemKeys

;

List

ParsingCandidateItem

itemValues

;

// copy all candidate keywords

FOREACH(vint, token, autoComplete->shownCandidates)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

vint

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

autoComplete

shownCandidates

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

vint

token

;

__foreach_iterator__

(

token

);)

{

WString

literal

parsingExecutor

GetTokenMetaData

(

token

unescapedRegexText

;

(

literal

L""

&& !

itemKeys

Contains

(

literal

)) {

ParsingCandidateItem

item

;

item

name

literal

;

item

semanticId

= -

;

itemValues

Insert

(

itemKeys

Add

(

literal

item

); } }

// copy all candidate symbols

(

autoComplete

acceptableSemanticIds

) {

FOREACH(ParsingCandidateItem, item, autoComplete->candidateItems)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

ParsingCandidateItem

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

autoComplete

candidateItems

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

ParsingCandidateItem

item

;

__foreach_iterator__

(

item

);)

{

(

autoComplete

acceptableSemanticIds

Contains

(

item

semanticId

)) {

// add all acceptable display of a symbol

// because a symbol can has multiple representation in different places

(

item

name

L""

&& !

itemKeys

Contains

(

item

name

)) {

itemValues

Insert

(

itemKeys

Add

(

item

name

item

); } } } }

// fill the list

List

GuiTextBoxAutoCompleteBase

AutoCompleteItem

candidateItems

;

for

(

vint

;

itemValues

Count

();

++) {

auto

item

itemValues

[

];

(

item

tag

IsNull

()) {

(

auto

analyzer

parsingExecutor

GetAnalyzer

()) {

item

tag

analyzer

CreateTagForCandidateItem

(

item

); } }

GuiTextBoxAutoCompleteBase

AutoCompleteItem

candidateItem

;

candidateItem

text

item

name

;

candidateItem

tag

item

tag

;

candidateItems

Add

(

candidateItem

); }

SetListContent

(

candidateItems

); }

// set the list state

keepListState

) {

(

openList

) {

OpenList

(

startPosition

); }

else

{

CloseList

(); } }

(

IsListOpening

()) {

HighlightList

(

editingText

); } }

void

GuiGrammarAutoComplete

Initialize

() {

grammarParser

CreateAutoRecoverParser

(

parsingExecutor

GetParser

()

GetTable

());

CollectLeftRecursiveRules

();

parsingExecutor

AttachCallback

(

this

); }

void

GuiGrammarAutoComplete

OnContextFinishedAsync

(

AutoCompleteContext

context

) {

(

auto

analyzer

parsingExecutor

GetAnalyzer

()) {

(

context

autoComplete

context

autoComplete

acceptableSemanticIds

) {

analyzer

GetCandidateItemsAsync

context

autoComplete

Obj

(),

context

autoComplete

candidateItems

); } } }

void

GuiGrammarAutoComplete

EnsureAutoCompleteFinished

() {

parsingExecutor

EnsureTaskFinished

();

SPIN_LOCK(contextLock)

(

bool

__scope_variable_flag__

true

)

for

(

const

SpinLock

Scope

scope

contextLock

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

{

context

AutoCompleteContext

(); } }

GuiGrammarAutoComplete

(

Ptr

RepeatingParsingExecutor

_parsingExecutor

) :

RepeatingParsingExecutor

CallbackBase

(

_parsingExecutor

) ,editing(

false

) {

Initialize

(); }

GuiGrammarAutoComplete

(

Ptr

parsing

tabling

ParsingGeneralParser

_grammarParser

const

WString

_grammarRule

) :

RepeatingParsingExecutor

CallbackBase

(

new

RepeatingParsingExecutor

(

_grammarParser

_grammarRule

)) ,editing(

false

) {

Initialize

(); }

GuiGrammarAutoComplete

() {

EnsureAutoCompleteFinished

();

parsingExecutor

DetachCallback

(

this

); }

Ptr

RepeatingParsingExecutor

GuiGrammarAutoComplete

GetParsingExecutor

() {

return

parsingExecutor

; } } } }