/// <summary>
/// Creates a new <see cref="InlinedTokenExpressionSeries"/> with the
/// <paramref name="source"/>, <paramref name="sourceRoot"/> and
/// <paramref name="root"/>
/// </summary>
/// <param name="source">The <see cref="TokenExpressionSeries"/> from which the current
/// <see cref="InlinedTokenExpressionSeries"/> derives.</param>
/// <param name="sourceRoot">The <see cref="IOilexerGrammarTokenEntry"/> which contains the
/// <paramref name="source"/>.</param>
/// <param name="root">The <see cref="InlinedTokenEntry"/> which contains the <see cref="InlinedTokenExpressionSeries"/>.</param>
public InlinedTokenExpressionSeries(ITokenExpressionSeries source, IOilexerGrammarTokenEntry sourceRoot, InlinedTokenEntry root, IDictionary <ITokenItem, ITokenItem> oldNewLookup)
: base(OilexerGrammarInliningCore.Inline(source.ToArray(), sourceRoot, root, oldNewLookup), source.Line, source.Column, source.Position, source.FileName)
{
this.Source = source;
this.SourceRoot = SourceRoot;
this.Root = root;
}
public SubtractionCommandTokenItem(ITokenExpressionSeries left, ITokenExpressionSeries right, int column, int line, long position)
: base(new ITokenExpressionSeries[2] {
left, right
}, column, line, position)
{
this.left = left;
this.right = right;
}
public ScanCommandTokenItem(ITokenExpressionSeries searchTarget, bool seekPast, int column, int line, long position)
: base(new ITokenExpressionSeries[1] {
searchTarget
}, column, line, position)
{
this.seekPast = seekPast;
this.searchTarget = searchTarget;
}
public OilexerGrammarTokenEntry(string name, ITokenExpressionSeries branches, EntryScanMode scanMode, string fileName, int column, int line, long position, bool unhinged, IOilexerGrammarTokenEntry[] lowerPrecedences, bool forcedRecognizer)
: base(name, fileName, column, line, position)
{
this.lowerPrecedenceTokens = lowerPrecedences;
this.scanMode = scanMode;
this.branches = branches;
this.unhinged = unhinged;
this.forcedRecognizer = forcedRecognizer;
}
public BaseEncodeGraphCommand(ITokenExpressionSeries searchTarget, OilexerGrammarTokens.StringLiteralToken stringBase, OilexerGrammarTokens.NumberLiteral digits, int column, int line, long position)
: base(new ITokenExpressionSeries[1] {
searchTarget
}, column, line, position)
{
this.encodeTarget = searchTarget;
this.digits = digits;
this.stringBase = stringBase;
}
private static bool AnyContainAName(ITokenExpressionSeries series)
{
foreach (var expression in series)
{
if (AnyContainAName(expression))
{
return(true);
}
}
return(false);
}
private static int GetFixedLength(ITokenExpressionSeries series)
{
var result = -1;
foreach (var expression in series)
{
var currentLength = GetFixedLength(expression);
if (result == -1 && currentLength != -1)
{
result = currentLength;
}
else if (currentLength != result)
{
return(-1);
}
}
return(result);
}
private static List <ICaptureTokenStructuralItem> PollGroup(ITokenExpressionSeries series, ICaptureTokenStructure structure)
{
List <ICaptureTokenStructuralItem> result = new List <ICaptureTokenStructuralItem>();
foreach (var expression in series)
{
foreach (var item in expression)
{
var firstOrDef = structure.Values.FirstOrDefault(k => k.Sources.Contains(item));
if (firstOrDef != null)
{
result.Add(firstOrDef);
}
else if (item is ITokenGroupItem)
{
result.AddRange(PollGroup((ITokenGroupItem)item, structure));
}
}
}
return(result);
}
private static void ResolveTokenExpressionSeries(this ITokenExpressionSeries series, IOilexerGrammarTokenEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors)
{
foreach (ITokenExpression ite in series)
ite.ResolveTokenExpression(entry, file, errors);
}
internal static RegularCaptureType DetermineKind(IOilexerGrammarTokenEntry entry, ITokenExpressionSeries series, IOilexerGrammarFile file)
{
RegularCaptureType result = RegularCaptureType.Undecided;
foreach (var expression in series)
{
var currentKind = DetermineKind(entry, expression, file);
switch (currentKind)
{
case RegularCaptureType.Recognizer:
if (result == RegularCaptureType.Undecided)
{
result = currentKind;
}
break;
case RegularCaptureType.Capturer:
result = currentKind;
break;
case RegularCaptureType.Transducer:
if (result == RegularCaptureType.Undecided)
{
result = RegularCaptureType.Transducer;
}
else if (result == RegularCaptureType.Recognizer)
{
result = RegularCaptureType.Capturer;
}
break;
}
}
if (result == RegularCaptureType.Undecided)
{
result = RegularCaptureType.Recognizer;
}
if (result == RegularCaptureType.Transducer)
{
if ((from gdEntry in file
where gdEntry is IOilexerGrammarProductionRuleEntry
let ruleEntry = (IOilexerGrammarProductionRuleEntry)gdEntry
from productionRuleItem in GetProductionRuleSeriesItems(ruleEntry)
where productionRuleItem is ILiteralReferenceProductionRuleItem
let literalItem = (ILiteralReferenceProductionRuleItem)productionRuleItem
where literalItem.Source == entry
select literalItem).Count() > 0)
{
return(RegularCaptureType.ContextfulTransducer);
}
}
return(result);
}
private static ICaptureTokenStructuralItem BuildStructureFor(InlinedTokenEntry entry, ITokenExpressionSeries expressionSeries, ITokenExpression expression, ITokenItem item, IOilexerGrammarFile source)
{
ICaptureTokenStructuralItem result = null;
if (item is ITokenGroupItem)
{
var tokenGroup = ((ITokenGroupItem)(item));
result = BuildStructureFor(entry, tokenGroup, source);
if (result.ResultType == ResultedDataType.None && !string.IsNullOrEmpty(item.Name))
{
if (tokenGroup.Count == 1 && tokenGroup[0].Count == 1)
{
var singleItem = tokenGroup[0][0];
if (singleItem is ILiteralCharTokenItem || singleItem is ILiteralCharReferenceTokenItem)
{
if (singleItem.RepeatOptions == ScannableEntryItemRepeatInfo.None && tokenGroup.RepeatOptions == ScannableEntryItemRepeatInfo.None)
{
result.ResultType = ResultedDataType.Character;
}
else
{
result.ResultType = ResultedDataType.String;
}
}
else
{
result.ResultType = ResultedDataType.String;
}
}
else
{
result.ResultType = ResultedDataType.String;
}
}
bool groupOptional = tokenGroup != null &&
((tokenGroup.RepeatOptions.Options & ScannableEntryItemRepeatOptions.ZeroOrMore) == ScannableEntryItemRepeatOptions.ZeroOrMore ||
(tokenGroup.RepeatOptions.Options & ScannableEntryItemRepeatOptions.ZeroOrOne) == ScannableEntryItemRepeatOptions.ZeroOrOne ||
(((tokenGroup.RepeatOptions.Options & ScannableEntryItemRepeatOptions.Specific) == ScannableEntryItemRepeatOptions.Specific) &&
(!tokenGroup.RepeatOptions.Min.HasValue || tokenGroup.RepeatOptions.Min.Value == 0)));
if (groupOptional)
{
result.GroupOptional = groupOptional;
}
if (item.Name.IsEmptyOrNull())
{
result.ResultType = ResultedDataType.PassThrough;
/*
* if ((item.RepeatOptions.Options & ScannableEntryItemRepeatOptions.ZeroOrMore) == ScannableEntryItemRepeatOptions.ZeroOrMore ||
* (item.RepeatOptions.Options & ScannableEntryItemRepeatOptions.ZeroOrOne) == ScannableEntryItemRepeatOptions.ZeroOrOne ||
* ((item.RepeatOptions.Options & ScannableEntryItemRepeatOptions.Specific) == ScannableEntryItemRepeatOptions.Specific &&
* (!item.RepeatOptions.Min.HasValue || item.RepeatOptions.Min.Value == 0)))
* foreach (var element in ((ICaptureTokenStructure)result).Values)
* element.Optional = true;*/
}
((ControlledCollection <ITokenSource>)(result.Sources)).baseList.Add(item);
}
else if (item is ILiteralTokenItem)
{
result = new CaptureTokenLiteralStructuralItem((ILiteralTokenItem)item);
if (entry.CaptureKind == RegularCaptureType.Transducer)
{
result.ResultType = ResultedDataType.EnumerationItem;
}
else if (entry.CaptureKind == RegularCaptureType.ContextfulTransducer)
{
result.ResultType = ResultedDataType.FlagEnumerationItem;
}
}
else if (item is ICharRangeTokenItem)
{
result = new CaptureTokenCharRangeStructuralItem((ICharRangeTokenItem)item);
if (entry.CaptureKind == RegularCaptureType.Transducer)
{
result.ResultType = ResultedDataType.EnumerationItem;
}
else if (entry.CaptureKind == RegularCaptureType.ContextfulTransducer)
{
result.ResultType = ResultedDataType.FlagEnumerationItem;
}
}
Deform(item, result, expression);
return(result);
}
private static ICaptureTokenStructure BuildStructureFor(InlinedTokenEntry entry, ITokenExpressionSeries expressionSeries, ITokenExpression expression, IOilexerGrammarFile source)
{
ICaptureTokenStructure result = new CaptureTokenStructure();
foreach (var item in expression)
{
var current = BuildStructureFor(entry, expressionSeries, expression, item, source);
result = result.Concat(current);
}
return(result);
}
private static Dictionary <ITokenGroupItem, List <ICaptureTokenStructuralItem> > PickOptionalGroups(ITokenExpressionSeries series, ICaptureTokenStructure structure)
{
Dictionary <ITokenGroupItem, List <ICaptureTokenStructuralItem> > result = new Dictionary <ITokenGroupItem, List <ICaptureTokenStructuralItem> >();
foreach (var expression in series)
{
foreach (var item in expression)
{
if (item is ITokenGroupItem)
{
var groupItem = (ITokenGroupItem)item;
if ((item.RepeatOptions.Options & ScannableEntryItemRepeatOptions.ZeroOrMore) == ScannableEntryItemRepeatOptions.ZeroOrMore ||
(item.RepeatOptions.Options & ScannableEntryItemRepeatOptions.ZeroOrOne) == ScannableEntryItemRepeatOptions.ZeroOrOne ||
(item.RepeatOptions.Options & ScannableEntryItemRepeatOptions.Specific) == ScannableEntryItemRepeatOptions.Specific &&
(!item.RepeatOptions.Min.HasValue || item.RepeatOptions.Min.Value == 0))
{
/* *
* Found an optional token group, now to search
* within to see what we have inside.
* */
var firstOrDef = structure.Values.FirstOrDefault(k => k.Sources.Contains(item));
if (firstOrDef != null)
{
result.Add(groupItem, new List <ICaptureTokenStructuralItem>()
{
firstOrDef
});
}
else
{
var currentSet = PollGroup(groupItem, structure);
if (currentSet.Count > 0)
{
result.Add(groupItem, currentSet);
}
}
}
else
{
var subResult = PickOptionalGroups(groupItem, structure);
foreach (var element in subResult.Keys)
{
if (result.ContainsKey(element))
{
result[element].AddRange(subResult[element]);
}
}
}
}
}
}
return(result);
}
private static ICaptureTokenStructure BuildStructureFor(InlinedTokenEntry entry, ITokenExpressionSeries expressionSeries, IOilexerGrammarFile source)
{
ICaptureTokenStructure result = null;
HashList <HashList <string> > currentResultVariants = new HashList <HashList <string> >();
foreach (var expression in expressionSeries)
{
var current = BuildStructureFor(entry, expressionSeries, expression, source);
if (result == null)
{
result = current;
}
else
{
result = result.Union(current);
}
if (entry.CaptureKind == RegularCaptureType.Capturer)
{
var dataSet = new HashList <string>(current.Keys);
if (!currentResultVariants.Any(k => k.SequenceEqual(dataSet)))
{
currentResultVariants.Add(dataSet);
}
}
}
foreach (var variant in currentResultVariants)
{
result.Structures.Add(variant);
}
if (expressionSeries == entry.Branches)
{
((ControlledCollection <ITokenSource>)result.Sources).baseList.Add(entry);
}
result.ResultedTypeName = string.Format("{0}{1}{2}", source.Options.TokenPrefix, entry.Name, source.Options.TokenSuffix);
return(result);
}
