void IncrementalGAnalyzer.Analyze(GAnlysInput input, IncrGAnalysisListener listener)
{
var easyLis = new EasyIncrGAnalysListener();
baseAnalyzer.Analyze(input, easyLis);
if (easyLis.didMatch)
{
var alt = new PrvtAltIGAnlys {
parent = this, previousResult = new List <EasyIncrGAnalysListener> {
easyLis
}
};
listener.OnMatch(easyLis.nextInput, easyLis.listener, alt);
}
}
void IncrementalGAnalyzer.Analyze(GAnlysInput input, IncrGAnalysisListener listener)
{
var easyLis = new EasyIncrGAnalysListener();
baseAnalyzer.Analyze(input, easyLis);
if (easyLis.didMatch)
{
var alt = new PrvtAltIGAnlys {
input = input, parent = this, previousAlt = easyLis.alternative, analyzers = new List <IncrementalGAnalyzer> {
baseAnalyzer
}
};
listener.OnMatch(easyLis.nextInput, easyLis.listener, alt);
}
}
void AlternativeIncrGAnalyzer.AnalyzeAgain(IncrGAnalysisListener listener)
{
Stack <EasyIncrGAnalysListener> resultArchives = new Stack <EasyIncrGAnalysListener>(givenResultArchive);
EasyIncrGAnalysListener lastLis = null;
while (true)
{
if (resultArchives.Count <= 0)
{
return;
}
var analyzer = resultArchives.Pop();
if (analyzer.alternative == null)
{
continue;
}
var easyLis = new EasyIncrGAnalysListener();
analyzer.alternative.AnalyzeAgain(easyLis);
if (easyLis.didMatch)
{
resultArchives.Push(easyLis);
lastLis = easyLis;
break;
}
}
while (true)
{
if (parent.conjectionAnalyzer != null)
{
var conjLis = new EasyIncrGAnalysListener {
};
parent.conjectionAnalyzer.Analyze(lastLis.nextInput, conjLis);
if (conjLis.didMatch)
{
lastLis = conjLis;
}
else if (!parent.isConjectionOptional)
{
return;
}
}
var easyLis = new EasyIncrGAnalysListener();
parent.baseAnalyzer.Analyze(lastLis.nextInput, easyLis);
if (!easyLis.didMatch)
{
if (resultArchives.Count == 0)
{
return;
}
else
{
break;
}
}
else
{
resultArchives.Push(easyLis);
}
}
List <AfterMatchListener> afLiss = new List <AfterMatchListener>();
foreach (var result in resultArchives)
{
afLiss.Add(result.listener);
}
bool hasAlt = false;
foreach (var result in resultArchives)
{
if (result.alternative != null)
{
hasAlt = true;
}
}
AlternativeIncrGAnalyzer altAnlys = null;
if (hasAlt)
{
altAnlys = new PrvtAltIGAnlys {
givenResultArchive = resultArchives, parent = parent
};
}
listener.OnMatch(resultArchives.Peek().nextInput, new PrvtLis {
listeners = afLiss
}, altAnlys);
}
void IncrementalGAnalyzer.Analyze(GAnlysInput input, IncrGAnalysisListener listener)
{
Stack <EasyIncrGAnalysListener> resultArchives = new Stack <EasyIncrGAnalysListener>();
while (true)
{
var currentInput = resultArchives.Count == 0 ? input : resultArchives.Peek().nextInput;
if (resultArchives.Count > 0 && conjectionAnalyzer != null)
{
var conjLis = new EasyIncrGAnalysListener();
conjectionAnalyzer.Analyze(currentInput, conjLis);
if (conjLis.didMatch)
{
currentInput = conjLis.nextInput;
}
if (!conjLis.didMatch && !isConjectionOptional)
{
break;
}
}
var easyLis = new EasyIncrGAnalysListener();
baseAnalyzer.Analyze(currentInput, easyLis);
if (!easyLis.didMatch)
{
if (resultArchives.Count == 0)
{
return;
}
else
{
break;
}
}
else
{
resultArchives.Push(easyLis);
}
}
List <AfterMatchListener> afLiss = new List <AfterMatchListener>();
foreach (var result in resultArchives)
{
afLiss.Add(result.listener);
}
bool hasAlt = false;
foreach (var result in resultArchives)
{
if (result.alternative != null)
{
hasAlt = true;
}
}
AlternativeIncrGAnalyzer altLis = null;
if (hasAlt)
{
altLis = new PrvtAltIGAnlys {
givenResultArchive = resultArchives, parent = this
};
}
listener.OnMatch(resultArchives.Peek().nextInput, new PrvtLis {
listeners = afLiss
}, altLis);
}
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
}
