public ClassSyntax BuildMethod(ClassSyntax context, string methodName, LanguageData data)
{
var args = context.Method()
.Static
.Returning(context.Types.Object)
.Named(methodName)
.BeginArgs();
Def <Args> tokenId = args.Args.Generate("token");
Def <Args> oldValue = args.Args.Generate("oldValue");
Def <Args> newValue = args.Args.Generate("newValue");
Def <Args> ctx = args.Args.Generate("rootContext");
Def <Args> stackLookback = args.Args.Generate("startLookback");
var emit = args
.Argument(context.Types.Int32, tokenId)
.Argument(context.Types.Object, oldValue)
.Argument(context.Types.Object, newValue)
.Argument(context.Types.Object, ctx)
.Argument(context.Types.Import(typeof(IStackLookback <Msg>)), stackLookback)
.EndArgs()
.BeginBody();
BuildBody(
emit,
data,
tokenId.GetRef(),
oldValue.GetRef(),
newValue.GetRef(),
ctx.GetRef(),
stackLookback.GetRef());
return(emit.EndBody());
}
private ClassSyntax BuildMethod_CreateStateToSymbol(ClassSyntax context)
{
var emit = context
.Method()
.Private.Static
.Returning(context.Types.Import(typeof(int[])))
.Named(CreateStateToSymbolMethodName)
.BeginArgs()
.EndArgs()
.BeginBody();
var resultLoc = emit.Locals.Generate().GetRef();
var stateToSymbol = data.StateToToken;
emit = emit
.Local(resultLoc.Def, context.Types.Import(typeof(int[])))
.Ldc_I4(stateToSymbol.Length)
.Newarr(context.Types.Import(typeof(int)))
.Stloc(resultLoc);
for (int i = 0; i != stateToSymbol.Length; ++i)
{
emit = emit
.Ldloc(resultLoc)
.Ldc_I4(i)
.Ldc_I4(stateToSymbol[i])
.Stelem_I4();
}
return(emit
.Ldloc(resultLoc)
.Ret()
.EndBody());
}
private ClassSyntax BuildMethod_GetParserAction(ClassSyntax context)
{
var generator = new ReadOnlyTableGenerator(
data.ParserActionTable,
il => il.Ldarg(0),
il => il.Ldarg(1));
var args = context.Method()
.Private.Static
.Returning(context.Types.Int32)
.Named(GetParserActionMethodName)
.BeginArgs();
return(args
.Argument(context.Types.Int32, args.Args.Generate())
.Argument(context.Types.Int32, args.Args.Generate())
.EndArgs()
.NoOptimization
.BeginBody()
.Do(generator.Build)
.Ret()
.EndBody());
}
private ClassSyntax BuildMethod_TermFactory(ClassSyntax context)
{
var args = context
.Method()
.Static
.Returning(context.Types.Int32)
.Named(TermFactoryMethodName)
.BeginArgs();
var cursorArg = args.Args.Generate("cursor");
var tokenArg = args.Args.Generate("token");
var emit = args
.Argument(context.Types.Import(typeof(ScanCursor)), cursorArg) // ruleId
.Out.Argument(context.Types.Import(typeof(object).MakeByRefType()), tokenArg)
.EndArgs()
.BeginBody();
var generator = new TermFactoryGenerator(data, declaringTypeRef);
generator.Build(
emit,
il => il.Ldarg(cursorArg.GetRef()),
il => il.Ldarg(tokenArg.GetRef()));
return(emit.EndBody());
}
private ClassSyntax BuildMethod_CreateTokenIdentities(ClassSyntax context)
{
var generator = new TokenIdentitiesSerializer(data.Grammar);
return(context
.Method().Private.Static
.Returning(context.Types.Import(LanguageBase.Fields.tokenKeyToId.FieldType))
.Named(CreateTokenKeyToIdMethodName)
.BeginArgs()
.EndArgs()
.BeginBody()
.Do(generator.Build)
.Ret()
.EndBody());
}
private ClassSyntax BuildMethod_CreateGrammar(ClassSyntax context)
{
var grammarSerializer = new GrammarSerializer(data.Grammar);
return(context
.Method()
.Private.Static
.Returning(context.Types.Import(typeof(Grammar)))
.Named(CreateGrammarMethodName)
.BeginArgs()
.EndArgs()
.BeginBody()
.Do(grammarSerializer.Build)
.Ret()
.EndBody());
}
private ClassSyntax BuildMethod_CreateDefaultContext(ClassSyntax context)
{
return(context
.Method()
.Private.Static
.Returning(context.Types.Object)
.Named(CreateDefaultContextMethodName)
.BeginArgs()
.EndArgs()
.BeginBody()
// Plan implementation of abstraction as needed
.Do(il => implementationGenerator
.EmitFactoryCode(il, languageName.DefinitionType))
.Ret()
.EndBody());
}
private ClassSyntax BuildMethod_Scan1(ClassSyntax context)
{
logging.Write(
new LogEntry
{
Severity = Severity.Verbose,
Message = string.Format("Started compiling Scan1 modes for {0} language", languageName.LanguageName)
});
foreach (var condition in data.Grammar.Conditions)
{
ITdfaData dfa = condition.Joint.The <ITdfaData>();
var dfaSerialization = new DfaSerialization(dfa);
var generator = new ScannerGenerator(dfaSerialization);
var methodName = ConditionMethods.GetMethodName(condition.Index);
var args = context
.Method()
.Static
.Returning(context.Types.Int32)
.Named(methodName)
.BeginArgs();
var emit = args
.Argument(
context.Types.Import(typeof(ScanCursor)),
args.Args.Generate("cursor")) // input
.EndArgs()
.NoInlining
.NoOptimization
.BeginBody();
generator.Build(emit);
context = emit.EndBody();
}
logging.Write(
new LogEntry
{
Severity = Severity.Verbose,
Message = string.Format("Done compiling Scan1 modes for {0} language", languageName.LanguageName)
});
return(context);
}
public ClassSyntax BuildMethod(ClassSyntax context, string methodName, LanguageData data)
{
var args = context.Method()
.Static
.Returning(context.Types.Object)
.Named(methodName)
.BeginArgs();
Def <Args> ruleId = args.Args.Generate("ruleId");
Def <Args> ruleArgs = args.Args.Generate("ruleArgs");
Def <Args> argsStart = args.Args.Generate("argsStart");
Def <Args> ctx = args.Args.Generate("rootContext");
Def <Args> stackLookback = args.Args.Generate("startLookback");
var emit = args
.Argument(context.Types.Int32, ruleId)
.Argument(context.Types.Import(typeof(Msg[])), ruleArgs)
.Argument(context.Types.Int32, argsStart)
.Argument(context.Types.Object, ctx)
.Argument(context.Types.Import(typeof(IStackLookback <Msg>)), stackLookback)
.EndArgs()
.BeginBody();
ruleId.Name = "ruleId";
ruleArgs.Name = "args";
argsStart.Name = "argsStart";
ctx.Name = "ctx";
stackLookback.Name = "stackLookback";
BuildBody(
emit,
data,
ruleId.GetRef(),
ruleArgs.GetRef(),
argsStart.GetRef(),
ctx.GetRef(),
stackLookback.GetRef());
return(emit.EndBody());
}
private ClassSyntax BuildMethod_CreateTokenComplexityTable(ClassSyntax context)
{
var emit = context
.Method()
.Private.Static
.Returning(context.Types.Import(typeof(int[])))
.Named(CreateTokenComplexityTableMethodName)
.BeginArgs()
.EndArgs()
.BeginBody();
var resultLoc = emit.Locals.Generate().GetRef();
var itemLoc = emit.Locals.Generate().GetRef();
var table = data.TokenComplexity;
emit = emit
.Local(resultLoc.Def, emit.Types.Import(typeof(int[])))
.Ldc_I4(table.Length)
.Newarr(emit.Types.Import(typeof(int)))
.Stloc(resultLoc)
;
for (int i = 0; i != table.Length; ++i)
{
emit
.Ldloc(resultLoc)
.Ldc_I4(i)
.Ldc_I4(table[i])
.Stelem_I4();
}
return(emit
.Ldloc(resultLoc)
.Ret()
.EndBody());
}
private ClassSyntax BuildMethod_CreateParserActionConflicts(ClassSyntax context)
{
var emit = context
.Method()
.Private.Static
.Returning(context.Types.Import(typeof(int[])))
.Named(CreateParserActionConflictsMethodName)
.BeginArgs()
.EndArgs()
.BeginBody();
var resultLoc = emit.Locals.Generate().GetRef();
var itemLoc = emit.Locals.Generate().GetRef();
var conflicts = data.ParserConflictActionTable;
emit = emit
.Local(resultLoc.Def, emit.Types.Import(typeof(int[])))
.Ldc_I4(conflicts.Length)
.Newarr(emit.Types.Import(typeof(int)))
.Stloc(resultLoc)
;
for (int i = 0; i != conflicts.Length; ++i)
{
emit
.Ldloc(resultLoc)
.Ldc_I4(i)
.Ldc_I4(conflicts[i])
.Stelem_I4();
}
return(emit
.Ldloc(resultLoc)
.Ret()
.EndBody());
}
public ClassSyntax BuildMethod(ClassSyntax context, string methodName, LanguageData data)
{
var args = context.Method()
.Static
.Returning(context.Types.Object)
.Named(methodName)
.BeginArgs();
Def<Args> ruleId = args.Args.Generate("ruleId");
Def<Args> ruleArgs = args.Args.Generate("ruleArgs");
Def<Args> argsStart = args.Args.Generate("argsStart");
Def<Args> ctx = args.Args.Generate("rootContext");
Def<Args> stackLookback = args.Args.Generate("startLookback");
var emit = args
.Argument(context.Types.Int32, ruleId)
.Argument(context.Types.Import(typeof(Msg[])), ruleArgs)
.Argument(context.Types.Int32, argsStart)
.Argument(context.Types.Object, ctx)
.Argument(context.Types.Import(typeof(IStackLookback<Msg>)), stackLookback)
.EndArgs()
.BeginBody();
ruleId.Name = "ruleId";
ruleArgs.Name = "args";
argsStart.Name = "argsStart";
ctx.Name = "ctx";
stackLookback.Name = "stackLookback";
BuildBody(
emit,
data,
ruleId.GetRef(),
ruleArgs.GetRef(),
argsStart.GetRef(),
ctx.GetRef(),
stackLookback.GetRef());
return emit.EndBody();
}
public ClassSyntax BuildMethod(ClassSyntax context, string methodName, LanguageData data)
{
var args = context.Method()
.Static
.Returning(context.Types.Object)
.Named(methodName)
.BeginArgs();
Def<Args> tokenId = args.Args.Generate("token");
Def<Args> oldValue = args.Args.Generate("oldValue");
Def<Args> newValue = args.Args.Generate("newValue");
Def<Args> ctx = args.Args.Generate("rootContext");
Def<Args> stackLookback = args.Args.Generate("startLookback");
var emit = args
.Argument(context.Types.Int32, tokenId)
.Argument(context.Types.Object, oldValue)
.Argument(context.Types.Object, newValue)
.Argument(context.Types.Object, ctx)
.Argument(context.Types.Import(typeof(IStackLookback<Msg>)), stackLookback)
.EndArgs()
.BeginBody();
BuildBody(
emit,
data,
tokenId.GetRef(),
oldValue.GetRef(),
newValue.GetRef(),
ctx.GetRef(),
stackLookback.GetRef());
return emit.EndBody();
}
private ClassSyntax Build_Ctor(ClassSyntax context)
{
var emit = context
.Method()
.Public.Instance
.Returning(context.Types.Void)
.Named(".ctor")
.BeginArgs()
.Do(args =>
{
var type = context.Types.Import(typeof(CilGrammarSource));
var arg = args.Args.Generate();
args.Argument(type, arg);
return(args);
})
.EndArgs()
.BeginBody();
// Call base constructor:
// this:
emit = emit
.Ldarg(0) // this
.Ldarg(1) // LanguageName
.Call(emit.Methods.Import(typeof(LanguageBase).GetConstructor(new[] { typeof(CilGrammarSource) })))
;
emit
.Ldarg(0)
.Ldc_I4(data.IsDeterministic ? 1 : 0)
.Stfld(LanguageBase.Fields.isDeterministic);
return(emit
// Init grammar
.Ldarg(0)
.Call(emit.Methods.Method(
_ => _
.StartSignature
.Returning(emit.Types.Import(typeof(Grammar)))
.DecaringType(declaringTypeRef)
.Named(CreateGrammarMethodName)
.BeginArgs()
.EndArgs()
))
.Stfld(LanguageBase.Fields.grammar)
// Init state->token table
.Ldarg(0)
.Call(emit.Methods.Method(
_ => _
.StartSignature
.Returning(emit.Types.Import(typeof(int[])))
.DecaringType(declaringTypeRef)
.Named(CreateStateToSymbolMethodName)
.BeginArgs()
.EndArgs()
))
.Stfld(LanguageBase.Fields.stateToSymbol)
// Init parser action conflicts table
.Ldarg(0)
.Call(emit.Methods.Method(
_ => _
.StartSignature
.Returning(emit.Types.Import(typeof(int[])))
.DecaringType(declaringTypeRef)
.Named(CreateParserActionConflictsMethodName)
.BeginArgs()
.EndArgs()
))
.Stfld(LanguageBase.Fields.parserConflictActions)
// Init token complexity table
.Ldarg(0)
.Call(emit.Methods.Method(
_ => _
.StartSignature
.Returning(emit.Types.Import(typeof(int[])))
.DecaringType(declaringTypeRef)
.Named(CreateTokenComplexityTableMethodName)
.BeginArgs()
.EndArgs()
))
.Stfld(LanguageBase.Fields.tokenComplexity)
// Init grammarAction field
.Ldarg(0)
.LdMethodDelegate(
declaringTypeRef,
RuleActionMethodName,
typeof(ProductionActionDelegate))
.Stfld(LanguageBase.Fields.grammarAction)
// Init grammarAction field
.Ldarg(0)
.LdMethodDelegate(
declaringTypeRef,
MergeActionMethodName,
typeof(MergeDelegate))
.Stfld(LanguageBase.Fields.merge)
// Init tokenIdentities
.Ldarg(0)
.Call(emit
.Methods.Method(
_ => _
.StartSignature
.Returning(emit.Types.Import(LanguageBase.Fields.tokenKeyToId.FieldType))
.DecaringType(declaringTypeRef)
.Named(CreateTokenKeyToIdMethodName)
.BeginArgs()
.EndArgs()))
.Stfld(LanguageBase.Fields.tokenKeyToId)
// Init scan field
.Ldarg(0)
.LdMethodDelegate(
declaringTypeRef,
ConditionMethods.GetMethodName(0),
typeof(Scan1Delegate))
.Stfld(LanguageBase.Fields.scan1)
// Init termFactory field
.Ldarg(0)
.LdMethodDelegate(
declaringTypeRef,
TermFactoryMethodName,
typeof(ScanActionDelegate))
.Stfld(LanguageBase.Fields.termFactory)
// Init getParserAction field
.Ldarg(0)
.LdMethodDelegate(
declaringTypeRef,
GetParserActionMethodName,
typeof(TransitionDelegate))
.Stfld(LanguageBase.Fields.getParserAction)
// Init defaul context factory
.Ldarg(0)
.LdMethodDelegate(
declaringTypeRef,
CreateDefaultContextMethodName,
typeof(Func <object>))
.Stfld(LanguageBase.Fields.createDefaultContext)
.Ret()
.EndBody());
}
private CilDocumentSyntax GenerateImpl(PlannedClass entry, CilDocumentSyntax cil)
{
ClassExtendsSyntax wantBaseClass =
cil.Class_()
.Public
.Named(entry.ClassName)
;
var baseClassRef = cil.Types.Import(entry.BaseClass);
ClassImplementsSyntax wantContract =
wantBaseClass
.Extends(baseClassRef);
var baseCtor = entry.BaseClass.GetConstructor(Type.EmptyTypes);
Ref <Methods> baseCtorRef;
if (baseCtor != null)
{
baseCtorRef = cil.Methods.Import(baseCtor);
}
else
{
baseCtorRef = null;
}
foreach (Type c in entry.Contracts)
{
wantContract = wantContract.Implements(cil.Types.Import(c));
}
ClassSyntax classCode = wantContract;
classCode = classCode
.Method()
.Public.Instance
.Returning(classCode.Types.Void)
.Named(".ctor")
.BeginArgs().EndArgs()
.BeginBody()
.Do(il =>
{
if (baseCtorRef != null)
{
il = il
.Ldarg(0)
.Callvirt(baseCtorRef);
}
return(il);
})
.Ret()
.EndBody()
;
foreach (var method in entry.Methods)
{
WantArgsBase wantArgs =
classCode.Method()
.Private.Hidebysig.Newslot
.Virtual.Final.Instance
.Returning(classCode.Types.Import(method.ReturnType))
.Named(method.DeclaringType + "." + method.Name)
.BeginArgs();
foreach (var parameter in method.GetParameters())
{
wantArgs = wantArgs.Argument(
classCode.Types.Import(parameter.ParameterType),
wantArgs.Args.Generate(parameter.Name));
}
var emit = wantArgs.EndArgs().BeginBody();
emit = emit.Override(emit.Methods.Import(method));
emit = EmitFactoryCode(
emit,
entry,
method.ReturnType,
!forceNonNullResult(method));
classCode = emit.Ret().EndBody();
}
return(classCode.EndClass());
}
