/*-------------------- Constructors ---------------------------------*/ internal MethodRef(Class paren, string name, Type retType, Type[] pars) : base(name,retType,paren) { sig.parTypes = pars; if (pars != null) sig.numPars = (uint)pars.Length; }
internal void SetClassParam(Class paren, int ix) { typeIndex = VAR; parent = paren; index = (ushort)ix; }
internal InterfaceImpl(ClassDef theClass, TableRow theInterface) { this.theClass = theClass; this.theInterface = (Class)theInterface; tabIx = MDTable.InterfaceImpl; }
/*-------------------- Constructors ---------------------------------*/ internal Field(string pfName, Type pfType, Class paren) : base(pfName, paren) { type = pfType; }
/// <summary> /// Add a type constraint to this generic parameter /// </summary> /// <param name="cType">class constraining the parameter type</param> public void AddConstraint(Class cType) { constraints.Add(cType); }
public ClassTypeConst(Class classDesc) { desc = classDesc; type = ElementType.ClassType; }
public void SetModifingType(Class mod) { cmodType = mod; }
/*-------------------- Constructors ---------------------------------*/ /// <summary> /// Create a new catch clause /// </summary> /// <param name="except">the exception to be caught</param> /// <param name="handlerStart">start of the handler code</param> /// <param name="handlerEnd">end of the handler code</param> public Catch(Class except, CILLabel handlerStart, CILLabel handlerEnd) : base(handlerStart,handlerEnd) { exceptType = except; }
private Type GetBlobType() { //Class currClass, Method currMeth) { byte typeIx = blob.ReadByte(); if (Diag.DiagOn) Console.WriteLine("Getting blob type " + (ElementType)typeIx); if (typeIx < PrimitiveType.primitives.Length) return PrimitiveType.primitives[typeIx]; switch (typeIx) { case ((int)ElementType.Ptr) : return new UnmanagedPointer(GetBlobType()); //currClass,currMeth)); case ((int)ElementType.ByRef) : return new ManagedPointer(GetBlobType()); //currClass,currMeth)); case ((int)ElementType.ValueType) : //Console.WriteLine("Reading value type"); uint vcIx = blob.ReadCompressedNum(); Class vClass = (Class)GetCodedElement(CIx.TypeDefOrRef,vcIx); vClass.MakeValueClass(); return vClass; case ((int)ElementType.Class) : return (Class)GetCodedElement(CIx.TypeDefOrRef,blob.ReadCompressedNum()); case ((int)ElementType.Array) : Type elemType = GetBlobType(); //currClass,currMeth); int rank = (int)blob.ReadCompressedNum(); int numSizes = (int)blob.ReadCompressedNum(); int[] sizes = null; if (numSizes > 0){ sizes = new int[numSizes]; for (int i=0; i < numSizes; i++) sizes[i] = (int)blob.ReadCompressedNum(); } int numBounds = (int)blob.ReadCompressedNum(); int[] loBounds = null, hiBounds = null; if ((numBounds > 0) && (numSizes > 0)){ loBounds = new int[numBounds]; hiBounds = new int[numBounds]; for (int i=0; i < numBounds; i++) { loBounds[i] = (int)blob.ReadCompressedNum(); hiBounds[i] = loBounds[i] + sizes[i] - 1; } } if (numSizes == 0) return new BoundArray(elemType,rank); if (numBounds == 0) return new BoundArray(elemType,rank,sizes); return new BoundArray(elemType,rank,loBounds,hiBounds); case ((int)ElementType.TypedByRef) : return PrimitiveType.TypedRef; case ((int)ElementType.I) : return PrimitiveType.IntPtr; case ((int)ElementType.U) : return PrimitiveType.UIntPtr; case ((int)ElementType.FnPtr) : MethSig mSig = ReadMethSig(null,false); return new MethPtrType(mSig); case ((int)ElementType.Object) : return PrimitiveType.Object; case ((int)ElementType.SZArray) : return new ZeroBasedArray(GetBlobType()); //currClass,currMeth)); case ((int)ElementType.CmodReqd) : case ((int)ElementType.CmodOpt) : Class modType = (Class)GetCodedElement(CIx.TypeDefOrRef,blob.ReadCompressedNum()); return new CustomModifiedType(GetBlobType(),(CustomModifier)typeIx,modType); case ((int)ElementType.Sentinel) : return sentinel; case ((int)ElementType.Pinned) : return pinned; case ((int)ElementType.GenericInst) : Class instType = (Class)GetBlobType(); Class scopeSave = currentClassScope; if (genInstNestLevel > 0) { currentClassScope = instType; } genInstNestLevel++; ClassSpec newClassSpec = new ClassSpec(instType,GetListOfType()); genInstNestLevel--; if (genInstNestLevel > 0) { currentClassScope = scopeSave; } return newClassSpec; case ((int)ElementType.Var) : if (currentClassScope == null) { //Console.WriteLine("GenericParam with currClass == null"); return GenericParam.AnonClassPar(blob.ReadCompressedNum()); //throw new Exception("No current class set"); } return currentClassScope.GetGenPar(blob.ReadCompressedNum()); case ((int)ElementType.MVar) : if (currentMethodScope == null) { //Console.WriteLine("GenericParam with currMeth == null"); return GenericParam.AnonMethPar(blob.ReadCompressedNum()); //throw new Exception("No current method set"); } return currentMethodScope.GetGenericParam((int)blob.ReadCompressedNum()); default: break; } return null; }
/// <summary> /// Delete a class from this module /// </summary> /// <param name="aClass">The name of the class to be deleted</param> public void RemoveClass(Class aClass) { classes.Remove(aClass); }
internal virtual void AddToClassList(Class aClass) { classes.Add(aClass); }
internal void ReplaceClass(Class aClass) { bool found = false; for (int i=0; (i < classes.Count) && !found; i++) { if (((Class)classes[i]).Name() == aClass.Name()) { found = true; } } if (!found) classes.Add(aClass); }
/// <summary> /// Add a class to this PE File /// </summary> /// <param name="attrSet">attributes of this class</param> /// <param name="nsName">name space name</param> /// <param name="name">class name</param> /// <param name="superType">super type of this class (extends)</param> /// <returns>a descriptor for this new class</returns> public ClassDef AddClass(TypeAttr attrSet, string nsName, string name, Class superType) { ClassDef aClass = AddClass(attrSet,nsName,name); aClass.SuperType = superType; return aClass; }
internal MethSig InstantiateGenTypes(Class classType, Type[] genTypes) { MethSig newSig = new MethSig(name); newSig.callConv = callConv; newSig.numPars = numPars; newSig.numOptPars = numOptPars; newSig.numGenPars = numGenPars; newSig.parTypes = ReplaceGenPars(parTypes,classType,genTypes); newSig.optParTypes = ReplaceGenPars(optParTypes,classType,genTypes); newSig.retType = SubstituteType(retType,classType,genTypes); return newSig; }
internal override void Resolve(PEReader buff) { buff.currentClassScope = this; superType = (Class)buff.GetCodedElement(CIx.TypeDefOrRef,extendsIx); if ((superType != null) && superType.isValueType()) typeIndex = (byte)ElementType.ValueType; for (int i=0; fieldIx < fieldEndIx; i++, fieldIx++) { FieldDef field = (FieldDef)buff.GetElement(MDTable.Field,fieldIx); field.SetParent(this); fields.Add(field); } for (int i=0; methodIx < methodEndIx; i++, methodIx++) { MethodDef meth = (MethodDef)buff.GetElement(MDTable.Method,methodIx); if (Diag.DiagOn) Console.WriteLine("Adding method " + meth.Name() + " to class " + name); meth.SetParent(this); methods.Add(meth); } buff.currentClassScope = null; }
/// <summary> /// Mark this position as the end of the last started block and /// make it a catch block. This catch block is associated with the /// specified try block. /// </summary> /// <param name="exceptType">the exception type to be caught</param> /// <param name="tryBlock">the try block associated with this catch block</param> public void EndCatchBlock(Class exceptType, TryBlock tryBlock) { Catch catchBlock = new Catch(exceptType,(CILLabel)blockStack.Pop(), NewCodedLabel()); tryBlock.AddHandler(catchBlock); }
/*-------------------- Constructors ---------------------------------*/ internal ClassSpec(Class clType, Type[] gPars) { this.typeIndex = GENERICINST; genClass = clType; genericParams = new ArrayList(gPars); tabIx = MDTable.TypeSpec; typeIndex = GENERICINST; ArrayList classMethods = clType.GetMethodList(); ArrayList classFields = clType.GetFieldList(); for (int i=0; i < classMethods.Count; i++) { MethSig mSig = ((Method)classMethods[i]).GetSig(); //.InstantiateGenTypes(this,gPars); if (mSig != null) { MethodRef newMeth = new MethodRef(mSig); newMeth.SetParent(this); newMeth.GenericParams = ((Method)classMethods[i]).GenericParams; methods.Add(newMeth); } } for (int i=0; i < classFields.Count; i++) { Type fType = ((Field)classFields[i]).GetFieldType(); //if ((fType is GenericParam) && (((GenericParam)fType).GetParent() == genClass)) { // fType = gPars[((GenericParam)fType).Index]; //} fields.Add(new FieldRef(this,((Field)classFields[i]).Name(),fType)); } }
internal void AddToClassList(Class nClass) { nestedClasses.Add(nClass); }
/*-------------------- Constructors ---------------------------------*/ /// <summary> /// Create a new custom modifier for a type /// </summary> /// <param name="type">the type to be modified</param> /// <param name="cmod">the modifier</param> /// <param name="cmodType">the type reference to be associated with the type</param> public CustomModifiedType(Type type, CustomModifier cmod, Class cmodType) : base((byte)cmod) { this.type = type; this.cmodType = cmodType; }
//uint[] interfaceIndexes; //private string[] eventNames, propertyNames, nestedNames; //internal string[][] names = new string[numListIx][]; /*-------------------- Constructors ---------------------------------*/ internal ClassDef(PEFile scope, TypeAttr attrSet, string nsName, string name) : base(nsName,name) { this.scope = scope; superType = MSCorLib.mscorlib.ObjectClass; flags = (uint)attrSet; tabIx = MDTable.TypeDef; }
internal override void AddToClassList(Class aClass) { ((ClassDef)aClass).SetScope((PEFile)this); classes.Add(aClass); }
/// <summary> /// Add an interface that is implemented by this class /// </summary> /// <param name="iFace">the interface that is implemented</param> public void AddImplementedInterface(Class iFace) { interfaces.Add(new InterfaceImpl(this,iFace)); //metaData.AddToTable(MDTable.InterfaceImpl,new InterfaceImpl(this,iFace)); }
/*-------------------- Constructors ---------------------------------*/ internal FieldRef(Class paren, string name, Type fType) : base(name, fType, paren) { parent = paren; }
/// <summary> /// Add a nested class to this class /// </summary> /// <param name="attrSet">attributes for this nested class</param> /// <param name="name">nested class name</param> /// <param name="sType">super type of this nested class</param> /// <returns>a descriptor for this new nested class</returns> public NestedClassDef AddNestedClass(TypeAttr attrSet, string name, Class sType) { NestedClassDef nClass = AddNestedClass(attrSet,name); nClass.superType = sType; return (nClass); }
/// <summary> /// Remove a constraint from this generic parameter /// </summary> /// <param name="cType">class type of constraint</param> public void RemoveConstraint(Class cType) { for (int i=0; i < constraints.Count; i++) { if (constraints[i] == cType) { constraints.RemoveAt(i); return; } } }
/// <summary> /// Get the interfaces implemented by this class /// </summary> /// <returns>List of implemented interfaces</returns> public Class[] GetInterfaces() { Class[] iFaces = new Class[interfaces.Count]; for (int i=0; i < iFaces.Length; i++) { iFaces[i] = ((InterfaceImpl)interfaces[i]).TheInterface(); } return iFaces; }
/*-------------------- Constructors ---------------------------------*/ public GenericParamConstraint(GenericParam parent, Class constraint) { this.parent = parent; this.constraint = constraint; tabIx = MDTable.GenericParamConstraint; }
public override void MakeSpecial() { special = true; superType = null; flags = (uint)TypeAttr.Private; }
internal override void Resolve(PEReader buff) { theClass = (ClassDef)buff.GetElement(MDTable.TypeDef,classIx); theInterface = (Class)buff.GetCodedElement(CIx.TypeDefOrRef,interfacesIndex); theClass.AddImplementedInterface(this); }
/*-------------------- Constructors ---------------------------------*/ internal Method(string methName, Type rType, Class paren) : base(methName,paren) { sig = new MethSig(methName); sig.retType = rType; }