private void BuildHook(MethodBuilder methodBuilder, CompiledPeg peg, MethodBuilder[] methodBuilders, FieldBuilder[] memoizationFields)
{
var generator = methodBuilder.GetILGenerator();
if (EmitErrorInfo)
{
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldc_I4, peg.Methods.Count);
generator.Emit(OpCodes.Newarr, typeof(char *));
generator.Emit(OpCodes.Stfld, entryPointsField);
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldc_I4, peg.Methods.Count);
generator.Emit(OpCodes.Newarr, typeof(char *));
generator.Emit(OpCodes.Stfld, exitPointsField);
}
if (EnableMemoization)
{
foreach (var field in memoizationFields)
{
if (field != null)
{
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldfld, dataSizeField);
generator.Emit(OpCodes.Ldc_I4_1);
generator.Emit(OpCodes.Add);
generator.Emit(OpCodes.Newarr, typeof(UnsafePatternResult));
generator.Emit(OpCodes.Stfld, field);
}
}
}
generator.BeginScope();
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldarg_1);
generator.EmitCall(OpCodes.Call, methodBuilders[peg.StartPatternIndex], null);
generator.Emit(OpCodes.Ret);
generator.EndScope();
}
private Type CompileInternal(CompiledPeg peg)
{
var methods = peg.Methods;
var moduleBuilder = CreateModuleBuilder();
var typeBuilder = moduleBuilder.DefineType("InternalType", TypeAttributes.Public | TypeAttributes.Class, typeof(BaseJittedRunner));
var hookAttributes = MethodAttributes.Public | MethodAttributes.ReuseSlot | MethodAttributes.Virtual | MethodAttributes.HideBySig;
var hook = typeBuilder.DefineMethod("RunInternal", hookAttributes, typeof(UnsafePatternResult), new[] { typeof(char *) });
var methodBuilders = methods
.Select((method, i) => typeBuilder.DefineMethod($"Pattern_{method}_{i}", MethodAttributes.Private | MethodAttributes.HideBySig, typeof(UnsafePatternResult), new[] { typeof(char *) }))
.ToArray();
var memoizationFields = EnableMemoization ? methods.Select((method, i) => typeBuilder.DefineField($"memoization_{method}_{i}", typeof(UnsafePatternResult[]), FieldAttributes.Private)).ToArray() : null;
BuildHook(hook, peg, methodBuilders, memoizationFields);
BuildConstructor(typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { typeof(List <Method>) }));
for (var i = 0; i < methodBuilders.Length; i++)
{
CompileSinglePattern(i, methods, methodBuilders, memoizationFields);
}
return(typeBuilder.CreateTypeInfo().UnderlyingSystemType);
}
public CompiledPeg Optimize(CompiledPeg peg)
{
return(new CompiledPeg(peg.Methods.Select(method => OptimizeSingleMethod(method)).ToList(), peg.StartPatternIndex));
}
public IRunnerFactory CompileAsFactory(CompiledPeg peg)
{
return(new ILRunnerFactory(CompileInternal(peg), peg.Methods));
}
public IRunner Compile(CompiledPeg peg)
{
return((IRunner)Activator.CreateInstance(CompileInternal(peg), new object[] { peg.Methods }));
}
public IRunnerFactory CompileAsFactory(CompiledPeg compiledPeg)
{
var labelPositions = compiledPeg.Methods.Select(item => CalculateLabelPositions(item)).ToArray();
return(new InterpreterFactory(compiledPeg.StartPatternIndex, compiledPeg.Methods, labelPositions));
}
