private static IProductionRuleCaptureStructure BuildStructureFor(OilexerGrammarProductionRuleEntry entry, IProductionRuleSeries expressionSeries, IOilexerGrammarFile source)
{
IProductionRuleCaptureStructure 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);
}
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)
{
((ControlledCollection <IProductionRuleSource>)result.Sources).baseList.Add(entry);
}
result.ResultedTypeName = string.Format("{0}{1}{2}", source.Options.RulePrefix, entry.Name, source.Options.RuleSuffix);
return(result);
}
public static void FinalLink(this IOilexerGrammarProductionRuleEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors)
{
if (entry.NeedsFinalLinking())
{
List <IProductionRule> result = new List <IProductionRule>();
foreach (IProductionRule currentItem in entry)
{
IProductionRule resultIPR = null;
if (currentItem.NeedsFinalLinking())
{
resultIPR = currentItem.FinalLink(entry, file, errors);
}
else
{
resultIPR = currentItem;
}
if (resultIPR != null)
{
result.Add(resultIPR);
}
}
OilexerGrammarProductionRuleEntry r = ((OilexerGrammarProductionRuleEntry)(entry));
r.Clear();
foreach (IProductionRule ipr in result)
{
r.Add(ipr);
}
}
}
public static void Deliteralize(this IOilexerGrammarProductionRuleEntry entry, IList <IOilexerGrammarTokenEntry> availableStock, OilexerGrammarFile file, ICompilerErrorCollection errors)
{
if (entry.NeedsDeliteralized())
{
List <IProductionRule> result = new List <IProductionRule>();
foreach (IProductionRule ipr in entry)
{
IProductionRule resultIPR = null;
if (ipr.NeedsDeliteralized())
{
resultIPR = ipr.Deliteralize(entry, availableStock, file, errors);
}
else
{
resultIPR = ipr;
}
if (resultIPR != null)
{
result.Add(resultIPR);
}
}
OilexerGrammarProductionRuleEntry r = ((OilexerGrammarProductionRuleEntry)(entry));
r.Clear();
foreach (IProductionRule ipr in result)
{
r.Add(ipr);
}
//currentEntry = null;
}
}
private static IProductionRuleCaptureStructure BuildStructureFor(OilexerGrammarProductionRuleEntry entry, IProductionRuleSeries expressionSeries, IProductionRule expression, IOilexerGrammarFile source)
{
IProductionRuleCaptureStructure result = new ProductionRuleCaptureStructure(entry);
foreach (var item in expression)
{
var current = BuildStructureFor(entry, expressionSeries, expression, item, source);
result = result.Concat(current);
}
return(result);
}
public static void ReplaceReferences(IOilexerGrammarFile source, IOilexerGrammarProductionRuleEntry target, IDictionary <IProductionRuleItem, IProductionRuleItem> elementToElementList)
{
OilexerGrammarProductionRuleEntry r = (OilexerGrammarProductionRuleEntry)(target);
IProductionRuleSeries resultSeries = ReplaceReferences(source, ((IProductionRuleSeries)(r)).ToArray(), elementToElementList);
r.Clear();
foreach (var rule in resultSeries)
{
r.Add(rule);
}
}
internal static void ExpandTemplates(this IOilexerGrammarProductionRuleEntry entry, IList <IOilexerGrammarTokenEntry> availableStock, OilexerGrammarFile file, ICompilerErrorCollection errors)
{
while (entry.NeedsExpansion())
{
OilexerGrammarProductionRuleEntry e = ((OilexerGrammarProductionRuleEntry)(entry));
IProductionRuleSeries iprs = entry.ExpandTemplates(availableStock, entry, file, errors);
e.Clear();
foreach (IProductionRule ipr in iprs)
{
e.Add(ipr);
}
}
}
internal static void Expand(this IPreprocessorAddRuleDirective directive, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, ProductionRuleTemplateArgumentSeries argumentLookup, IOilexerGrammarProductionRuleTemplateEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors)
{
string search = directive.InsertTarget;
if (search != null && search != string.Empty)
{
OilexerGrammarProductionRuleEntry foundItem = null;
if (argumentLookup.ContainsParameter(search))
{
IProductionRuleTemplatePart part = argumentLookup.GetParameter(search);
IProductionRuleSeries iprs = argumentLookup[part];
if (iprs.Count == 1 && iprs[0].Count == 1)
{
IProductionRuleItem ipri = iprs[0][0];
if (ipri is ISoftReferenceProductionRuleItem)
{
ISoftReferenceProductionRuleItem n = (ISoftReferenceProductionRuleItem)ipri;
search = n.PrimaryName;
}
else if (ipri is IRuleReferenceProductionRuleItem)
{
foundItem = (OilexerGrammarProductionRuleEntry)((IRuleReferenceProductionRuleItem)(ipri)).Reference;
}
}
}
if (foundItem == null)
{
foreach (IOilexerGrammarEntry ie in file)
{
if (ie is OilexerGrammarProductionRuleEntry && ((OilexerGrammarProductionRuleEntry)ie).Name == search)
{
foundItem = ie as OilexerGrammarProductionRuleEntry;
break;
}
}
}
if (foundItem == null)
{
errors.SourceError(OilexerGrammarCore.CompilerErrors.UndefinedAddRuleTarget, new LineColumnPair(directive.Line, directive.Column), LineColumnPair.Zero, new Uri(entry.FileName, UriKind.RelativeOrAbsolute), string.Join <IProductionRule>(" | ", directive.Rules), search);
return;
}
foreach (IProductionRule ipr in directive.Rules)
{
foundItem.Add(ipr.Expand(currentEntry, availableStock, argumentLookup, entry, file, errors));
}
}
}
internal static void Expand(this IPreprocessorDefineRuleDirective directive, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, ProductionRuleTemplateArgumentSeries argumentLookup, IOilexerGrammarProductionRuleTemplateEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors)
{
string search = directive.DeclareTarget;
if (search != null && search != string.Empty)
{
if (argumentLookup.ContainsParameter(search))
{
IProductionRuleTemplatePart part = argumentLookup.GetParameter(search);
IProductionRuleSeries iprs = argumentLookup[part];
if (iprs.Count == 1 && iprs[0].Count == 1)
{
IProductionRuleItem ipri = iprs[0][0];
if (ipri is ISoftReferenceProductionRuleItem)
{
ISoftReferenceProductionRuleItem n = (ISoftReferenceProductionRuleItem)ipri;
search = n.PrimaryName;
}
}
}
/* ToDo: Evaluate the depth necessary to institute a lock associated to the base list on the oilexer grammar file type. */
IOilexerGrammarEntry[] fileElements;
lock (file)
fileElements = file.ToArray();
foreach (IOilexerGrammarEntry ie in fileElements)
{
if (ie is IOilexerGrammarNamedEntry && ((IOilexerGrammarNamedEntry)ie).Name == search)
{
errors.SourceError(OilexerGrammarCore.CompilerErrors.DuplicateTermDefined, new LineColumnPair(directive.Line, directive.Column), LineColumnPair.Zero, new Uri(entry.FileName, UriKind.RelativeOrAbsolute), search);
return;
}
}
OilexerGrammarProductionRuleEntry insertedItem = new OilexerGrammarProductionRuleEntry(search, entry.ScanMode, entry.FileName, directive.Column, directive.Line, directive.Position);
lock (file)
file.Add(insertedItem);
foreach (IProductionRule ipr in directive.DefinedRules)
{
IProductionRule expanded = ipr.Expand(currentEntry, availableStock, argumentLookup, entry, file, errors);
insertedItem.Add(expanded);
}
}
}
private static IProductionRuleCaptureStructuralItem BuildStructureFor(OilexerGrammarProductionRuleEntry entry, IProductionRuleSeries expressionSeries, IProductionRule expression, IProductionRuleItem item, IOilexerGrammarFile source)
{
IProductionRuleCaptureStructuralItem result = null;
if (item is IProductionRuleGroupItem)
{
var ruleGroup = ((IProductionRuleGroupItem)(item));
if (!ruleGroup.Name.IsEmptyOrNull() && AllAreUnnamedEquivalents(ruleGroup))
{
SetAllNames(ruleGroup, ruleGroup.Name);
}
result = BuildStructureFor(entry, ruleGroup, source);
if (result.ResultType == ResultedDataType.None && !item.Name.IsEmptyOrNull())
{
if (ruleGroup.Count == 1 && ruleGroup[0].Count == 1)
{
var singleItem = ruleGroup[0][0];
if (singleItem is ILiteralCharReferenceProductionRuleItem)
{
if (singleItem.RepeatOptions == ScannableEntryItemRepeatInfo.None && ruleGroup.RepeatOptions == ScannableEntryItemRepeatInfo.None)
{
result.ResultType = ResultedDataType.Character;
}
else
{
result.ResultType = ResultedDataType.String;
}
}
else
{
result.ResultType = ResultedDataType.String;
}
}
else
{
result.ResultType = ResultedDataType.String;
}
}
else if (item.Name.IsEmptyOrNull())
{
result.ResultType = ResultedDataType.PassThrough;
}
((ControlledCollection <IProductionRuleSource>)(result.Sources)).baseList.Add(item);
}
else if (item is ILiteralReferenceProductionRuleItem)
{
var literalRefItem = (ILiteralReferenceProductionRuleItem)item;
var inlinedRef = ((InlinedTokenEntry)(literalRefItem.Source));
result = new ProductionRuleLiteralTokenItemReferenceStructuralItem(literalRefItem.Source, literalRefItem, entry);
if (inlinedRef.CaptureKind == RegularCaptureType.Transducer)
{
result.ResultType = ResultedDataType.EnumerationItem;
}
else if (inlinedRef.CaptureKind == RegularCaptureType.ContextfulTransducer)
{
result.ResultType = ResultedDataType.FlagEnumerationItem;
}
}
else if (item is ITokenReferenceProductionRuleItem)
{
var tokenRefItem = ((ITokenReferenceProductionRuleItem)(item));
var inlinedRef = ((InlinedTokenEntry)(tokenRefItem.Reference));
result = new ProductionRuleTokenReferenceStructuralItem((ITokenReferenceProductionRuleItem)item, entry);
if (inlinedRef.CaptureKind == RegularCaptureType.Transducer)
{
result.ResultType = ResultedDataType.Enumeration;
}
else
{
result.ResultType = ResultedDataType.ImportType;
}
}
else if (item is IRuleReferenceProductionRuleItem)
{
var ruleItem = (IRuleReferenceProductionRuleItem)item;
result = new ProductionRuleCaptureReferenceStructuralItem(ruleItem, entry);
}
Deform(item, result, expression);
return(result);
}
private static void BuildStructureConstructors(IProductionRuleCaptureStructure targetStructure, OilexerGrammarProductionRuleEntry structureRoot, ITypeIdentityManager identityManager)
{
int stateIndex = 0;
foreach (var element in targetStructure.Values)
{
element.StateIndex = stateIndex++;
}
IEnumerable <IEnumerable <Tuple <IProductionRuleCaptureStructuralItem, bool> > > validVariations = new IEnumerable <Tuple <IProductionRuleCaptureStructuralItem, bool> > [0];
var firstOrDefSeries = (IProductionRuleSeries)targetStructure.Sources.FirstOrDefault(k => k is IProductionRuleSeries);
var firstOrDefProductionRule = (IOilexerGrammarProductionRuleEntry)targetStructure.Sources.FirstOrDefault(k => k is IOilexerGrammarProductionRuleEntry);
var optg = PickOptionalGroups(firstOrDefProductionRule == null ? firstOrDefSeries : firstOrDefProductionRule, targetStructure);
foreach (var parameterSet in targetStructure.Structures)
{
var limitedSet = (from param in parameterSet
join item in targetStructure.Keys on param equals item
select new { Name = item, Item = targetStructure[item] }).ToArray();
var optionalSet = (from l in limitedSet
where l.Item.Optional
select l).ToArray();
if (limitedSet.Length > 0)
{
var parameterPermutations = VariateSeries(new LockedLinkedList <IProductionRuleCaptureStructuralItem>(from l in limitedSet
select l.Item).First, optg).Distinct();
validVariations = validVariations.Concat(parameterPermutations);
foreach (var variation in parameterPermutations)
{
bool[] parameterStateFlags = (from k in variation.ToArray()
select k.Item2).ToArray();
List <string> parameterResult = new List <string>();
for (int parameterIndex = 0; parameterIndex < parameterStateFlags.Length; parameterIndex++)
{
if (parameterStateFlags[parameterIndex])
{
var limitedEntry = limitedSet[parameterIndex];
parameterResult.Add(limitedEntry.Name);
}
}
//if (!resultantParameterSets.Any(k => k.SequenceEqual(parameterResult)))
// resultantParameterSets.Add(parameterResult);
}
}
}
List <IEnumerable <Tuple <IProductionRuleCaptureStructuralItem, bool> > > toRemove = new List <IEnumerable <Tuple <IProductionRuleCaptureStructuralItem, bool> > >();
var exclusiveDistinctions = (from set in validVariations.Distinct().ToArray()
let parameters =
from parameter in set
where parameter.Item2
select parameter.Item1
orderby string.Join(string.Empty, from k in parameters
select k.BucketName)
select new HashList <IProductionRuleCaptureStructuralItem>(parameters)).Distinct();
var stateField = targetStructure.ResultClass.Fields.Add(new TypedName("state", identityManager.ObtainTypeReference(RuntimeCoreType.Int32)));
var toStringMethod = targetStructure.ResultClass.Methods.Add(new TypedName("ToString", identityManager.ObtainTypeReference(RuntimeCoreType.String)));
toStringMethod.AccessLevel = AccessLevelModifiers.Public;
toStringMethod.IsOverride = true;
var toStringStateSwitch = toStringMethod.Switch(stateField.GetReference());
toStringMethod.Return(identityManager.ObtainTypeReference(RuntimeCoreType.String).GetTypeExpression().GetField("Empty"));
var formatMethod = identityManager.ObtainTypeReference(RuntimeCoreType.String).GetTypeExpression().GetMethod("Format");
foreach (var parameterSetVariation in exclusiveDistinctions)
{
TypedNameSeries currentCtorTNS = new TypedNameSeries();
int currentStateValue = 0;
foreach (var parameterEntry in parameterSetVariation)
{
var parameterName = parameterEntry.BucketName;
var currentElement = targetStructure[parameterName];
IType parameterType = null;
switch (currentElement.ResultType)
{
case ResultedDataType.EnumerationItem:
case ResultedDataType.Flag:
parameterType = identityManager.ObtainTypeReference(RuntimeCoreType.Boolean);
break;
case ResultedDataType.Enumeration:
IProductionRuleCaptureStructure enumStructure = (IProductionRuleCaptureStructure)currentElement;
parameterType = enumStructure.AggregateSetEnum ?? enumStructure.ResultEnumSet[0];
break;
case ResultedDataType.ComplexType:
IProductionRuleCaptureStructure dualStructure = (IProductionRuleCaptureStructure)currentElement;
parameterType = dualStructure.ResultInterface;
break;
case ResultedDataType.Counter:
parameterType = identityManager.ObtainTypeReference(RuntimeCoreType.Int32);
break;
case ResultedDataType.Character:
parameterType = identityManager.ObtainTypeReference(RuntimeCoreType.Char);
break;
case ResultedDataType.String:
parameterType = identityManager.ObtainTypeReference(RuntimeCoreType.String);
break;
default:
throw new InvalidOperationException("Unknown parameter type.");
}
currentStateValue |= (int)Math.Pow(2, parameterEntry.StateIndex);
currentCtorTNS.Add(LowerFirstCharacter(parameterName), parameterType);
}
var currentCtor = targetStructure.ResultClass.Constructors.Add(currentCtorTNS);
currentCtor.AccessLevel = AccessLevelModifiers.Public;
currentCtor.Assign(stateField.GetReference(), currentStateValue.ToPrimitive());
var currentStateCase = toStringStateSwitch.Case(currentStateValue.ToPrimitive());
var currentInvocation = formatMethod.Invoke();
currentStateCase.Return(currentInvocation);
var currentFormat = string.Empty.ToPrimitive();
currentInvocation.Arguments.Add(currentFormat);
StringBuilder formatBuilder = new StringBuilder();
bool first = true;
int currentParamIndex = 0;
foreach (var parameterEntry in parameterSetVariation)
{
if (first)
{
first = false;
}
else
{
formatBuilder.Append(", ");
}
formatBuilder.AppendFormat("{{{0}}}", currentParamIndex++);
var parameterName = parameterEntry.BucketName;
var currentElement = targetStructure[parameterName];
IIntermediateFieldMember currentField = currentElement.AssociatedField;
currentInvocation.Arguments.Add(currentField.GetReference());
currentCtor.Assign(currentField.GetReference(), currentCtor.Parameters[LowerFirstCharacter(parameterName)].GetReference());
}
currentFormat.Value = formatBuilder.ToString();
}
}
internal static SelectiveTuple <Tuple <IIntermediateClassType, IIntermediateInterfaceType>, IIntermediateEnumType, Tuple <IIntermediateEnumType, IIntermediateEnumType[]> > CreateProgramStructure(IProductionRuleCaptureStructure targetStructure, IIntermediateNamespaceDeclaration owner, OilexerGrammarProductionRuleEntry structureRoot)
{
switch (targetStructure.ResultType)
{
case ResultedDataType.Enumeration:
bool isFlagSet = targetStructure.Values.All(k => k.ResultType == ResultedDataType.FlagEnumerationItem);
bool useBucketName = targetStructure != structureRoot.CaptureStructure;
if (targetStructure.Count > sizeof(SlotType) * 8 && isFlagSet)
{
var chunkedSets = targetStructure.Values.ToArray().Chunk(sizeof(SlotType) * 8);
IIntermediateEnumType[] resultSet = new IIntermediateEnumType[chunkedSets.Length];
IIntermediateEnumType aggregateSet = null;
aggregateSet = owner.Parts.Add().Enums.Add("{0}Cases", targetStructure.ResultedTypeName);
for (int chunkIndex = 0; chunkIndex < chunkedSets.Length; chunkIndex++)
{
var chunkSet = chunkedSets[chunkIndex];
int fieldIndex = 0;
var resultEnum = resultSet[chunkIndex] = owner.Parts.Add().Enums.Add("Valid{0}Set{1}", useBucketName ? targetStructure.BucketName : structureRoot.Name, (chunkIndex + 1));
resultEnum.AccessLevel = AccessLevelModifiers.Public;
resultEnum.Fields.Add("None");
#if x86
resultEnum.ValueType = EnumerationBaseType.UInt32;
#elif x64
resultEnum.ValueType = EnumerationBaseType.UInt64;
#endif
foreach (var element in chunkSet)
{
switch (element.ResultType)
{
case ResultedDataType.EnumerationItem:
resultEnum.Fields.Add(element.BucketName);
break;
case ResultedDataType.FlagEnumerationItem:
var resultField = resultEnum.Fields.Add(element.BucketName, (SlotType)Math.Pow(2, fieldIndex++));
break;
default:
throw new InvalidOperationException("Enums are supposed to yield an " +
"enumeration, result element is of an invalid type.");
}
aggregateSet.Fields.Add(element.BucketName);
}
}
targetStructure.ResultEnumSet = resultSet;
targetStructure.AggregateSetEnum = aggregateSet;
return(new SelectiveTuple <Tuple <IIntermediateClassType, IIntermediateInterfaceType>, IIntermediateEnumType, Tuple <IIntermediateEnumType, IIntermediateEnumType[]> >(Tuple.Create(aggregateSet, resultSet)));
}
else
{
IIntermediateEnumType resultEnum = null;
IIntermediateEnumType aggregateSet = null;
if (isFlagSet)
{
aggregateSet = owner.Enums.Add("{0}Cases", targetStructure.ResultedTypeName);
resultEnum = owner.Enums.Add("Valid{0}", useBucketName ? targetStructure.BucketName : structureRoot.Name);
}
else
{
resultEnum = owner.Enums.Add(targetStructure.ResultedTypeName);
}
resultEnum.AccessLevel = AccessLevelModifiers.Public;
int numNonFlags = (from f in targetStructure.Values
where f.ResultType == ResultedDataType.EnumerationItem
select f).Count();
int flagFieldIndex = isFlagSet ? 0 : (int)(Math.Ceiling(Math.Log10(numNonFlags) / Math.Log10(2)));
int regularFieldIndex = 1;
#if x86
resultEnum.ValueType = EnumerationBaseType.UInt32;
#elif x64
resultEnum.ValueType = EnumerationBaseType.UInt64;
#endif
resultEnum.Fields.Add("None", (SlotType)0);
foreach (var element in targetStructure)
{
switch (element.Value.ResultType)
{
case ResultedDataType.EnumerationItem:
resultEnum.Fields.Add(element.Value.BucketName, (SlotType)regularFieldIndex++);
break;
case ResultedDataType.FlagEnumerationItem:
var resultField = resultEnum.Fields.Add(element.Value.BucketName, (SlotType)Math.Pow(2, flagFieldIndex++));
break;
default:
throw new InvalidOperationException("Enums are supposed to yield an " +
"enumeration, result element is an of invalid type.");
}
if (isFlagSet)
{
aggregateSet.Fields.Add(element.Value.BucketName);
}
}
targetStructure.ResultEnumSet = new IIntermediateEnumType[1] {
resultEnum
};
targetStructure.AggregateSetEnum = aggregateSet;
return(new SelectiveTuple <Tuple <IIntermediateClassType, IIntermediateInterfaceType>, IIntermediateEnumType, Tuple <IIntermediateEnumType, IIntermediateEnumType[]> >(resultEnum));
}
case ResultedDataType.ComplexType:
var resultClass = owner.Classes.Add(targetStructure.ResultedTypeName);
var resultInterface = owner.Interfaces.Add("I{0}", targetStructure.ResultedTypeName);
resultInterface.AccessLevel = AccessLevelModifiers.Public;
resultClass.AccessLevel = AccessLevelModifiers.Internal;
resultClass.ImplementedInterfaces.ImplementInterfaceQuick(resultInterface);
targetStructure.ResultClass = resultClass;
targetStructure.ResultInterface = resultInterface;
foreach (var element in targetStructure.Values)
{
IType simpleType;
switch (element.ResultType)
{
case ResultedDataType.Enumeration:
case ResultedDataType.ComplexType:
IProductionRuleCaptureStructure cts = element as IProductionRuleCaptureStructure;
if (cts == null)
{
throw new InvalidOperationException("Complex types are supposed to be IProductionRuleCaptureStructure instances.");
}
cts.ResultedTypeName = string.Format("{0}{1}", targetStructure.ResultedTypeName, cts.Name);
var currentResult = CreateProgramStructure(cts, owner, structureRoot);
currentResult.Visit(
dualClassInterface =>
{
var interfaceProp = resultInterface.Properties.Add(new TypedName(cts.BucketName, dualClassInterface.Item2), true, false);
var classProp = resultClass.Properties.Add(new TypedName(cts.BucketName, dualClassInterface.Item2), true, false);
classProp.AccessLevel = AccessLevelModifiers.Public;
var classField = resultClass.Fields.Add(new TypedName("_{0}", dualClassInterface.Item2, LowerFirstCharacter(cts.BucketName)));
classField.AccessLevel = AccessLevelModifiers.Private;
classProp.GetMethod.Return(classField.GetReference());
cts.AssociatedField = classField;
},
enumeration =>
{
var interfaceProp = resultInterface.Properties.Add(new TypedName(cts.BucketName, enumeration), true, false);
var classProp = resultClass.Properties.Add(new TypedName(cts.BucketName, enumeration), true, false);
classProp.AccessLevel = AccessLevelModifiers.Public;
var classField = resultClass.Fields.Add(new TypedName("_{0}", enumeration, LowerFirstCharacter(cts.BucketName)));
classField.AccessLevel = AccessLevelModifiers.Private;
classProp.GetMethod.Return(classField.GetReference());
cts.AssociatedField = classField;
},
aggregateWithValidSet =>
{
var enumeration = aggregateWithValidSet.Item1;
var interfaceProp = resultInterface.Properties.Add(new TypedName(cts.BucketName, enumeration), true, false);
var classProp = resultClass.Properties.Add(new TypedName(cts.BucketName, enumeration), true, false);
classProp.AccessLevel = AccessLevelModifiers.Public;
var classField = resultClass.Fields.Add(new TypedName("_{0}", enumeration, LowerFirstCharacter(cts.BucketName)));
classField.AccessLevel = AccessLevelModifiers.Private;
classProp.GetMethod.Return(classField.GetReference());
cts.AssociatedField = classField;
},
() => { throw new InvalidOperationException("Complex types are supposed to yield a complex type, result type unknown"); });
break;
case ResultedDataType.EnumerationItem:
case ResultedDataType.Flag:
simpleType = owner.IdentityManager.ObtainTypeReference(RuntimeCoreType.Boolean);
goto simpleType;
case ResultedDataType.Counter:
simpleType = owner.IdentityManager.ObtainTypeReference(RuntimeCoreType.Int32);
goto simpleType;
case ResultedDataType.Character:
simpleType = owner.IdentityManager.ObtainTypeReference(RuntimeCoreType.Char);
goto simpleType;
case ResultedDataType.String:
simpleType = owner.IdentityManager.ObtainTypeReference(RuntimeCoreType.String);
goto simpleType;
default:
break;
}
continue;
simpleType:
{
var interfaceProp = resultInterface.Properties.Add(new TypedName(element.BucketName, simpleType), true, false);
var classProp = resultClass.Properties.Add(new TypedName(element.BucketName, simpleType), true, false);
classProp.AccessLevel = AccessLevelModifiers.Public;
var classField = resultClass.Fields.Add(new TypedName("_{0}", simpleType, LowerFirstCharacter(element.BucketName)));
classField.AccessLevel = AccessLevelModifiers.Private;
classProp.GetMethod.Return(classField.GetReference());
element.AssociatedField = classField;
}
}
BuildStructureConstructors(targetStructure, structureRoot, owner.IdentityManager);
return(new SelectiveTuple <Tuple <IIntermediateClassType, IIntermediateInterfaceType>, IIntermediateEnumType, Tuple <IIntermediateEnumType, IIntermediateEnumType[]> >(Tuple.Create(resultClass, resultInterface)));
case ResultedDataType.PassThrough:
return(null);
default:
throw new InvalidOperationException();
}
}
internal static IProductionRuleCaptureStructure BuildStructureFor(OilexerGrammarProductionRuleEntry entry, IOilexerGrammarFile source)
{
return(BuildStructureFor(entry, entry, source));
}
public ProductionRuleCaptureStructure(OilexerGrammarProductionRuleEntry owner)
{
this.Sources = new ControlledCollection <IProductionRuleSource>();
this.owner = owner;
}
