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()); }