/// <summary>
/// Encodes a control-flow graph.
/// </summary>
/// <param name="graph">The control-flow graph to encode.</param>
/// <returns>An LNode that represents the control-flow graph.</returns>
public LNode Encode(FlowGraph graph)
{
var blockNameSet = new UniqueNameSet <UniqueTag>(
tag => tag.Name, "block_");
var valueNameSet = new UniqueNameSet <UniqueTag>(
tag => tag.Name, "val_", blockNameSet);
// Reserve special names.
valueNameSet.ReserveName(CodeSymbols.Result.Name);
valueNameSet.ReserveName(tryFlowExceptionSymbol.Name);
var blockNameMap = new UniqueNameMap <UniqueTag>(blockNameSet);
var valueNameMap = new UniqueNameMap <UniqueTag>(valueNameSet);
var blockNodes = new List <LNode>();
foreach (var block in graph.BasicBlocks)
{
var paramNodes = block.Parameters
.EagerSelect(param =>
Factory.Call(
parameterSymbol,
Encode(param.Type),
EncodeUniqueTag(param.Tag, valueNameMap)));
var instrNodes = block.NamedInstructions
.Select(instr =>
Factory.Call(
CodeSymbols.Assign,
EncodeUniqueTag(instr.Tag, valueNameMap),
Encode(instr.Instruction, valueNameMap)))
.ToArray();
blockNodes.Add(
Factory.Call(
block.Tag == graph.EntryPointTag
? entryPointBlockSymbol
: basicBlockSymbol,
EncodeUniqueTag(block.Tag, blockNameMap),
Factory.Call(CodeSymbols.AltList, paramNodes),
Factory.Call(CodeSymbols.Braces, instrNodes),
Encode(block.Flow, blockNameMap, valueNameMap)));
}
return(Factory.Braces(blockNodes));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
protected ClassType(DynamicModule module, TypeKey key, string classFullName, Type baseType, ClassType containingClass)
{
var resolvedBaseType = TypeTemplate.Resolve(baseType);
m_Key = key;
m_Module = module;
m_Writers = new List <ClassWriterBase>();
m_Members = new List <MemberBase>();
m_MembersByDeclarations = new Dictionary <MemberInfo, MemberBase>();
m_MembersByName = new Dictionary <string, MemberBase>();
m_FactoryMethods = new List <MethodInfo>();
m_MemberNames = new UniqueNameSet();
m_NotImplementedMembers = new HashSet <MemberInfo>();
m_NotImplementedMembers.UnionWith(TypeMemberCache.Of(resolvedBaseType).ImplementableMembers);
m_CompiledType = null;
m_DependencyFields = new List <FieldMember>();
m_NestedClasses = new List <NestedClassType>();
//m_TypeBuilder = module.ModuleBuilder.DefineType(classFullName, DefaultTypeAtributes, resolvedBaseType);
// ReSharper disable once DoNotCallOverridableMethodsInConstructor
m_TypeBuilder = CreateTypeBuilder(module, classFullName, resolvedBaseType, containingClass);
}
