public Type RegisterType(CILClass cilClass, CILProgramInstance programInstance, CILantroType cilantroType)
{
var parentTypeAssembly = Assembly.Load(cilClass.Extends.AssemblyName);
var parentType = parentTypeAssembly.GetType(cilClass.Extends.ClassName);
var typeBuilder = _moduleBuilder.DefineType(cilClass.ClassName.ClassName, TypeAttributes.Class, parentType);
foreach (var method in parentType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
{
if (method.IsAbstract)
{
//typeBuilder.DefineMethodOverride(method, method);
var methodBuilder = typeBuilder.DefineMethod(method.Name, (method.Attributes & (~MethodAttributes.Abstract)), method.ReturnType, method.GetParameters().Select(p => p.ParameterType).ToArray());
var msil = methodBuilder.GetILGenerator();
msil.ThrowException(typeof(NotImplementedException));
typeBuilder.DefineMethodOverride(methodBuilder, method);
//var cilMethods = cilClass.Methods.Select(m => new CILantroMethodInfo(m, programInstance, typeBuilder)).ToList();
//var cilMethod = cilMethods.SingleOrDefault(m => m.Name == method.Name && CILantroType.CompareArgumentTypes(m.GetParameters().Select(p => p.ParameterType).ToArray(), method.GetParameters().Select(p => p.ParameterType).ToArray()));
//typeBuilder.DefineMethodOverride(cilMethod, method);
}
}
var type = typeBuilder.CreateType();
return(type);
}
public CILantroFieldInfo(CILClassField cilClassField, CILClass cilClass)
{
_cilClass = cilClass;
_name = cilClassField.Name;
_isPublic = cilClassField.IsPublic();
_isStatic = cilClassField.IsStatic();
}
/// <summary>
/// Get the guid of a static variable, which is a static field of a class.
/// It is global and accessible by a pair of a class name and a variable name.
/// </summary>
/// <param name="classType">The class containing the static field</param>
/// <param name="variable">The static variable</param>
/// <returns>The guid of the static variable</returns>
public int GetStaticVariable(CILClass classType, CILVariable variable)
{
string name = classType.Name + ":" + variable.Name;
for(int i = 0; i < names.Count; i++)
if(names[i] == name)
return values[i];
AddStaticVariable(classType, variable);
// the second time we must have got the variable on the list already
return GetStaticVariable(classType, variable);
}
public override void CopyInternalData(VMValue other)
{
base.CopyInternalData (other);
VMValue_objectinst theOther = (VMValue_objectinst)other;
classType = theOther.classType;
holdingLockThreadID = theOther.holdingLockThreadID;
holdingLockCount = theOther.holdingLockCount;
for(int i = 0; i < ((VMValue_objectinst)other).fields.Count; i++)
fields.Add(theOther.fields[i]);
}
public CILantroType(CILClass cilClass, CILProgramInstance programInstance)
{
_programInstance = programInstance;
_cilClass = cilClass;
_fields = _cilClass.Fields.Select(f => new CILantroFieldInfo(f, cilClass)).ToList();
_constructors = _cilClass.Constructors.Select(c => new CILantroConstructorInfo(c, _programInstance)).ToList();
var methods = _cilClass.Methods.Select(m => new CILantroMethodInfo(m, _programInstance, this)).ToList();
var constructorMethods = _cilClass.Constructors.Select(m => new CILantroMethodInfo(m, _programInstance, this)).ToList();
_methods = methods.Union(constructorMethods).ToList();
}
public override CILProgram BuildNode(ParseTreeNode node)
{
CILClass cilClass = null;
var declarationNode = node.GetChildDeclarationNode();
cilClass = _classBuilder.BuildNode(declarationNode);
return(new CILProgram
{
Class = cilClass
});
}
public Type RegisterEnumType(CILClass enumClass)
{
var enumBuilder = _moduleBuilder.DefineEnum(enumClass.ClassName.ClassName, TypeAttributes.Class, typeof(int));
foreach (var cilField in enumClass.Fields)
{
if (cilField.Name != "value__")
{
var fieldInitValue = Convert.ToInt32(cilField.InitValue);
enumBuilder.DefineLiteral(cilField.Name, fieldInitValue);
}
}
var enumType = enumBuilder.CreateType();
return(enumType);
}
public void AddStaticVariable(CILClass classType, CILVariable variable)
{
string name = classType.Name + ":" + variable.Name;
VMValue v = systemState.Values.MakeValue(variable);
v.IsConcrete = true;
v.IsThreadLocal = false;
for(int i = 0; i < names.Count; i++)
if(name == names[i])
return;
else if(name.CompareTo(names[i]) < 0)
{
names.Insert(i, name);
values.Insert(i, v.GUID);
return;
}
names.Add(name);
values.Add(v.GUID);
}
public VMValue_objectinst(int guid, VMValueManager valueFactory, CILClass classType)
: base(guid)
{
this.classType = classType;
this.holdingLockThreadID = -1;
this.holdingLockCount = 0;
IEnumerator iter = classType.GetFieldEnumerator();
while(iter.MoveNext())
{
CILClassField field = (CILClassField)iter.Current;
if(field.IsStatic == false)
{
VMValue f = valueFactory.MakeValue(field.Variable);
f.IsConcrete = true;
fields.Add(f.GUID);
}
}
}
public CILClassInstance(CILClass cilClass)
{
_cilClass = cilClass;
Fields = new Dictionary <string, object>();
FieldAddresses = new Dictionary <string, Guid>();
foreach (var cilField in cilClass.Fields)
{
if (!cilField.IsStatic())
{
Fields.Add(cilField.Name, null);
}
if (!cilField.IsStatic())
{
FieldAddresses.Add(cilField.Name, Guid.NewGuid());
}
}
var baseClass = _cilClass;
var nextBaseClass = baseClass.ExtendsClass;
while (nextBaseClass != null)
{
baseClass = nextBaseClass;
nextBaseClass = baseClass.ExtendsClass;
}
var extendsAssembly = Assembly.Load(baseClass.Extends.AssemblyName);
var extendsType = extendsAssembly.GetType(baseClass.Extends.ClassName);
if (extendsType.IsAbstract)
{
BaseInstance = FormatterServices.GetUninitializedObject(baseClass.RuntimeType);
}
else
{
BaseInstance = FormatterServices.GetUninitializedObject(extendsType);
}
}
public int GetStaticVariable(CILClass classType, CILVariable variable)
{
return heap.GetStaticVariable(classType, variable);
}
public override void CopyInternalData(VMValue other)
{
base.CopyInternalData(other);
classType = ((VMValue_object)other).classType;
valueguid = ((VMValue_object)other).valueguid;
}
public VMValue_object(int guid, CILClass classType, int objinstGuid)
: base(guid)
{
this.classType = classType;
this.valueguid = objinstGuid;
}
