void IncrGAnalysisListener.OnMatch(GAnlysInput nextInput, AfterMatchListener afterListener, AlternativeIncrGAnalyzer alternative)
{
List <IndexedAfterMatchListener> updatedMatches = new List <IndexedAfterMatchListener>(previoudMatches);
updatedMatches.Add(new IndexedAfterMatchListener(nextIndex - 1, afterListener));
if (nextIndex < analyzers.Count)
{
var recordingListener = new RecordingIncrGAnalysListener {
baseListener = new ChainListenerOld {
analyzers = analyzers, nextIndex = nextIndex + 1, rootListener = rootListener, previoudMatches = updatedMatches, afterListenerFactory = afterListenerFactory
}
};
analyzers[nextIndex].Analyze(nextInput, recordingListener);
if (!recordingListener.didMatch && alternative != null)
{
updatedMatches.RemoveAt(updatedMatches.Count - 1);
AlternativeIncrGAnalyzer currentAlternative = alternative;
var altListener = new ChainListenerOld {
analyzers = analyzers, nextIndex = nextIndex, rootListener = rootListener, previoudMatches = updatedMatches, afterListenerFactory = afterListenerFactory
};
alternative.AnalyzeAgain(altListener);
}
}
else
{
//rootListener.OnMatch(nextInput, new ClusterAfterListener { afterListeners = updatedMatches });
rootListener.OnMatch(nextInput, afterListenerFactory(updatedMatches), alternative);
}
}
void AlternativeIncrGAnalyzer.AnalyzeAgain(IncrGAnalysisListener listener)
{
var index = nextIndex;
var innerListener = new SubListener {
clientListner = listener, parent = parent, nextAnalyzerIndex = index, originalInput = originalInput
};
if (subAltAnalyzer != null)
{
subAltAnalyzer.AnalyzeAgain(innerListener);
}
while (!innerListener.didHit && index < parent.candidates.Count)
{
innerListener.nextAnalyzerIndex++;
parent.candidates[index].Analyze(originalInput, innerListener);
index++;
}
}
void AlternativeIncrGAnalyzer.AnalyzeAgain(IncrGAnalysisListener listener)
{
#region try past alternatives
if (previousAlt != null)
{
var altLis = new EasyIncrGAnalysListener();
previousAlt.AnalyzeAgain(altLis);
if (altLis.didMatch)
{
var alt = new PrvtAltIGAnlys {
parent = parent, previousAlt = altLis.alternative, analyzers = analyzers, input = input
};
listener.OnMatch(altLis.nextInput, altLis.listener, alt);
return;
}
}
#endregion
#region try repeat
/*if (parent.conjectionAnalyzer != null && !parent.isConjectionOptional) {
* var easyConjLis = new EasyIncrGAnalysListener();
* parent.conjectionAnalyzer.Analyze(input, easyConjLis);
* if (!easyConjLis.didMatch) {
* return;
* }
* }*/
var newAnalyzers = new List <IncrementalGAnalyzer>(analyzers);
if (parent.conjectionAnalyzer != null)
{
if (parent.isConjectionOptional)
{
newAnalyzers.Add(new IGAnlys_IgnoreBlock {
baseAnalyzer = new IGAnlys_Optional {
baseAnalyzer = parent.conjectionAnalyzer
}
});
}
else
{
newAnalyzers.Add(new IGAnlys_IgnoreBlock {
baseAnalyzer = parent.conjectionAnalyzer
});
}
}
newAnalyzers.Add(parent.baseAnalyzer);
var repeatLis = new EasyIncrGAnalysListener();
newAnalyzers[0].Analyze(
input,
new ChainListener {
index = 0,
results = new List <IndexAndResult>(),
analyzers = newAnalyzers,
finalListener = repeatLis,
afterListenerFactory = DefaultAfterListener
}
);
if (repeatLis.didMatch)
{
listener.OnMatch(repeatLis.nextInput, repeatLis.listener,
new PrvtAltIGAnlys {
analyzers = newAnalyzers, input = input, parent = parent, previousAlt = repeatLis.alternative
}
);
}
#endregion
}
void AlternativeIncrGAnalyzer.AnalyzeAgain(IncrGAnalysisListener listener)
{
baseAltAnalyzer.AnalyzeAgain(new ResultChangingIGAListener {
parent = parent, baseListener = listener
});
}
