private static void ProcessFunctions(TypeInfo parentTypeInfo, TreeNode parentTreeNode) { using (TypeAttr attr = parentTypeInfo.GetTypeAttr()) { // // Walk through all the function/propput/propget/propref properties // for (int i = ConvCommon2.GetIndexOfFirstMethod(parentTypeInfo, attr); i < attr.cFuncs; ++i) { FunctionInfoMatchTarget functionInfo = new FunctionInfoMatchTarget(parentTypeInfo, (short)i); TreeNode funcTreeNode = new TreeNode(); if (functionInfo.FuncDesc.IsPropertyGet) { funcTreeNode.Text = functionInfo.Name + " (getter)" + ": " + functionInfo.Type; } else if (functionInfo.FuncDesc.IsPropertyPut || functionInfo.FuncDesc.IsPropertyPutRef) { funcTreeNode.Text = functionInfo.Name + " (setter)" + ": " + functionInfo.Type; } else { funcTreeNode.Text = functionInfo.Name + ": " + functionInfo.Type; } funcTreeNode.Tag = functionInfo; SetTlbTreeNodeImage(funcTreeNode); parentTreeNode.Nodes.Add(funcTreeNode); ProcessFuncParams(parentTypeInfo, functionInfo.Index, funcTreeNode); } } }
public OWEnum(ITlibNode parent, ITypeInfo ti, TypeAttr ta) { Parent = parent; _name = ti.GetName(); _ta = ta; _ti = ti; }
public OWModule(ITlibNode parent, ITypeInfo ti, TypeAttr ta) { Parent = parent; _ti = ti; _ta = ta; _name = _ti.GetName(); if (_ta.cVars <= 0 && _ta.cFuncs <= 0) { return; } var tix = new olewoo_interop.ITypeInfoXtra(); if (_ta.cFuncs > 0) { var fd = new FuncDesc(_ti, 0); var invkind = fd.invkind; var memid = fd.memid; _dllname = tix.GetDllEntry(ti, invkind, memid); } else { _dllname = null; } _data = new IDLData(this); }
/// <summary> /// If the type is aliased, return the ultimated non-aliased type if the type is user-defined, otherwise, return /// the aliased type directly. So the result could still be aliased to a built-in type. /// If the type is not aliased, just return the type directly /// </summary> static public void ResolveAlias(TypeInfo type, TypeDesc typeDesc, out TypeInfo realType, out TypeAttr realAttr) { if ((VarEnum)typeDesc.vt != VarEnum.VT_USERDEFINED) { // Already resolved realType = type; realAttr = type.GetTypeAttr(); return; } else { TypeInfo refType = type.GetRefTypeInfo(typeDesc.hreftype); TypeAttr refAttr = refType.GetTypeAttr(); // If the userdefined typeinfo is not itself an alias, then it is what the alias aliases. // Also, if the userdefined typeinfo is an alias to a builtin type, then the builtin // type is what the alias aliases. if (refAttr.typekind != TypeLibTypes.Interop.TYPEKIND.TKIND_ALIAS || (VarEnum)refAttr.tdescAlias.vt != VarEnum.VT_USERDEFINED) { // Resolved realType = refType; realAttr = refAttr; } else { // Continue resolving the type ResolveAlias(refType, refAttr.tdescAlias, out realType, out realAttr); } } }
public OWRecord(ITlibNode parent, ITypeInfo ti, TypeAttr ta) { Parent = parent; _ti = ti; _ta = ta; _name = _ti.GetName(); }
public ClassDef AddDefinition(string name_space, string name, TypeAttr attr, Location location) { string full_name; if (name_space != null) { full_name = String.Format("{0}.{1}", name_space, name); } else { full_name = name; } ClassTableItem item = (ClassTableItem)table[full_name]; if (item == null) { ClassDef klass = pefile.AddClass(attr, name_space, name); AddDefined(full_name, klass, location); return(klass); } item.Class.AddAttribute(attr); item.Defined = true; return(item.Class); }
public OWTypeDef(ITlibNode parent, ITypeInfo ti, TypeAttr ta) { Parent = parent; _ta = ta; _ti = ti; string prefix = string.Empty; if (VarEnum.VT_PTR == ((VarEnum)_ta.tdescAlias.vt & VarEnum.VT_PTR)) { var otd = _ta.tdescAlias.lptdsec; _ti.GetRefTypeInfo(otd.hreftype, out _oti); prefix = _oti.GetName() + " "; } else if (VarEnum.VT_ARRAY == ((VarEnum)_ta.tdescAlias.vt & VarEnum.VT_ARRAY)) { var oad = ta.tdescAlias.lpadesc; _ti.GetRefTypeInfo(oad.tdescElem.hreftype, out _oti); prefix = _oti.GetName() + " "; } else { _ti.GetRefTypeInfo(_ta.tdescAlias.hreftype, out _oti); prefix = _oti.GetName() + " "; } _name = prefix + ti.GetName(); _data = new IDLData(this); }
/// <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); }
public ClassDef AddDefinition(string name_space, string name, TypeAttr attr, Class parent, Location location) { string full_name; if (name_space != null) { full_name = String.Format("{0}.{1}", name_space, name); } else { full_name = name; } ClassTableItem item = (ClassTableItem)table[full_name]; if (item == null) { ClassDef klass = pefile.AddClass(attr, name_space, name, parent); AddDefined(full_name, klass, location); return(klass); } /// TODO: Need to set parent, will need to modify PEAPI for this. item.Class.AddAttribute(attr); item.Defined = true; return(item.Class); }
public OWTypeDef(ITlibNode parent, ITypeInfo ti, TypeAttr ta) { Parent = parent; _ta = ta; _ti = ti; string prefix = string.Empty; if (VarEnum.VT_ARRAY == ((VarEnum)_ta.tdescAlias.vt & VarEnum.VT_ARRAY)) { var oad = ta.tdescAlias.lpadesc; _ti.GetRefTypeInfo(oad.tdescElem.hreftype, out _oti); prefix = _oti.GetName() + " "; } else { TmpIdlFormatter tmp = new TmpIdlFormatter(); _ta.tdescAlias.ComTypeNameAsString(ti, tmp); prefix = tmp.data + " "; if (VarEnum.VT_USERDEFINED == (VarEnum)_ta.tdescAlias.vt) { _ti.GetRefTypeInfo(_ta.tdescAlias.hreftype, out _oti); } } _name = prefix + ti.GetName(); _data = new IDLData(this); }
public ActionResult Edit(TypeAttr t) { var typeattr = db.TypeAttrs.Where(x => x.TypeId == t.TypeId).SingleOrDefault(); if (typeattr != null) { var coutOrderby = db.TypeAttrs.OrderBy(x => x.OrderBy).Where(y => y.TypeId != t.TypeId && y.Status != 10 && y.OrderBy >= t.OrderBy).ToList(); typeattr.TypeName = t.TypeName; if (t.OrderBy > 0) { if (typeattr.OrderBy != t.OrderBy) { var orderby = t.OrderBy; foreach (var item in coutOrderby) { item.OrderBy = ++orderby; } } typeattr.OrderBy = t.OrderBy; typeattr.Status = t.Status; db.SaveChanges(); return(Json(new { success = "Chỉnh sửa thành công !" }, JsonRequestBehavior.AllowGet)); } else { return(Json(new { error = "Số thứ tự không được nhỏ hơn 1 !" }, JsonRequestBehavior.AllowGet)); } } else { return(Json(new { error = "Có lỗi khi chỉnh sửa !" }, JsonRequestBehavior.AllowGet)); } }
public OWEnum(ITlibNode parent, ITypeInfo ti, TypeAttr ta) { Parent = parent; _name = ti.GetName(); _ta = ta; _ti = ti; _data = new IDLData(this); }
/*-------------------- Constructors ---------------------------------*/ internal ExternClass(TypeAttr attr, string ns, string name, MetaDataElement paren) { flags = (uint)attr; NameSpace = ns; this.Name = name; implementation = paren; tabIx = MDTable.ExportedType; }
/// <summary> /// Add a class which extends System.ValueType to this Module /// If this class already exists, throw an exception /// </summary> /// <param name="attrSet">attributes of this class</param> /// <param name="nsName">name space name</param> /// <param name="name">class name</param> /// <returns>a descriptor for this new class</returns> public ClassDef AddValueClass(TypeAttr attrSet, string nsName, string name) { ClassDef aClass = AddClass(attrSet, nsName, name); aClass.SuperType = MSCorLib.mscorlib.ValueType(); aClass.MakeValueClass(); return(aClass); }
public OWInterface(ITlibNode parent, ITypeInfo ti, TypeAttr ta, bool topLevel) { Parent = parent; _name = ti.GetName(); _ta = ta; _ti = ti; _topLevel = topLevel; }
public void AddClass(string name, TypeAttr ta, string assemblyReference) { if (class_table == null) { class_table = new List <ExternClass> (); } class_table.Add(new ExternClass(name, ta, assemblyReference)); }
/*-------------------- Constructors ---------------------------------*/ internal ClassDef(PEFile scope, TypeAttr attrSet, string nsName, string name) : base(nsName, name) { Contract.Requires(scope != null); this.scope = scope; superType = MSCorLib.mscorlib.ObjectClass; flags = (uint)attrSet; tabIx = MDTable.TypeDef; }
public OWTypeDef(ITlibNode parent, ITypeInfo ti, TypeAttr ta) { Parent = parent; _ta = ta; _ti = ti; _ti.GetRefTypeInfo(_ta.tdescAlias.hreftype, out var oti); _name = oti.GetName() + " " + ti.GetName(); }
public OWDispInterface(ITlibNode parent, ITypeInfo ti, TypeAttr ta, bool topLevel) { Parent = parent; _name = ti.GetName(); _ta = ta; _ti = ti; _methodChildren = new OWIDispatchMethods(this); _propChildren = new OWIDispatchProperties(this); _topLevel = topLevel; _data = new IDLData(this); }
public JsonResult Create(TypeAttr t) { if (ModelState.IsValid) { var countOrderby = db.TypeAttrs.OrderBy(x => x.OrderBy).Where(x => x.Status != 10).Count(); t.OrderBy = countOrderby + 1; db.TypeAttrs.Add(t); db.SaveChanges(); return(Json(new { success = "Thêm mới thành công !" }, JsonRequestBehavior.AllowGet)); } return(Json(new { error = "Có lỗi khi thêm mới !" }, JsonRequestBehavior.AllowGet)); }
internal static TreeNode GetTypeLibNode(TypeLib tlb, DisplayLevel displayLevel) { string typeLibName = tlb.GetDocumentation(); TreeNode root = new TreeNode(typeLibName); root.Tag = tlb; int nCount = tlb.GetTypeInfoCount(); for (int n = 0; n < nCount; ++n) { TypeInfo type = tlb.GetTypeInfo(n); //string typeTypeName = type.GetDocumentation(); //NativeType2String.AddNativeUserDefinedType(typeTypeName); // For dual interfaces, it has a "funky" TKIND_DISPATCH|TKIND_DUAL interface with a parter of TKIND_INTERFACE|TKIND_DUAL interface // The first one is pretty bad and has duplicated all the interface members of its parent, which is not we want // We want the second v-table interface // So, if we indeed has seen this kind of interface, prefer its partner // However, we should not blindly get the partner because those two interfaces partners with each other // So we need to first test to see if the interface is both dispatch & dual, and then get its partner interface using (TypeAttr attr = type.GetTypeAttr()) { if (attr.IsDual && attr.IsDispatch) { TypeInfo typeReferencedType = type.GetRefTypeNoComThrow(); if (typeReferencedType != null) { type = typeReferencedType; } } } TreeNode typeInfoNode = new TreeNode(); TypeInfoMatchTarget typeInfoMatchTarget = null; root.Nodes.Add(typeInfoNode); using (TypeAttr attr = type.GetTypeAttr()) { TYPEKIND kind = attr.typekind; typeInfoMatchTarget = new TypeInfoMatchTarget(tlb, type, kind); if (displayLevel == DisplayLevel.All) { ProcessFunctions(type, typeInfoNode); ProcessFields(type, typeInfoNode); } } typeInfoNode.Text = typeInfoMatchTarget.Name + ": " + typeInfoMatchTarget.Type; typeInfoNode.Tag = typeInfoMatchTarget; SetTlbTreeNodeImage(typeInfoNode); } return(root); }
/*------------------------- public set and get methods --------------------------*/ /// <summary> /// Add a class to this Module /// If this class already exists, throw an exception /// </summary> /// <param name="attrSet">attributes of this class</param> /// <param name="nsName">name space name</param> /// <param name="name">class name</param> /// <returns>a descriptor for this new class</returns> public ClassDef AddClass(TypeAttr attrSet, string nsName, string name) { //FIXME Contract.Requires(classes != null); ClassDef aClass = GetClass(nsName, name); if (aClass != null) { throw new DescriptorException("Class " + aClass.NameString()); } aClass = new ClassDef((PEFile)this, attrSet, nsName, name); classes.Add(aClass); return(aClass); }
public void BeginTypeDef(TypeAttr attr, string name, BaseClassRef parent, ArrayList impl_list, Location location, GenericParameters gen_params) { TypeDef outer = null; string cache_name = CacheName(name); if (typedef_stack_top > 0) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < typedef_stack_top; i++) { outer = (TypeDef)typedef_stack [i]; if (i == 0) { /* Use FullName for outermost class to get the * namespace also */ sb.Append(outer.FullName); } else { sb.Append(outer.Name); } sb.Append("/"); } sb.Append(name); cache_name = sb.ToString(); } TypeDef typedef = type_manager[cache_name]; if (typedef != null) { // Class head is allready defined, we are just reopening the class current_customattrtarget = current_typedef = typedef; current_declsectarget = typedef; typedef_stack.Add(current_typedef); typedef_stack_top++; return; } typedef = new TypeDef(attr, current_namespace, name, parent, impl_list, location, gen_params, outer); type_manager[cache_name] = typedef; current_customattrtarget = current_typedef = typedef; current_declsectarget = typedef; typedef_stack.Add(typedef); typedef_stack_top++; }
////////////////////////////////////////////////////////////////////////// // Methods ////////////////////////////////////////////////////////////////////////// /// <summary> /// Define a new class to emit for this assembly. This class /// becomes the 'current' class, where subsequent EmitMethod /// and EmitField calls will popuate this class. /// </summary> public void emitClass(string baseQName, string qname, string[] interfaces, TypeAttr attr) { string[] s = FanUtil.splitQName(qname); className = qname; // first check if this type was already stubbed out classDef = (ClassDef)types[qname]; if (classDef == null) { // if not, we need to create it if (qname.IndexOf("/") != -1) { // Nested class PERWAPI.ClassDef cdef = (PERWAPI.ClassDef)findType(s[0]); classDef = cdef.AddNestedClass(attr, s[1]); } else { // Normal class classDef = peFile.AddClass(attr, s[0], s[1]); } } else { // if stubbed out, make sure we define the type correctly classDef.SetAttribute(attr); } // base class if (baseQName == null) { classDef.SuperType = null; } else { classDef.SuperType = findType(baseQName) as PERWAPI.Class; } // interfaces for (int i = 0; i < interfaces.Length; i++) { classDef.AddImplementedInterface(findType(interfaces[i]) as PERWAPI.Class); } types[qname] = classDef; }
public static bool SwapForInterface(ref ITypeInfo ti, ref TypeAttr ta) { try { if (ta.typekind == TypeAttr.TypeKind.TKIND_DISPATCH && 0 != (ta.wTypeFlags & TypeAttr.TypeFlags.TYPEFLAG_FDUAL)) { ti.GetRefTypeOfImplType(-1, out var href); ti.GetRefTypeInfo(href, out ti); ta = new TypeAttr(ti); return(true); } } // ReSharper disable once EmptyGeneralCatchClause catch (Exception) { } return(false); }
private static void ProcessFields(TypeInfo parentTypeInfo, TreeNode parentTreeNode) { // // Walk through all vars (including elements from structs and disp interface, ...) // using (TypeAttr attr = parentTypeInfo.GetTypeAttr()) { for (int i = 0; i < attr.cVars; ++i) { FieldInfoMatchTarget variableInfo = new FieldInfoMatchTarget(parentTypeInfo, i); TreeNode dispVarTreeNode = new TreeNode(); dispVarTreeNode.Text = variableInfo.Name + ": " + variableInfo.Type; dispVarTreeNode.Tag = variableInfo; SetTlbTreeNodeImage(dispVarTreeNode); parentTreeNode.Nodes.Add(dispVarTreeNode); } } }
/// <summary> /// This function is used to workaround around the fact that the TypeInfo might return IUnknown/IDispatch methods (in the case of dual interfaces) /// So we should always call this function to get the first index for different TypeInfo and never save the id /// </summary> static public int GetIndexOfFirstMethod(TypeInfo type, TypeAttr attr) { if (attr.typekind != TypeLibTypes.Interop.TYPEKIND.TKIND_DISPATCH) { return(0); } int nIndex = 0; if (attr.cFuncs >= 3) { // Check for IUnknown first using (FuncDesc func = type.GetFuncDesc(0)) { if (func.memid == 0x60000000 && func.elemdescFunc.tdesc.vt == (int)VarEnum.VT_VOID && func.cParams == 2 && func.GetElemDesc(0).tdesc.vt == (int)VarEnum.VT_PTR && func.GetElemDesc(1).tdesc.vt == (int)VarEnum.VT_PTR && "QueryInterface" == type.GetDocumentation(func.memid)) { nIndex = 3; } } if (attr.cFuncs >= 7) { using (FuncDesc func = type.GetFuncDesc(3)) { // Check IDispatch if (func.memid == 0x60010000 && func.elemdescFunc.tdesc.vt == (int)VarEnum.VT_VOID && func.cParams == 1 && func.GetElemDesc(0).tdesc.vt == (int)VarEnum.VT_PTR && "GetTypeInfoCount" == type.GetDocumentation(func.memid)) { nIndex = 7; } } } } return(nIndex); }
/*------------------------- public set and get methods --------------------------*/ /// <summary> /// Add a class which is declared public in this external module of /// THIS assembly. This class will be exported from this assembly. /// The ilasm syntax for this is .extern class /// </summary> /// <param name="attrSet">attributes of the class to be exported</param> /// <param name="nsName">name space name</param> /// <param name="name">external class name</param> /// <param name="declFile">the file where the class is declared</param> /// <param name="isValueClass">is this class a value type?</param> /// <returns>a descriptor for this external class</returns> public ClassRef AddExternClass(TypeAttr attrSet, string nsName, string name, bool isValueClass, PEFile pefile) { Contract.Requires(nsName != null); Contract.Requires(name != null); Contract.Requires(pefile != null); ClassRef cRef = new ClassRef(this, nsName, name); if (isValueClass) { cRef.MakeValueClass(); } ExternClass eClass = new ExternClass(attrSet, nsName, name, modFile); exportedClasses.Add(eClass); cRef.SetExternClass(eClass); classes.Add(cRef); return(cRef); }
////////////////////////////////////////////////////////////////////////// // Emit ////////////////////////////////////////////////////////////////////////// public static void emit(Emitter emitter, FPod pod) { //FPodEmit emit = new FPodEmit(pod); TypeAttr tattr = TypeAttr.Public | TypeAttr.Sealed; FieldAttr fattr = FieldAttr.Public | FieldAttr.Static; emitter.emitClass("System.Object", FanUtil.toDotnetTypeName(pod.m_podName, "$Pod", false), new string[0], tattr); pod.readLiterals(); // generate constant fields other types will reference, we don't // initialize them, rather we do that later via reflection for (int i = 0; i < pod.m_literals.m_ints.size(); i++) { emitter.emitField("I" + i, "System.Int64", fattr); } for (int i = 0; i < pod.m_literals.m_floats.size(); i++) { emitter.emitField("F" + i, "System.Double", fattr); } for (int i = 0; i < pod.m_literals.m_decimals.size(); i++) { emitter.emitField("D" + i, "Fan.Sys.BigDecimal", fattr); } for (int i = 0; i < pod.m_literals.m_strs.size(); i++) { emitter.emitField("S" + i, "System.String", fattr); } for (int i = 0; i < pod.m_literals.m_durations.size(); i++) { emitter.emitField("Dur" + i, "Fan.Sys.Duration", fattr); } for (int i = 0; i < pod.m_literals.m_uris.size(); i++) { emitter.emitField("U" + i, "Fan.Sys.Uri", fattr); } }
public override List <string> GetAttributes() { var lprops = new List <string> { $"uuid({_ta.guid})" }; var ta = new TypeAttr(_ti); if (_ta.wMajorVerNum != 0 || _ta.wMinorVerNum != 0) { lprops.Add($"version({ta.wMajorVerNum}.{ta.wMinorVerNum})"); } OWCustData.GetCustData(_ti, ref lprops); var help = _ti.GetHelpDocumentationById(-1, out var context); AddHelpStringAndContext(lprops, help, context); if (0 == (_ta.wTypeFlags & TypeAttr.TypeFlags.TYPEFLAG_FCANCREATE)) { lprops.Add("noncreatable"); } return(lprops); }
public ClassRef AddExternClass(string ns, string name, TypeAttr attrs, MetaDataElement declRef) { return new ExternClassRef (attrs, ns, name, declRef, metaData); }
internal ClassDef(TypeAttr attrSet, string nsName, string name, MetaData md) : base(nsName, name, md) { metaData = md; superType = metaData.mscorlib.GetSpecialSystemClass(PrimitiveType.Object); flags = (uint)attrSet; tabIx = MDTable.TypeDef; }
/// <summary> /// Add a nested class to this class /// </summary> /// <param name="attrSet">attributes for this nested class</param> /// <param name="nsName">nested name space name</param> /// <param name="name">nested class name</param> /// <returns>a descriptor for this new nested class</returns> public ClassDef AddNestedClass(TypeAttr attrSet, string nsName, string name) { ClassDef nClass = new ClassDef(attrSet,"",name,metaData); metaData.AddToTable(MDTable.TypeDef,nClass); metaData.AddToTable(MDTable.NestedClass,new MapElem(nClass,Row,MDTable.TypeDef)); nClass.parentClass = this; return (nClass); }
/*------------------------- public set and get methods --------------------------*/ /// <summary> /// Add a class to this Module /// If this class already exists, throw an exception /// </summary> /// <param name="attrSet">attributes of this class</param> /// <param name="nsName">name space name</param> /// <param name="name">class name</param> /// <returns>a descriptor for this new class</returns> public ClassDef AddClass(TypeAttr attrSet, string nsName, string name) { //FIXME Contract.Requires(classes != null); ClassDef aClass = GetClass(nsName, name); if (aClass != null) throw new DescriptorException("Class " + aClass.NameString()); aClass = new ClassDef((PEFile)this, attrSet, nsName, name); classes.Add(aClass); return aClass; }
public void AddClass (string name, TypeAttr ta, string assemblyReference) { if (class_table == null) class_table = new List<ExternClass> (); class_table.Add (new ExternClass (name, ta, assemblyReference)); }
internal ClassDef(TypeAttr attrSet, string nsName, string name, MetaData md) : base(nsName, name, md) { metaData = md; if (! ((nsName == "" && name == "<Module>") || (nsName == "System" && name == "Object")) ) { superType = metaData.mscorlib.GetSpecialSystemClass(PrimitiveType.Object); } flags = (uint)attrSet; tabIx = MDTable.TypeDef; }
/// <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); }
public void BeginTypeDef (TypeAttr attr, string name, BaseClassRef parent, ArrayList impl_list, Location location, GenericParameters gen_params) { TypeDef outer = null; string cache_name = CacheName (name); if (typedef_stack_top > 0) { StringBuilder sb = new StringBuilder (); for (int i = 0; i < typedef_stack_top; i++){ outer = (TypeDef) typedef_stack [i]; if (i == 0) /* Use FullName for outermost class to get the namespace also */ sb.Append (outer.FullName); else sb.Append (outer.Name); sb.Append ("/"); } sb.Append (name); cache_name = sb.ToString (); } TypeDef typedef = type_manager[cache_name]; if (typedef != null) { // Class head is allready defined, we are just reopening the class current_customattrtarget = current_typedef = typedef; current_declsectarget = typedef; typedef_stack.Add (current_typedef); typedef_stack_top++; return; } typedef = new TypeDef (attr, current_namespace, name, parent, impl_list, location, gen_params, outer); type_manager[cache_name] = typedef; current_customattrtarget = current_typedef = typedef; current_declsectarget = typedef; typedef_stack.Add (typedef); typedef_stack_top++; }
/*-------------------- Constructors ---------------------------------*/ internal NestedClassDef(ClassDef parent, TypeAttr attrSet, string name) : base(parent.GetScope(), attrSet, "", name) { this.parent = parent; }
/// <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> /// <returns>a descriptor for this new nested class</returns> public NestedClassDef AddNestedClass(TypeAttr attrSet, string name) { NestedClassDef nClass = GetNestedClass(name); if (nClass != null) throw new DescriptorException("Nested Class " + nClass.NameString()); nClass = new NestedClassDef(this, attrSet, name); nestedClasses.Add(nClass); return (nClass); }
internal ExternClass(TypeAttr attr, uint nsIx, uint nIx, MetaDataElement paren) : base(nsIx,nIx) { flags = (uint)attr; parent = paren; tabIx = MDTable.ExportedType; }
/// <summary> /// Add a class which extends System.ValueType to this Module /// If this class already exists, throw an exception /// </summary> /// <param name="attrSet">attributes of this class</param> /// <param name="nsName">name space name</param> /// <param name="name">class name</param> /// <returns>a descriptor for this new class</returns> public ClassDef AddValueClass(TypeAttr attrSet, string nsName, string name) { ClassDef aClass = AddClass(attrSet, nsName, name); aClass.SuperType = MSCorLib.mscorlib.ValueType(); aClass.MakeValueClass(); return 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; }
/// <summary> /// Add a class which extends System.ValueType to this module /// </summary> /// <param name="attrSet">attributes of this class</param> /// <param name="nsName">name space name</param> /// <param name="name">class name</param> /// <returns>a descriptor for this new class</returns> public ClassDef AddValueClass(TypeAttr attrSet, string nsName, string name, ValueClass vClass) { ClassDef aClass = new ClassDef(attrSet,nsName,name,metaData); aClass.MakeValueClass(vClass); aClass.SetTypeIndex (PrimitiveType.ValueType.GetTypeIndex ()); metaData.AddToTable(MDTable.TypeDef,aClass); return aClass; }
internal ExternClassRef(TypeAttr attrs, string nsName, string name, FileRef declFile, MetaData md) : base(nsName,name,md) { externClass = new ExternClass(attrs,nameSpaceIx,nameIx,declFile); metaData.AddToTable(MDTable.ExportedType,externClass); }
/// <summary> /// Add a class to this module /// </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 = new ClassDef(attrSet,nsName,name,metaData); aClass.SetSuper(superType); metaData.AddToTable(MDTable.TypeDef,aClass); return aClass; }
/// <summary> /// Set the attributes of this class /// </summary> /// <param name="ta">class attributes</param> public void SetAttribute(TypeAttr ta) { flags = (uint)ta; }
public ExternClass (string fullName, TypeAttr ta, string assemblyReference) { this.fullName = fullName; this.ta = ta; this.assemblyReference = assemblyReference; }
/// <summary> /// Add a class to this module /// </summary> /// <param name="attrSet">attributes of this class</param> /// <param name="nsName">name space name</param> /// <param name="name">class name</param> /// <returns>a descriptor for this new class</returns> public ClassDef AddClass(TypeAttr attrSet, string nsName, string name) { return AddClass (attrSet, nsName, name, null); }
public OWInheritedInterfaces(ITlibNode parent, ITypeInfo ti, TypeAttr ta) { Parent = parent; _ta = ta; _ti = ti; }
/// <summary> /// Add a class which extends System.ValueType to this module /// </summary> /// <param name="attrSet">attributes of this class</param> /// <param name="nsName">name space name</param> /// <param name="name">class name</param> /// <returns>a descriptor for this new class</returns> public ClassDef AddValueClass(TypeAttr attrSet, string nsName, string name, ValueClass vClass) { ClassDef aClass = new ClassDef(attrSet,nsName,name,metaData); if (!ClassDef.IsValueType (nsName, name) && !ClassDef.IsEnum (nsName, name)) { aClass.MakeValueClass(vClass); } else { if (ClassDef.IsEnum (nsName, name)) aClass.SetSuper (metaData.mscorlib.ValueType ()); else aClass.SetSuper (metaData.mscorlib.GetSpecialSystemClass (PrimitiveType.Object)); metaData.mscorlib.SetSpecialSystemClass (nsName, name, aClass); } aClass.SetTypeIndex (PrimitiveType.ValueType.GetTypeIndex ()); metaData.AddToTable(MDTable.TypeDef,aClass); return aClass; }
/// <summary> /// Add an attribute to this class /// </summary> /// <param name="ta">the attribute to be added</param> public void AddAttribute(TypeAttr ta) { flags |= (uint)ta; }
/// <summary> /// Add a class to this module /// </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 = new ClassDef(attrSet,nsName,name,metaData); if (superType != null) aClass.SetSuper(superType); if (PEFile.IsMSCorlib) metaData.mscorlib.SetSpecialSystemClass (nsName, name, aClass); metaData.AddToTable(MDTable.TypeDef,aClass); return aClass; }
/// <summary> /// Add a nested class to this class /// </summary> /// <param name="attrSet">attributes for this nested class</param> /// <param name="nsName">nested name space name</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 ClassDef AddNestedClass(TypeAttr attrSet, string nsName, string name, Class sType) { ClassDef nClass = AddNestedClass (attrSet, nsName, name); nClass.SetSuper(sType); if (ClassDef.IsValueType (sType)) nClass.MakeValueClass (ValueClass.ValueType); else if (ClassDef.IsEnum (sType)) nClass.MakeValueClass (ValueClass.Enum); if (ClassDef.IsValueType (sType) || ClassDef.IsEnum (sType)) nClass.SetTypeIndex (PrimitiveType.ValueType.GetTypeIndex ()); nClass.typeIndexChecked = true; return (nClass); }
public ClassTable (PEFile pefile) { DefaultAttr = TypeAttr.Public; this.pefile = pefile; table = new Hashtable (); }
public ClassRef AddNestedClass(TypeAttr attrs, string name) { ExternClassRef nestedClass = new ExternClassRef(name,metaData); externClass = new ExternClass(attrs,0,nameIx,this.externClass); metaData.AddToTable(MDTable.ExportedType,externClass); return nestedClass; }
public ClassDef AddDefinition (string name_space, string name, TypeAttr attr, Location location) { string full_name; if (name_space != null) full_name = String.Format ("{0}.{1}", name_space, name); else full_name = name; ClassTableItem item = (ClassTableItem) table[full_name]; if (item == null) { ClassDef klass = pefile.AddClass (attr, name_space, name); AddDefined (full_name, klass, location); return klass; } item.Class.AddAttribute (attr); item.Defined = true; return item.Class; }
/// <summary> /// Add a class which is declared public in this external module of /// THIS assembly. This class will be exported from this assembly. /// The ilasm syntax for this is .extern class /// </summary> /// <param name="attrSet">attributes of the class to be exported</param> /// <param name="nsName">name space name</param> /// <param name="name">external class name</param> /// <param name="declFile">the file where the class is declared</param> /// <param name="isValueClass">is this class a value type?</param> /// <returns>a descriptor for this external class</returns> public ExternClassRef AddExternClass(TypeAttr attrSet, string nsName, string name, FileRef declFile, bool isValueClass) { ExternClassRef cRef = new ExternClassRef(attrSet,nsName,name,declFile,metaData); metaData.AddToTable(MDTable.TypeRef,cRef); cRef.SetParent(this); if (isValueClass) cRef.MakeValueClass(ValueClass.ValueType); return cRef; }
public ClassDef AddDefinition (string name_space, string name, TypeAttr attr, Class parent, Location location) { string full_name; if (name_space != null) full_name = String.Format ("{0}.{1}", name_space, name); else full_name = name; ClassTableItem item = (ClassTableItem) table[full_name]; if (item == null) { ClassDef klass = pefile.AddClass (attr, name_space, name, parent); AddDefined (full_name, klass, location); return klass; } /// TODO: Need to set parent, will need to modify PEAPI for this. item.Class.AddAttribute (attr); item.Defined = true; return item.Class; }