public void Build(ParserCompiler compiler, ParserBuilder parserBuilder, IIntermediateCliManager identityManager)
{
/* *
* After much of the static analysis has been completed on the grammar, it's now time to generate the parser's full state transition detail.
* */
BuildGetValidSyntaxCore(compiler, parserBuilder, identityManager);
}
public void Build(ParserCompiler compiler, IIntermediateAssembly assembly)
{
this._compiler = compiler;
this._assembly = assembly;
this._identityManager = ((IIntermediateCliManager)(this._assembly.IdentityManager));
this.BuildFixedTokenClass();
}
public void Build(ParserCompiler compiler, IIntermediateAssembly assembly)
{
this._compiler = compiler;
this._assembly = assembly;
this._identityManager = ((IIntermediateCliManager)(assembly.IdentityManager));
CreateICharStreamSegment(assembly);
CreateCharStreamSegment(assembly);
}
public void Build2(ParserCompiler compiler, ParserBuilder parserBuilder, IIntermediateCliManager identityManager)
{
BuildCullAmbiguitiesCore(compiler, parserBuilder, identityManager);
BuildGetValidSyntax(compiler, parserBuilder, identityManager);
BuildDebuggerDisplayForSymbols(compiler, parserBuilder, identityManager);
BuildVisitorModel(compiler, identityManager);
BuildCullAmbiguities(compiler, parserBuilder, identityManager);
}
internal void BuildNFA(ParserCompiler compiler)//Dictionary<SyntacticalDFAState, PredictionTreeLeaf> allLeaves, ControlledDictionary<IOilexerGrammarProductionRuleEntry, SyntacticalDFARootState> ruleDFAStates, Dictionary<IOilexerGrammarProductionRuleEntry, GrammarVocabulary> ruleGrammarLookup, GrammarSymbolSet grammarSymbolSet, ICompilerErrorCollection compilerErrorCollection)
{
this.nfaState = new SyntacticalNFAState(compiler.RuleDFAStates, compiler._GrammarSymbols);
this.nfaState.SetInitial(this);
var targetState = this.InitialPaths.GetNFAState(compiler);
this.InitialPaths.BuildNFA(compiler);//allLeaves, ruleGrammarLookup, compilerErrorCollection, ruleDFAStates, (GrammarSymbolSet)grammarSymbolSet);
nfaState.MoveTo(this.InitialPaths.Discriminator, targetState);
}
public static GrammarVocabulary ObtainCompleteSet(ParserCompiler compiler)
{
if (!completeSets.ContainsKey(compiler))
{
var newItem = new GrammarVocabulary(compiler.GrammarSymbols);
newItem.IsNegativeSet = true;
completeSets.Add(compiler, newItem);
}
return(completeSets[compiler]);
}
private void BuildVisitorModel(ParserCompiler compiler, IIntermediateCliManager identityManager)
{
var returnType = identityManager.ObtainTypeReference(RuntimeCoreType.VoidType);
var visitorInterface = compiler.RuleSymbolBuilder.ILanguageRuleSymbol.Assembly.DefaultNamespace.Parts.Add().Interfaces.Add("I{0}Visitor", compiler.Source.Options.AssemblyName);
var visitorResultInterface = compiler.RuleSymbolBuilder.ILanguageRuleSymbol.Assembly.DefaultNamespace.Parts.Add().Interfaces.Add("I{0}ReturnVisitor", compiler.Source.Options.AssemblyName);
var tParamResult = visitorResultInterface.TypeParameters.Add("TResult");
BuildVisitor(compiler, returnType, visitorInterface, identityManager);
BuildVisitor(compiler, tParamResult, visitorResultInterface, identityManager);
}
public void Build(ParserCompiler compiler, IIntermediateAssembly targetAssembly)
{
this._targetAssembly = targetAssembly;
this._compiler = compiler;
this._symbolStore = targetAssembly.DefaultNamespace.Parts.Add().Classes.Add("{0}SymbolStore", this._compiler.Source.Options.AssemblyName);
this._singletons = _symbolStore.Parts.Add().Classes.Add("Singletons");
this._identityEnum = targetAssembly.DefaultNamespace.Parts.Add().Enums.Add("{0}Symbols", this._compiler.Source.Options.AssemblyName);
_symbolStore.AccessLevel = AccessLevelModifiers.Internal;
_symbolStore.SpecialModifier = SpecialClassModifier.Static;
_singletons.AccessLevel = AccessLevelModifiers.Internal;
_symbolStore.SummaryText = string.Format("Defines the used symbols for the {0} language, effectively each unique set of combinations is outlined within this symbol store.", compiler.Source.Options.GrammarName);
}
private static void BuildVisitor(ParserCompiler compiler, IType returnType, IIntermediateInterfaceType visitorInterface, IIntermediateCliManager identityManager)
{
var voidType = identityManager.ObtainTypeReference(RuntimeCoreType.VoidType);
string rtType = returnType.IsGenericTypeParameter ? "@t:" : "@s:";
var methods = new Dictionary <IOilexerGrammarProductionRuleEntry, IIntermediateInterfaceMethodMember>();
foreach (var rule in compiler.Source.GetRules() /*.Where(r => !r.IsRuleCollapsePoint)*/)
{
string ruleNameParameter = rule.Name.LowerFirstCharacter();
var targetInterface = compiler.RuleDetail[rule].RelativeInterface;
object target = rule;
if (rule.IsRuleCollapsePoint)
{
continue;
}
AddVisitMethodToVisitor(returnType, visitorInterface, voidType, rtType, methods, ruleNameParameter, targetInterface, target);
}
var rootVisit = AddVisitMethodToClass(returnType, voidType, visitorInterface, compiler.RootRuleBuilder.LanguageRuleRoot, true, AddVisitMethodToInterface(returnType, visitorInterface, compiler.RootRuleBuilder.ILanguageRule));
AddVisitMethodToInterface(returnType, visitorInterface, compiler.TokenSymbolBuilder.ILanguageToken);
IIntermediateInterfaceMethodMember tokenSymbolVisitMethod;
AddVisitMethodToClass(returnType, voidType, visitorInterface, compiler.VariableTokenBaseBuilder.LanguageVariableToken, false, AddVisitMethodToVisitor(returnType, visitorInterface, voidType, rtType, methods, "token", compiler.VariableTokenBaseBuilder.ILanguageVariableToken, null));
AddVisitMethodToClass(returnType, voidType, visitorInterface, compiler.FixedTokenBaseBuilder.LanguageFixedToken, false, tokenSymbolVisitMethod = AddVisitMethodToVisitor(returnType, visitorInterface, voidType, rtType, methods, "token", compiler.TokenSymbolBuilder.ILanguageToken, null));
foreach (var rule in compiler.Source.GetRules().Where(r => !r.IsRuleCollapsePoint))
{
BuildMethodOn(returnType, visitorInterface, voidType, methods[rule], compiler.RuleDetail[rule].Class);
}
visitorInterface.AccessLevel = AccessLevelModifiers.Public;
var tokenDerived = compiler.TokenCastAsRule;
if (tokenDerived != null)
{
var orm = compiler.RelationalModelMapping.ImplementationDetails[tokenDerived];
var tokenDerivedVisit = BuildMethodOn(returnType, visitorInterface, voidType, null, orm.Value.Class, true);
var call = rootVisit.GetReference(compiler.RootRuleBuilder.TokenDerived_Token.GetReference()).Invoke(tokenDerivedVisit.Parameters["visitor"].GetReference());
if (voidType != returnType)
{
tokenDerivedVisit.Return(call);
}
else
{
tokenDerivedVisit.Call(call);
}
}
//BuildMethodOn(returnType, visitorInterface, voidType, method, compiler.RelationalModelMapping[compiler.TokenCastAsRule].ImplementationDetails.Value.Class);
}
private void BuildGetValidSyntaxCore(ParserCompiler compiler, ParserBuilder parserBuilder, IIntermediateCliManager identityManager)
{
var targetClassPartial = parserBuilder.ParserClass.Parts.Add();
this._getValidSyntaxMethodImpl = targetClassPartial.Methods.Add(new TypedName("GetValidSyntax", compiler.LexicalSymbolModel.ValidSymbols));
this._getValidSyntaxMethod = parserBuilder.ParserInterface.Methods.Add(new TypedName("GetValidSyntax", compiler.LexicalSymbolModel.ValidSymbols));
this._getValidSyntaxMethodInternalImpl =
targetClassPartial.Methods.Add(
new TypedName("GetValidSyntaxInternal", compiler.LexicalSymbolModel.ValidSymbols),
new TypedNameSeries(
new TypedName("state", RuntimeCoreType.Int32, identityManager),
new TypedName("ruleContext", compiler.RuleSymbolBuilder.ILanguageRuleSymbol),
new TypedName("initialPass", RuntimeCoreType.Boolean, identityManager)));
}
internal void Adapt(ParserCompiler compiler)
{
if (this.dfaState != null)
{
var adaptLookup = new Dictionary <SyntacticalDFAState, PredictionTreeDFAdapter>();
this.Adapter = PredictionTreeDFAdapter.Adapt(this.dfaState, ref adaptLookup, compiler);
this.Adapter.AssociatedContext.StateAdapterLookup = new ControlledDictionary <SyntacticalDFAState, PredictionTreeDFAdapter>(adaptLookup);
foreach (var adapter in adaptLookup.Values)
{
adapter.AssociatedContext.PostConnect(this.EdgeNode, this.Adapter);
}
}
else
{
throw new InvalidOperationException();
}
}
public SyntacticalDFAState ConstructAdvanceDFA(ParserCompiler compiler)//Dictionary<SyntacticalDFAState, PredictionTreeLeaf> fullSeries, Dictionary<IOilexerGrammarProductionRuleEntry, GrammarVocabulary> ruleVocabulary, ICompilerErrorCollection compilationErrors, ControlledDictionary<IOilexerGrammarProductionRuleEntry, SyntacticalDFARootState> lookup, GrammarSymbolSet symbols)
{
SyntacticalNFAState resultNFANode = null;
/* *
* Simple for now, but I suspect it'll be more complicated
* later on to provide sufficient context.
* */
if (this.Veins.DFAOriginState is SyntacticalDFARootState)
{
resultNFANode = new SyntacticalNFARootState(this.Veins.Rule, compiler.RuleDFAStates, compiler._GrammarSymbols);
}
else
{
resultNFANode = new SyntacticalNFAState(compiler.RuleDFAStates, compiler._GrammarSymbols);
}
foreach (var transition in this.LookAhead.Keys)
{
((PredictionTree)this.LookAhead[transition])
.BuildNFA(compiler); //fullSeries, ruleVocabulary, compilationErrors, lookup, symbols);
}
foreach (var transition in this.LookAhead.Keys)
{
((PredictionTree)this.LookAhead[transition]).
HandleReplFixups(compiler);//fullSeries, ruleVocabulary, compilationErrors, lookup, symbols);
}
/* *
* Transition from the Variable look-ahead table
* into the NFA states.
* */
foreach (var transition in this.LookAhead.Keys)
{
var currentSet = (PredictionTree)this.LookAhead[transition];
resultNFANode.MoveTo(transition, currentSet.GetNFAState(compiler));
}
/* *
* Create a Deterministic automation from the results.
* */
resultNFANode.SetInitial(this);
return(this.DeterministicAutomata = resultNFANode.DeterminateAutomata());
}
private void BuildCullAmbiguitiesCore(ParserCompiler compiler, ParserBuilder parserBuilder, IIntermediateCliManager identityManager)
{
bool lexicallyAmbiguousModel = compiler._GrammarSymbols.AmbiguousSymbols.Count() > 0;
if (!lexicallyAmbiguousModel)
{
return;
}
this._cullAmbiguities = this._getValidSyntaxMethodInternalImpl
.Parent
.Methods
.Add(
new TypedName("CullAmbiguitiesFrom", compiler.LexicalSymbolModel.ValidSymbols),
new TypedNameSeries(
new TypedName("unambiguousSource", compiler.LexicalSymbolModel.ValidSymbols)));
var allAmbiguities = compiler.LexicalSymbolModel.GenerateSymbolstoreVariation(new GrammarVocabulary(compiler.GrammarSymbols, compiler._GrammarSymbols.AmbiguousSymbols.ToArray()), "AllAmbiguities", string.Format("Returns a @s:{0}; value that represents all ambiguous identities.", compiler.LexicalSymbolModel.ValidSymbols.Name));
allAmbiguities.Name = "AllAmbiguities";
this._AllAmbiguitiesField = allAmbiguities;
_cullAmbiguities.AccessLevel = AccessLevelModifiers.Public;
}
private void BuildCullAmbiguities(ParserCompiler compiler, ParserBuilder parserBuilder, IIntermediateCliManager identityManager)
{
bool lexicallyAmbiguousModel = compiler._GrammarSymbols.AmbiguousSymbols.Count() > 0;
if (!lexicallyAmbiguousModel)
{
return;
}
var runningAmbiguities = this._cullAmbiguities.Locals.Add(
new TypedName("runningAmbiguities", compiler.LexicalSymbolModel.ValidSymbols), new DefaultValueExpression(compiler.LexicalSymbolModel.ValidSymbols));
var resultAmbiguities = this._cullAmbiguities.Locals.Add(
new TypedName("resultAmbiguities", compiler.LexicalSymbolModel.ValidSymbols), new DefaultValueExpression(compiler.LexicalSymbolModel.ValidSymbols));
var unambiguousSource = this._cullAmbiguities.Parameters["unambiguousSource"];
this._cullAmbiguities.Comment("Remove the ambiguities that are currently present, a larger multiple-symbol ambiguity may trump what was there due to the follow-union.");
this._cullAmbiguities.Assign((IMemberReferenceExpression)unambiguousSource.GetReference(), AssignmentOperation.BitwiseExclusiveOrAssign, unambiguousSource.GetReference().BitwiseAnd(_AllAmbiguitiesField.GetReference()));
bool first = true;
foreach (var ambiguity in compiler._GrammarSymbols.AmbiguousSymbols)
{
var ambiguityDetail = compiler.AmbiguityDetail[ambiguity];
IBlockStatementParent target = this._cullAmbiguities;
if (first)
{
first = false;
}
else
{
target = target.If(runningAmbiguities.GetReference().BitwiseAnd(ambiguityDetail.AmbiguityKeyReference.GetReference()).InequalTo(ambiguityDetail.AmbiguityKeyReference.GetReference()));
}
var assignmentCheck = target.If(unambiguousSource.BitwiseAnd(ambiguityDetail.AmbiguityKeyReference).EqualTo(ambiguityDetail.AmbiguityKeyReference));
assignmentCheck.Assign(runningAmbiguities.GetReference(), AssignmentOperation.BitwiseOrAssign, ambiguityDetail.AmbiguityKeyReference.GetReference());
assignmentCheck.Assign(resultAmbiguities.GetReference(), AssignmentOperation.BitwiseOrAssign, ambiguityDetail.AmbiguityReference.GetReference());
}
_cullAmbiguities.Return(resultAmbiguities.GetReference());
}
internal GrammarVocabularySymbolicBreakdown SymbolicBreakdown(ParserCompiler compiler)
{
var symbols = this.GetSymbols();
return(new GrammarVocabularySymbolicBreakdown()
{
Tokens = new GrammarVocabularyTokenBreakdown(
symbols.Where(s => s is IGrammarTokenSymbol)
.Cast <IGrammarTokenSymbol>()
.Select(token => compiler.TokenSymbolDetail[token])
.ToDictionary(t => t.Symbol, t => t)),
Rules = new GrammarVocabularyRuleBreakdown(
symbols.Where(s => s is IGrammarRuleSymbol)
.Cast <IGrammarRuleSymbol>()
.Select(rule => compiler.RuleDetail[rule.Source])
.ToDictionary(k => k.Symbol, v => v)),
Ambiguities =
new GrammarVocabularyAmbiguityBreakdown(
symbols.Where(s => s is IGrammarAmbiguousSymbol)
.Cast <IGrammarAmbiguousSymbol>()
.Select(ambiguity => compiler.AmbiguityDetail[ambiguity])
.ToDictionary(k => k.Symbol, v => v)),
});
}
public ErrorContextBuilder(ParserCompiler compiler, IIntermediateCliManager identityManager, IIntermediateAssembly assembly)
{
this._identityManager = identityManager;
this._assembly = assembly;
this._compiler = compiler;
}
private void BuildGetValidSyntax(ParserCompiler compiler, ParserBuilder parserBuilder, IIntermediateCliManager identityManager)
{
bool lexicallyAmbiguousModel = compiler._GrammarSymbols.AmbiguousSymbols.Count() > 0;
var advanceAdapters =
compiler
.AdvanceMachines.Values
.Select(k => k.All)
.DefaultIfEmpty().Aggregate(
(a, b) =>
a.Concat(b));
if (advanceAdapters == null)
{
advanceAdapters = new PredictionTreeDFAdapter[0];
}
var adapters = compiler.FollowAdapters.Select(k => k.Value.AssociatedState).Concat(compiler.AllRuleAdapters.Select(k => k.Value.AssociatedState)).Concat(advanceAdapters.DefaultIfEmpty().Where(k => k != null).Select(k => k.AssociatedState)).Distinct().OrderBy(k => k.StateValue).ToArray();
var distinctStateValues = adapters.Select(k => k.StateValue).Distinct().ToArray();
var stateSymbolStoreEntry =
(from state in adapters
/* Since the other adapters are state-machines derived from the projection of a given state of a rule, normal adapters (derived from non-expanded lookahead) must be aggregated */
join normalAdapter in compiler.AllRuleAdapters on state equals normalAdapter.Value.AssociatedState into normalVariantSet
from normalAdapter in normalVariantSet.DefaultIfEmpty()
let fc = (normalAdapter.Value == null || normalAdapter.Value.OutgoingTransitions.Count == 0 || normalAdapter.Value.AssociatedContext.Leaf.LookAhead.Count == 0) ? state.OutTransitions.FullCheck : normalAdapter.Value.AssociatedContext.Leaf.LookAhead.Keys.Aggregate(GrammarVocabulary.UnionAggregateDelegate)
group new { State = state, Grammar = fc, GrammarStore = compiler.LexicalSymbolModel.GenerateSymbolstoreVariation(fc) } by new { Grammar = fc, IsEdge = state.IsEdge }).ToDictionary(k => k.Key, v => v.ToArray());
var stateParam = _getValidSyntaxMethodInternalImpl.Parameters["state"];
var ruleContext = _getValidSyntaxMethodInternalImpl.Parameters["ruleContext"];
var initialPass = _getValidSyntaxMethodInternalImpl.Parameters["initialPass"];
if (!lexicallyAmbiguousModel)
{
_getValidSyntaxMethodInternalImpl.Parameters.Remove(initialPass);
initialPass = null;
}
_getValidSyntaxMethodImpl.AccessLevel = AccessLevelModifiers.Public;
var getSyntaxMethodImplInvocation = _getValidSyntaxMethodInternalImpl.GetReference().Invoke(parserBuilder._StateImpl.GetReference(), parserBuilder._CurrentContextImpl.GetReference());
_getValidSyntaxMethodImpl.Return(getSyntaxMethodImplInvocation);
if (lexicallyAmbiguousModel)
{
getSyntaxMethodImplInvocation.Arguments.Add(IntermediateGateway.TrueValue);
}
ITypedLocalMember pushAmbiguityContext = null;
if (lexicallyAmbiguousModel)
{
pushAmbiguityContext = _getValidSyntaxMethodInternalImpl.Locals.Add(
new TypedName("pushAmbiguityContext", RuntimeCoreType.Boolean, identityManager),
IntermediateGateway.FalseValue);
}
ITypedLocalMember validResult = null;
if (lexicallyAmbiguousModel)
{
validResult = _getValidSyntaxMethodInternalImpl.Locals.Add(
new TypedName("result", compiler.LexicalSymbolModel.ValidSymbols),
this._getValidSyntaxMethodInternalImpl.ReturnType.GetNewExpression());
}
var switchStatement = this._getValidSyntaxMethodInternalImpl.Switch(stateParam.GetReference());
foreach (var uniqueGrammarSet in stateSymbolStoreEntry.Keys)
{
var currentSet = stateSymbolStoreEntry[uniqueGrammarSet];
IExpression[] stateIndices = new IExpression[currentSet.Length];
currentSet = currentSet.OrderBy(k => k.State.StateValue).ToArray();
for (int stateIndex = 0; stateIndex < currentSet.Length; stateIndex++)
{
stateIndices[stateIndex] = currentSet[stateIndex].State.StateValue.ToPrimitive();
}
var currentCase = switchStatement.Case(stateIndices);
currentCase.Comment(currentSet[0].Grammar.ToString());
if (uniqueGrammarSet.IsEdge)
{
//Inject logic to look up in the stack.
if (lexicallyAmbiguousModel)
{
var nullCheck = currentCase.If(ruleContext.InequalTo(IntermediateGateway.NullValue));
nullCheck.Assign(validResult.GetReference(), currentSet[0].GrammarStore.GetReference().BitwiseOr(_getValidSyntaxMethodInternalImpl.GetReference().Invoke(compiler.RuleSymbolBuilder.FollowState.GetReference(ruleContext.GetReference()), compiler.RuleSymbolBuilder.Parent.GetReference(ruleContext.GetReference()), IntermediateGateway.FalseValue)));
nullCheck.If(initialPass.GetReference())
.Assign(pushAmbiguityContext.GetReference(), IntermediateGateway.TrueValue);
nullCheck.CreateNext();
nullCheck.Next.Assign(validResult.GetReference(), currentSet[0].GrammarStore.GetReference());
}
else
{
var nullCheck = currentCase.If(ruleContext.InequalTo(IntermediateGateway.NullValue));
nullCheck.Return(currentSet[0].GrammarStore.GetReference().BitwiseOr(_getValidSyntaxMethodInternalImpl.GetReference().Invoke(compiler.RuleSymbolBuilder.FollowState.GetReference(ruleContext.GetReference()), compiler.RuleSymbolBuilder.Parent.GetReference(ruleContext.GetReference()))));
nullCheck.CreateNext();
nullCheck.Next.Return(currentSet[0].GrammarStore.GetReference());
}
}
else if (lexicallyAmbiguousModel)
{
currentCase.Assign(validResult.GetReference(), currentSet[0].GrammarStore.GetReference());
}
else
{
currentCase.Return(currentSet[0].GrammarStore.GetReference());
}
}
if (lexicallyAmbiguousModel)
{
this._getValidSyntaxMethodInternalImpl.If(pushAmbiguityContext.GetReference())
.Assign(validResult.GetReference(), AssignmentOperation.BitwiseOrAssign,
_cullAmbiguities.GetReference().Invoke(validResult.GetReference()));
}
if (lexicallyAmbiguousModel)
{
this._getValidSyntaxMethodInternalImpl.Return(validResult.GetReference());
}
else
{
this._getValidSyntaxMethodInternalImpl.Return(this._getValidSyntaxMethodInternalImpl.ReturnType.GetNewExpression());
}
this._getValidSyntaxMethodInternalImpl.AccessLevel = AccessLevelModifiers.Private;
}
internal static SelectiveTuple <Tuple <IIntermediateClassType, IIntermediateInterfaceType>, IIntermediateEnumType, Tuple <IIntermediateEnumType, IIntermediateEnumType[]> > CreateProgramStructure(ICaptureTokenStructure targetStructure, IIntermediateNamespaceDeclaration owner, InlinedTokenEntry structureRoot, ParserCompiler compiler)
{
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.Parts.Add().Enums.Add("{0}Cases", targetStructure.ResultedTypeName);
resultEnum = owner.Parts.Add().Enums.Add("Valid{0}", useBucketName ? targetStructure.BucketName : structureRoot.Name);
}
else
{
resultEnum = owner.Parts.Add().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.Parts.Add().Classes.Add(targetStructure.ResultedTypeName);
var resultInterface = owner.Parts.Add().Interfaces.Add("I{0}", targetStructure.ResultedTypeName);
bool tailLanguage = compiler.Source.Options.GrammarName.ToLower().EndsWith("language");
resultInterface.SummaryText = string.Format("Represents the {0} structure from the {1}{2}.", targetStructure.ResultedTypeName, compiler.Source.Options.GrammarName, tailLanguage ? string.Empty : " language");
resultClass.SummaryText = string.Format("Provides a base implementation of a @s:{2}; from the {1}{3}.", targetStructure.Name, compiler.Source.Options.GrammarName, resultInterface.Name, tailLanguage ? string.Empty : " language");
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:
ICaptureTokenStructure cts = element as ICaptureTokenStructure;
if (cts == null)
{
throw new InvalidOperationException("Complex types are supposed to be ICaptureTokenStructure instances.");
}
cts.ResultedTypeName = string.Format("{0}{1}", targetStructure.ResultedTypeName, cts.Name);
var currentResult = CreateProgramStructure(cts, owner, structureRoot, compiler);
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();
}
}
private void BuildDebuggerDisplayForSymbols(ParserCompiler compiler, ParserBuilder parserBuilder, IIntermediateCliManager identityManager)
{
var extensionsClass = compiler.RuleSymbolBuilder.ILanguageRuleSymbol.Assembly.DefaultNamespace.Parts.Add().Classes.Add("{0}Extensions", compiler.Source.Options.AssemblyName);
extensionsClass.AccessLevel = AccessLevelModifiers.Internal;
extensionsClass.SpecialModifier = SpecialClassModifier.Static;
this.ExtensionsClass = extensionsClass;
var symbolDebuggerDisplay = extensionsClass.Methods.Add(
new TypedName("SymbolDebuggerDisplay", RuntimeCoreType.String, identityManager),
new TypedNameSeries(
new TypedName("symbol", compiler.SymbolStoreBuilder.Identities)));
var symbol = symbolDebuggerDisplay.Parameters["symbol"];
var constantEntries = (from s in compiler._GrammarSymbols.SymbolsOfType <IGrammarConstantEntrySymbol>()
where !(s.Source is IOilexerGrammarTokenEofEntry)
let literalItem = s.Source.Branches[0][0] as ILiteralTokenItem
where literalItem != null
orderby literalItem.Line, literalItem.Column, literalItem.Value.ToString()
select new { LiteralItem = literalItem, Symbol = s }).ToArray();
var constantItems =
(from s in compiler._GrammarSymbols.SymbolsOfType <IGrammarConstantItemSymbol>()
let literalItem = s.SourceItem
orderby literalItem.Line, literalItem.Column, literalItem.Value.ToString()
select new { LiteralItem = literalItem, Symbol = s }).ToArray();
var ambiguousItems =
(from s in compiler._GrammarSymbols.SymbolsOfType <IGrammarAmbiguousSymbol>()
let literalConstantEntry = (IGrammarConstantEntrySymbol)s.FirstOrDefault(aSym => aSym is IGrammarConstantEntrySymbol && constantEntries.Any(ce => ce.Symbol == aSym))
let literalConstantItem = (IGrammarConstantItemSymbol)s.FirstOrDefault(aSym => aSym is IGrammarConstantItemSymbol && constantItems.Any(ci => ci.Symbol == aSym))
where literalConstantEntry != null || literalConstantItem != null
let literalItem = literalConstantEntry != null ? literalConstantEntry.Source.Branches[0][0] as ILiteralTokenItem : literalConstantItem.SourceItem
orderby literalItem.Line, literalItem.Column, literalItem.Value.ToString()
select new { LiteralItem = literalItem, Symbol = s }).ToArray();
var mainSwitch = symbolDebuggerDisplay.Switch(symbol.GetReference());
//compiler.TokenSymbolDetail
foreach (var constantEntry in constantEntries)
{
var symbolDet = compiler.TokenSymbolDetail[constantEntry.Symbol];
var currentCase = mainSwitch.Case(symbolDet.Identity.GetReference());
var fN = symbolDet.Symbol.Source.FileName;
if (fN.ToLower().StartsWith(compiler.Source.RelativeRoot))
{
currentCase.Comment(string.Format("In .{0} on line {1}, column {2}", fN.Substring(compiler.Source.RelativeRoot.Length), constantEntry.LiteralItem.Line, constantEntry.LiteralItem.Column));
}
else
{
currentCase.Comment(string.Format("In {0} on line {1}, column {2}", fN, constantEntry.LiteralItem.Line, constantEntry.LiteralItem.Column));
}
currentCase.Return(constantEntry.LiteralItem.Value.ToString().ToPrimitive());
}
foreach (var constantItem in constantItems)
{
var symbolDet = compiler.TokenSymbolDetail[constantItem.Symbol];
var currentCase = mainSwitch.Case(symbolDet.Identity.GetReference());
var fN = symbolDet.Symbol.Source.FileName;
if (fN.ToLower().StartsWith(compiler.Source.RelativeRoot))
{
currentCase.Comment(string.Format("In .{0} on line {1}, column {2}", fN.Substring(compiler.Source.RelativeRoot.Length), constantItem.LiteralItem.Line, constantItem.LiteralItem.Column));
}
else
{
currentCase.Comment(string.Format("In {0} on line {1}, column {2}", fN, constantItem.LiteralItem.Line, constantItem.LiteralItem.Column));
}
currentCase.Return(constantItem.LiteralItem.Value.ToString().ToPrimitive());
}
foreach (var ambiguousItem in ambiguousItems)
{
var identityField = compiler.LexicalSymbolModel.GetIdentitySymbolField(ambiguousItem.Symbol);
var currentCase = mainSwitch.Case(identityField.GetReference());
StringBuilder ambiguityBuilder = new StringBuilder();
ambiguityBuilder.Append("Ambiguity {");
bool first = true;
foreach (var ambigSymbol in ambiguousItem.Symbol)
{
if (first)
{
first = false;
}
else
{
ambiguityBuilder.Append(", ");
}
ambiguityBuilder.Append(ambigSymbol.ElementName);
}
ambiguityBuilder.Append("} :");
ambiguityBuilder.Append(ambiguousItem.LiteralItem.Value.ToString().ToPrimitive());
currentCase.Return(ambiguityBuilder.ToString().ToPrimitive());
}
mainSwitch.Case(true).Return(symbol.GetReference().GetMethod("ToString").Invoke());
this.SymbolDebuggerDisplay = symbolDebuggerDisplay;
symbolDebuggerDisplay.AccessLevel = AccessLevelModifiers.Public;
compiler.SymbolStoreBuilder.Identities.Metadata.Add(new MetadatumDefinitionParameterValueCollection(identityManager.ObtainTypeReference(typeof(DebuggerDisplayAttribute)))
{
string.Format("{{{0}.{1}.{2}(this),nq}}", extensionsClass.NamespaceName, extensionsClass.Name, symbolDebuggerDisplay.Name)
});
compiler.FixedTokenBaseBuilder.LanguageFixedToken.Metadata.Add(new MetadatumDefinitionParameterValueCollection(identityManager.ObtainTypeReference(typeof(DebuggerDisplayAttribute)))
{
string.Format("{{{0}.{1}.{2}(Identity),nq}}", extensionsClass.NamespaceName, extensionsClass.Name, symbolDebuggerDisplay.Name)
});
compiler.VariableTokenBaseBuilder.LanguageVariableToken.Metadata.Add(new MetadatumDefinitionParameterValueCollection(identityManager.ObtainTypeReference(typeof(DebuggerDisplayAttribute)))
{
"{Value,nq}"
});
compiler.RootRuleBuilder.LanguageRuleRoot.Metadata.Add(new MetadatumDefinitionParameterValueCollection(identityManager.ObtainTypeReference(typeof(DebuggerDisplayAttribute)))
{
"{Context.Identity,nq}: {Context}"
});
}
internal void Connect(PredictionTreeDFAdapter adapter, ParserCompiler compiler)
{
this.Adapter = adapter;
this.AssociatedCompiler = compiler;
}
internal void ConnectAdapter(ProductionRuleNormalAdapter adapter, ParserCompiler associatedBuilder)
{
this.Adapter = adapter;
this.AssociatedBuilder = associatedBuilder;
}
