|
public static OutputAttributes ( |
||
| doc | ||
| parent | ||
| attributes | IList |
|
| 리턴 | void | |
public static void OutputGenericParameters(XmlDocument document, XmlNode nclass, IGenericParameterProvider provider)
{
if (provider.GenericParameters.Count == 0)
{
return;
}
var gparameters = provider.GenericParameters;
XmlElement ngeneric = document.CreateElement(string.Format("generic-parameters"));
nclass.AppendChild(ngeneric);
foreach (GenericParameter gp in gparameters)
{
XmlElement nparam = document.CreateElement(string.Format("generic-parameter"));
nparam.SetAttribute("name", gp.Name);
nparam.SetAttribute("attributes", ((int)gp.Attributes).ToString());
AttributeData.OutputAttributes(document, nparam, gp.CustomAttributes);
ngeneric.AppendChild(nparam);
var constraints = gp.Constraints;
if (constraints.Count == 0)
{
continue;
}
XmlElement nconstraint = document.CreateElement("generic-parameter-constraints");
foreach (TypeReference constraint in constraints)
{
XmlElement ncons = document.CreateElement("generic-parameter-constraint");
ncons.SetAttribute("name", Utils.CleanupTypeName(constraint));
nconstraint.AppendChild(ncons);
}
nparam.AppendChild(nconstraint);
}
}
public override void DoOutput()
{
XmlNode parametersNode = document.CreateElement("parameters");
parent.AppendChild(parametersNode);
foreach (ParameterDefinition parameter in parameters)
{
XmlNode paramNode = document.CreateElement("parameter");
parametersNode.AppendChild(paramNode);
AddAttribute(paramNode, "name", parameter.Name);
AddAttribute(paramNode, "position", parameter.Method.Parameters.IndexOf(parameter).ToString(CultureInfo.InvariantCulture));
AddAttribute(paramNode, "attrib", ((int)parameter.Attributes).ToString());
string direction = "in";
if (parameter.ParameterType is ByReferenceType)
{
direction = parameter.IsOut ? "out" : "ref";
}
TypeReference t = parameter.ParameterType;
AddAttribute(paramNode, "type", Utils.CleanupTypeName(t));
if (parameter.IsOptional)
{
AddAttribute(paramNode, "optional", "true");
if (parameter.HasConstant)
{
AddAttribute(paramNode, "defaultValue", parameter.Constant == null ? "NULL" : parameter.Constant.ToString());
}
}
if (direction != "in")
{
AddAttribute(paramNode, "direction", direction);
}
AttributeData.OutputAttributes(document, paramNode, parameter.CustomAttributes);
}
}
public override void DoOutput()
{
XmlNode mclass = document.CreateElement(ParentTag, null);
parent.AppendChild(mclass);
foreach (MemberReference member in members)
{
XmlNode mnode = document.CreateElement(Tag, null);
mclass.AppendChild(mnode);
AddAttribute(mnode, "name", GetName(member));
if (!NoMemberAttributes)
{
AddAttribute(mnode, "attrib", GetMemberAttributes(member));
}
AttributeData.OutputAttributes(document, mnode, GetCustomAttributes(member));
AddExtraData(mnode, member);
}
}
protected override void AddExtraData(XmlNode p, MemberReference memberDefenition)
{
base.AddExtraData(p, memberDefenition);
if (!(memberDefenition is MethodDefinition))
{
return;
}
MethodDefinition mbase = (MethodDefinition)memberDefenition;
ParameterData parms = new ParameterData(document, p, mbase.Parameters);
parms.DoOutput();
if (mbase.IsAbstract)
{
AddAttribute(p, "abstract", "true");
}
if (mbase.IsVirtual)
{
AddAttribute(p, "virtual", "true");
}
if (mbase.IsStatic)
{
AddAttribute(p, "static", "true");
}
string rettype = Utils.CleanupTypeName(mbase.MethodReturnType.ReturnType);
if (rettype != "System.Void" || !mbase.IsConstructor)
{
AddAttribute(p, "returntype", (rettype));
}
AttributeData.OutputAttributes(document, p, mbase.MethodReturnType.CustomAttributes);
MemberData.OutputGenericParameters(document, p, mbase);
}
public override void DoOutput()
{
if (document == null)
{
throw new InvalidOperationException("Document not set");
}
XmlNode nclass = document.CreateElement("class", null);
AddAttribute(nclass, "name", type.Name);
string classType = GetClassType(type);
AddAttribute(nclass, "type", classType);
if (type.BaseType != null)
{
AddAttribute(nclass, "base", Utils.CleanupTypeName(type.BaseType));
}
if (type.IsSealed)
{
AddAttribute(nclass, "sealed", "true");
}
if (type.IsAbstract)
{
AddAttribute(nclass, "abstract", "true");
}
if ((type.Attributes & TypeAttributes.Serializable) != 0 || type.IsEnum)
{
AddAttribute(nclass, "serializable", "true");
}
string charSet = GetCharSet(type);
AddAttribute(nclass, "charset", charSet);
string layout = GetLayout(type);
if (layout != null)
{
AddAttribute(nclass, "layout", layout);
}
if (type.PackingSize >= 0)
{
AddAttribute(nclass, "pack", type.PackingSize.ToString());
}
if (type.ClassSize >= 0)
{
AddAttribute(nclass, "size", type.ClassSize.ToString());
}
parent.AppendChild(nclass);
AttributeData.OutputAttributes(document, nclass, GetCustomAttributes(type));
XmlNode ifaces = null;
foreach (TypeReference iface in TypeHelper.GetInterfaces(type))
{
if (!TypeHelper.IsPublic(iface))
{
// we're only interested in public interfaces
continue;
}
if (ifaces == null)
{
ifaces = document.CreateElement("interfaces", null);
nclass.AppendChild(ifaces);
}
XmlNode iface_node = document.CreateElement("interface", null);
AddAttribute(iface_node, "name", Utils.CleanupTypeName(iface));
ifaces.AppendChild(iface_node);
}
MemberData.OutputGenericParameters(document, nclass, type);
ArrayList members = new ArrayList();
FieldDefinition [] fields = GetFields(type);
if (fields.Length > 0)
{
Array.Sort(fields, MemberReferenceComparer.Default);
FieldData fd = new FieldData(document, nclass, fields);
members.Add(fd);
}
if (type.IsEnum)
{
var value_type = GetEnumValueField(type);
if (value_type == null)
{
throw new NotSupportedException();
}
AddAttribute(nclass, "enumtype", Utils.CleanupTypeName(value_type.FieldType));
}
if (!Driver.AbiMode)
{
MethodDefinition [] ctors = GetConstructors(type);
if (ctors.Length > 0)
{
Array.Sort(ctors, MemberReferenceComparer.Default);
members.Add(new ConstructorData(document, nclass, ctors));
}
PropertyDefinition[] properties = GetProperties(type);
if (properties.Length > 0)
{
Array.Sort(properties, MemberReferenceComparer.Default);
members.Add(new PropertyData(document, nclass, properties));
}
EventDefinition [] events = GetEvents(type);
if (events.Length > 0)
{
Array.Sort(events, MemberReferenceComparer.Default);
members.Add(new EventData(document, nclass, events));
}
MethodDefinition [] methods = GetMethods(type);
if (methods.Length > 0)
{
Array.Sort(methods, MemberReferenceComparer.Default);
members.Add(new MethodData(document, nclass, methods));
}
}
foreach (MemberData md in members)
{
md.DoOutput();
}
var nested = type.NestedTypes;
//remove non public(familiy) and nested in second degree
for (int i = nested.Count - 1; i >= 0; i--)
{
TypeDefinition t = nested [i];
if ((t.Attributes & TypeAttributes.VisibilityMask) == TypeAttributes.NestedPublic ||
(t.Attributes & TypeAttributes.VisibilityMask) == TypeAttributes.NestedFamily ||
(t.Attributes & TypeAttributes.VisibilityMask) == TypeAttributes.NestedFamORAssem)
{
// public
if (t.DeclaringType == type)
{
continue; // not nested of nested
}
}
nested.RemoveAt(i);
}
if (nested.Count > 0)
{
XmlNode classes = document.CreateElement("classes", null);
nclass.AppendChild(classes);
foreach (TypeDefinition t in nested)
{
TypeData td = new TypeData(document, classes, t);
td.DoOutput();
}
}
}
public override void DoOutput()
{
if (document == null)
{
throw new InvalidOperationException("Document not set");
}
XmlNode nassembly = document.CreateElement("assembly", null);
AssemblyNameDefinition aname = ass.Name;
AddAttribute(nassembly, "name", aname.Name);
AddAttribute(nassembly, "version", aname.Version.ToString());
parent.AppendChild(nassembly);
TypeForwardedToData.OutputForwarders(document, nassembly, ass);
AttributeData.OutputAttributes(document, nassembly, ass.CustomAttributes);
var typesCollection = ass.MainModule.Types;
if (typesCollection == null || typesCollection.Count == 0)
{
return;
}
object [] typesArray = new object [typesCollection.Count];
for (int i = 0; i < typesCollection.Count; i++)
{
typesArray [i] = typesCollection [i];
}
Array.Sort(typesArray, TypeReferenceComparer.Default);
XmlNode nss = document.CreateElement("namespaces", null);
nassembly.AppendChild(nss);
string current_namespace = "$%&$&";
XmlNode ns = null;
XmlNode classes = null;
foreach (TypeDefinition t in typesArray)
{
if (string.IsNullOrEmpty(t.Namespace))
{
continue;
}
if (!Driver.AbiMode && ((t.Attributes & TypeAttributes.VisibilityMask) != TypeAttributes.Public))
{
continue;
}
if (t.DeclaringType != null)
{
continue; // enforce !nested
}
if (t.Namespace != current_namespace)
{
current_namespace = t.Namespace;
ns = document.CreateElement("namespace", null);
AddAttribute(ns, "name", current_namespace);
nss.AppendChild(ns);
classes = document.CreateElement("classes", null);
ns.AppendChild(classes);
}
TypeData bd = new TypeData(document, classes, t);
bd.DoOutput();
}
}