public static TypeDefinition Create(AssemblyEmitter assembly, TypeReference declaringType, MethodReference targetMethod)
{
var baseType = AssemblyRegistry.GetFunctorType(assembly, targetMethod);
assembly.AddTypeUsage(baseType);
return(new FunctorImplementationTypeEmitter(assembly, declaringType, baseType, targetMethod).typeDefinition);
}
public VariableDefinition Acquire(TypeReference type)
{
Contract.Requires(type != null);
Contract.Ensures(Contract.Result <VariableDefinition>() != null);
if (temporaryVariables == null)
{
temporaryVariables = new List <TempVariable>();
}
for (int i = 0; i < temporaryVariables.Count; i++)
{
if (!temporaryVariables[i].isTaken)
{
var tempVariableType = temporaryVariables[i].variable.VariableType;
if (tempVariableType.FullName == type.FullName && tempVariableType.Scope == type.Scope)
{
var result = temporaryVariables[i].variable;
temporaryVariables[i] = new TempVariable(result, true);
return(result);
}
}
}
var variableName = "$Temp" + (temporaryVariables.Count + 1).ToString();
var variable = new VariableDefinition(variableName, type);
temporaryVariables.Add(new TempVariable(variable, true));
methodBody.Variables.Add(variable);
assembly.AddTypeUsage(type);
return(variable);
}
protected TypeEmitter(AssemblyEmitter assembly, string className, string @namespace, TypeAttributes typeAttributes,
TypeReference baseType, bool addToAssembly)
{
if (assembly == null)
{
throw new ArgumentNullException("assembly");
}
Assembly = assembly;
if (baseType == null)
{
baseType = Assembly.TypeSystem.Object;
}
typeDefinition = new TypeDefinition(@namespace, className, typeAttributes, baseType);
// Structs without fields must have specified class and packing size parameters
if (typeDefinition.IsValueType)
{
typeDefinition.IsSequentialLayout = true;
typeDefinition.ClassSize = 1;
typeDefinition.PackingSize = 0;
}
if (addToAssembly)
{
Assembly.AddType(typeDefinition);
}
Assembly.AddTypeUsage(baseType);
}
