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