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;
}
/*-------------------- Constructors ---------------------------------*/
internal ExternClass(TypeAttr attr, string ns, string name, MetaDataElement paren)
{
flags = (uint)attr;
NameSpace = ns;
this.Name = name;
implementation = paren;
tabIx = MDTable.ExportedType;
}
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;
}
