public EnumDef AddEnum(string name, BaseType t) { if (!t.IsInteger()) { throw new InvalidEnumArgumentException("Underlying enum type must be integral."); } var def = new EnumDef { Name = name, IsUnion = t == BaseType.UType, TypeBuilder = this, }; if (Enums.Add(name, def)) { throw new Exception("enum already exists!"); } def.UnderlyingType.BaseType = t; def.UnderlyingType.EnumDef = def; if (def.IsUnion) { def.Values.Add("NONE", new EnumVal { Name = "NONE", Value = 0, }); } return(def); }
static bool Crawl(Type type) { foreach (var member in type.GetEffectiveProperties()) { var memberType = GetDefinableType(member.GetPropertyOrFieldType()); if (memberType == null || All.Contains(memberType)) { continue; } if (memberType.IsEnum) { if (Enums.Lacks(memberType)) { Enums.Add(memberType); } } else { All.Add(memberType); return(true); } } return(false); }
public void Build() { foreach (INamedTypeSymbol symbol in GetSymbolsForNativeApi()) { if (symbol.TypeKind == TypeKind.Enum) { Enums.Add(symbol.Name, symbol); continue; } if (IsRefCountedTypeSymbol(symbol)) { RefCounted.Add(symbol.Name, symbol); continue; } if (IsScopedTypeSymbol(symbol)) { Scoped.Add(symbol.Name, symbol); continue; } if (symbol.TypeKind != TypeKind.Struct) { continue; } if (IsSizedStruct(symbol)) { Sized.Add(symbol.Name, symbol); continue; } Simple.Add(symbol.Name, symbol); } }
private void AddEnum(ITypeDefinition enm, StringBuilder key) { if (enm.Namespace == "") { lock (Enums) { foreach (var typeArg in enm.TypeParameters) { foreach (var constraint in typeArg.DirectBaseTypes) { key.Append(constraint.Name); } } if (Enums.ContainsKey(key.ToString())) { return; } Enums.Add(key.ToString(), new EnumProperties(enm)); } } else { AddNamespace(key, enm); } }
private void DetectElementsInFile(CodeElements elements) { foreach (CodeElement element in elements) { if (element is CodeClass) { Classes.Add(element as CodeClass); } if (element is CodeEnum) { Enums.Add(element as CodeEnum); } if (element is CodeStruct) { Structs.Add(element as CodeStruct); } if (element is CodeInterface) { Interfaces.Add(element as CodeInterface); } DetectElementsInFile(element.Children); } }
public Enumeration FindEnum(string name, bool createDecl = false) { var entries = name.Split(new string[] { "::" }, StringSplitOptions.RemoveEmptyEntries).ToList(); if (entries.Count <= 1) { var @enum = Enums.Find(e => e.Name.Equals(name)); if (@enum == null && createDecl) { @enum = new Enumeration() { Name = name, Namespace = this }; Enums.Add(@enum); } return(@enum); } var enumName = entries[entries.Count - 1]; var namespaces = entries.Take(entries.Count - 1); var @namespace = FindNamespace(namespaces); if (@namespace == null) { return(null); } return(@namespace.FindEnum(enumName, createDecl)); }
public override bool VisitEnumDeclaration([NotNull] JavaParser.EnumDeclarationContext context) { ++EnumCounter; Enums.Add(context.IDENTIFIER().GetText()); return(true); }
private void ApplyGlVersion(GlVersion glVersion) { foreach (GlEnum glEnum in glVersion.AddedEnums) { if (!Enums.Contains(glEnum)) { Enums.Add(glEnum); } } foreach (GlFunction glFunction in glVersion.AddedFunctions) { if (!Functions.Contains(glFunction)) { Functions.Add(glFunction); } } if (HasProfiles) { if (Profile == GlProfile.Core) { ApplyCoreProfile(glVersion); } else if (Profile == GlProfile.Compatibility) { ApplyCompatibilityProfile(glVersion); } } }
public PackageBuilder Enum(string name, Type type, Action <EnumBuilder> configure) { var enumBuilder = new EnumBuilder(Context, name, source: type); configure(enumBuilder); Enums.Add(enumBuilder); return(this); }
public void ImportCodeEnum <TEnum>(string enumName) where TEnum : struct, IComparable, IFormattable, IConvertible { Contract.Requires(!string.IsNullOrEmpty(enumName)); Contract.Requires(Actions.Count == 0, "Why are you importing an Enum after the DB has been loaded?"); var script_enum = MegaloScriptEnum.ForEnum <TEnum>(enumName); Enums.Add(script_enum); }
/// <summary> /// Creates an enum builder /// </summary> /// <param name="Name">Name of the enum</param> /// <param name="EnumBaseType">Base type of the enum (defaults to int)</param> /// <param name="Attributes">Attributes associated with the type</param> /// <returns>An EnumBuilder class</returns> public virtual EnumBuilder CreateEnum(string Name, Type EnumBaseType = null, TypeAttributes Attributes = TypeAttributes.Public) { if (EnumBaseType == null) { EnumBaseType = typeof(int); } EnumBuilder ReturnValue = new EnumBuilder(this, Name, EnumBaseType, Attributes); Enums.Add(ReturnValue); return(ReturnValue); }
/// <summary> /// Creates an enum builder /// </summary> /// <param name="name">name of the enum</param> /// <param name="enumBaseType">Base type of the enum (defaults to int)</param> /// <param name="attributes">Attributes associated with the type</param> /// <returns>An EnumBuilder class</returns> public virtual EnumBuilder CreateEnum(string name, Type enumBaseType = null, TypeAttributes attributes = TypeAttributes.Public) { if (enumBaseType == null) { enumBaseType = typeof(int); } var returnValue = new EnumBuilder(this, name, enumBaseType, attributes); Enums.Add(returnValue); return(returnValue); }
private void ApplyCoreProfile(GlVersion glVersion) { foreach (GlEnum glEnum in glVersion.AddedCoreEnums) { if (!Enums.Contains(glEnum)) { Enums.Add(glEnum); } } Enums.RemoveAll(glEnum => glVersion.RemovedCoreEnums.Contains(glEnum)); Functions.RemoveAll(glFunction => glVersion.RemovedCoreFunctions.Contains(glFunction)); }
/// <summary> /// Reads properties of "Enum" metadata objects /// </summary> /// <param name="connection"></param> /// <param name="conf"></param> /// <param name="ct"></param> /// <returns></returns> private async Task ReadEnumsAsync(DbConnection connection, BracketsFileNode conf, CancellationToken ct) { var objectGuids = GetMetadataObjectGuids(conf.GetNode(4, 1, 1, 17)); foreach (var objectGuid in objectGuids) { var objectInfo = BracketsFileParser.Parse(await GetStringConfigFileDataAsync(connection, objectGuid, ct)); var obj = ReadMetadataObject <OneSEnum>(objectInfo.GetNode(1, 5, 1), objectGuid); Enums.Add(obj); } }
public void Merge(ProtoCollection proto) { foreach (var m in proto.Messages.Values) { Messages.Add(m.ProtoName, m); m.Parent = this; } foreach (var e in proto.Enums.Values) { Enums.Add(e.ProtoName, e); e.Parent = this; } }
public void Merge(ProtoCollection proto) { foreach (var m in proto.Messages.Values) { Messages.Add(m.ProtoName, m); m.Parent = this; } foreach (var e in proto.Enums.Values) { Enums.Add(e.ProtoName, e); e.Parent = this; } Comments = Comments == null ? proto.Comments : Comments + "\n" + proto.Comments; }
private void AddEnumType(Type type) { if (!type.IsEnum) { throw new ArgumentOutOfRangeException(nameof(type)); } if (Enums.ContainsKey(type.Name)) { return; } Enums.Add(type.Name, Enum.GetNames(type)); }
public void AddEnum(TypeDefinition thingType) { if (Enums.All(e => e.FullName != thingType.FullName)) { var conflictEnum = Enums.SingleOrDefault(e => e.Name == thingType.Name); if (conflictEnum == null) { Enums.Add(thingType); } else { LogMessages[thingType.Name] = $"Enum [{thingType.Name}] of type [{thingType.FullName}] conflicts with [{conflictEnum.FullName}]"; } } }
/// <summary> /// Handles updating the form to match the selected data model property /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void UpdateForm(object sender, PropertyChangedEventArgs e) { if (e.PropertyName != "SelectedDataModelProp") { return; } Operators.Clear(); Enums.Clear(); UserValueIsVisible = false; EnumValueIsVisible = false; switch (SelectedDataModelProp.Type) { case "Int32": case "Single": Operators.AddRange(_int32Operators); UserValueIsVisible = true; break; case "Boolean": Operators.AddRange(_boolOperators); Enums.Add("True"); Enums.Add("False"); EnumValueIsVisible = true; break; case "String": Operators.AddRange(_stringOperators); UserValueIsVisible = true; break; default: Operators.AddRange(_operators); UserValueIsVisible = true; break; } // Setup Enum selection if needed if (SelectedDataModelProp.EnumValues != null) { Enums.AddRange(SelectedDataModelProp.EnumValues); EnumValueIsVisible = true; } SelectedOperator = Operators.First(); }
/// <summary> /// Merges another compilation model into this one. /// </summary> /// <param name="model">The model to merge from.</param> public void Merge(CompilationModel model) { foreach (var item in model.Enums) { Enums.Add(item); } foreach (var item in model.Classes) { Classes.Add(item); } foreach (var item in model.GlobalStatements) { GlobalStatements.Add(item); } }
private void ApplyCompatibilityProfile(GlVersion glVersion) { foreach (GlEnum glEnum in glVersion.AddedCompatibilityEnums) { if (!Enums.Contains(glEnum)) { Enums.Add(glEnum); } } foreach (GlFunction glFunction in glVersion.AddedCompatibilityFunctions) { if (!Functions.Contains(glFunction)) { Functions.Add(glFunction); } } }
public void SetupPropertyInput() { Operators.Clear(); Enums.Clear(); switch (SelectedDataModelProp.Type) { case "Int32": case "Single": Operators.AddRange(_int32Operators); UserValueIsVisible = true; break; case "Boolean": Operators.AddRange(_boolOperators); Enums.Add("True"); Enums.Add("False"); EnumValueIsVisible = true; break; case "String": Operators.AddRange(_stringOperators); UserValueIsVisible = true; break; default: Operators.AddRange(_operators); UserValueIsVisible = true; break; } // Add Changed operator is the type is event if (_editorViewModel.ProposedLayer.IsEvent) { Operators.Add(new NamedOperator("Changed", "changed")); // Also add decreased and increased operator on numbers if (SelectedDataModelProp.Type == "Int32" || SelectedDataModelProp.Type == "Single") { Operators.Add(new NamedOperator("Decreased", "decreased")); Operators.Add(new NamedOperator("Increased", "increased")); } } SetupUserValueInput(); }
private void AddEnum(IType enm, StringBuilder key) { lock (Enums) { foreach (var typeArg in enm.TypeParameters) { foreach (var constraint in typeArg.Constraints) { key.Append(constraint.Name); } } if (Enums.ContainsKey(key.ToString())) { return; } Enums.Add(key.ToString(), new EnumProperties(enm)); } }
IEnumeration IDeclarationContext.FindEnum(string Name, bool Create) { var entries = Name.Split(new[] { "::" }, StringSplitOptions.None); if (entries.Length == 1) { var foundEnum = Enums.FirstOrDefault((e) => e.Name == Name); if (foundEnum != null) { return(foundEnum); } if (!Create) { return(null); } var _enum = new Enumeration(); _enum.Name = Name; _enum.Namespace = this; Enums.Add(_enum); return(_enum); } var enumName = entries[entries.Length - 1]; var namespaces = new string[entries.Length - 1]; for (int i = 0; i < namespaces.Length; i++) { namespaces[i] = entries[i]; } var _namespace = FindNamespace(namespaces); if (_namespace == null) { return(null); } return(_namespace.FindEnum(enumName, Create)); }
public PropertyCtrlViewModel(string name, EnumProperty property) { Name = name; IntSliderShow = Visibility.Collapsed; FloatSliderShow = Visibility.Collapsed; ComboBoxShow = Visibility.Visible; FileManagerShow = Visibility.Collapsed; TableViewShow = Visibility.Collapsed; EnumNameStr = Name; foreach (var el in property.Values) { Enums.Add(new ComboBoxItem() { Content = el.Key }); } if (Enums.Count > 0) { SelectEnum = Enums[0]; foreach (var en in Enums) { if (en.Content.ToString() == property.ToString()) { SelectEnum = en; break; } } } OnUpdateEnum += (string content) => { property.Set(content); if (OnUpdateImg != null) { OnUpdateImg(this); } }; }
public void Add(Types.Enum e) { Enums.Add(e); // check duplicate }
public void AddEnum(IEnumeration value) { Enums.Add((Enumeration)value); }
void LoadTypes(XmlNode root) { foreach (XmlNode node in root.ChildNodes) { if (node is XmlComment) { continue; } if (node.Attributes["requires"] != null && node.ChildNodes.Count == 0) { } if (node.Attributes["category"] != null) { string cat = node.Attributes["category"].Value; if (cat == "union" || cat == "struct") { string name = node.Attributes["name"].Value; bool union = cat == "union"; List <Field> fields = new List <Field>(); foreach (XmlNode fNode in node.ChildNodes) { if (fNode is XmlComment) { continue; } if (fNode.Name == "comment") { continue; } if (fNode.Name == "validity") { continue; } LoadField(fNode, fields); } var s = new Struct(name, fields, union); Structs.Add(s); StructMap.Add(name, s); } else if (cat == "handle") { if (node.Attributes["alias"] != null) { continue; } string name = node["name"].InnerText; List <Field> fields = new List <Field>(); var s = new Struct(name, fields, false); s.Handle = true; if (node["type"].InnerText == "VK_DEFINE_HANDLE") { fields.Add(new Field("native", "IntPtr", false, null)); } else { fields.Add(new Field("native", "ulong", false, null)); } Structs.Add(s); StructMap.Add(name, s); } else if (cat == "enum") { if (node.Attributes["alias"] != null) { continue; } var eName = node.Attributes["name"].Value; if (!EnumMap.ContainsKey(eName)) { var e = new Enum(eName, false); EnumMap.Add(eName, e); Enums.Add(e); AllEnums.Add(eName); } } else if (cat == "bitmask") { if (node.Attributes["alias"] != null) { continue; } var eName = node["name"].InnerText; if (!EnumMap.ContainsKey(eName)) { var e = new Enum(eName, true); EnumMap.Add(eName, e); Enums.Add(e); AllEnums.Add(eName); } } } } }
/// <summary> /// Parses an XML string to a new Easy Base System. /// </summary> /// <remarks>Generator step 1.</remarks> /// <param name="xmlString">The XML string.</param> private void ParseXml(string xmlString) { // Read all entity names (singular and plural) XmlReader reader = XmlReader.Create(new StringReader(xmlString)); XDocument doc = XDocument.Load(reader); var entityNames = (from entity in doc.Descendants("Entity") select new { NameSingular = entity.Attribute("NameSingular").Value, NamePlural = entity.Attributes("NamePlural").Count() > 0 ? entity.Attribute("NamePlural").Value : ToPlural(entity.Attribute("NameSingular").Value) }).ToList(); reader.Close(); reader = XmlReader.Create(new StringReader(xmlString)); // Read Enums doc = XDocument.Load(reader); var enums = (from e in doc.Descendants("Enum") select e).ToList(); // Create all global enums foreach (var e in enums) { string enumName = e.Attribute("Name").Value; Enums.Add(new GlobalEnum(enumName)); var values = (from v in e.Descendants() select v).ToList(); // Create all possible values for current enum foreach (var value in values) { Enums[enumName].Values.Add(value.Value); } } reader.Close(); reader = XmlReader.Create(new StringReader(xmlString)); // Read Entities while (reader.ReadToFollowing("Entity")) { string nameSingular = ""; string namePlural = ""; bool isView = false; List <Field> fields = new List <Field>(); List <UniqueKey> uniqueKeys = new List <UniqueKey>(); List <string> parentNames = new List <string>(); while (reader.MoveToNextAttribute()) { string attributeName = reader.Name; switch (attributeName) { case "NameSingular": nameSingular = reader.Value; if (namePlural == "") { namePlural = ToPlural(nameSingular); } break; case "NamePlural": namePlural = reader.Value; break; case "IsView": isView = (reader.Value.ToLower() == "true"); break; default: throw new NotImplementedException("'" + attributeName + "' on entity '" + nameSingular + "' is not a valid entity attribute."); } } if (nameSingular == "") { throw new ApplicationException("Entity must have a name."); } while (reader.Read() && reader.NodeType != XmlNodeType.Element && reader.NodeType != XmlNodeType.EndElement) { ; } if (reader.NodeType != XmlNodeType.EndElement && !reader.EOF) { if (reader.Name == "Fields") { while (reader.Read() && reader.NodeType != XmlNodeType.Element && reader.NodeType != XmlNodeType.EndElement) { ; } while (reader.NodeType != XmlNodeType.EndElement && !reader.EOF) { Field field; if (reader.Name == "PrimaryKeyField") { string fieldName = ""; string fieldType = ""; bool allowNull = false; bool isIdentity = false; string[] enumValues = null; string globalEnumName = ""; while (reader.MoveToNextAttribute()) { string attributeName = reader.Name; switch (attributeName) { case "Name": fieldName = reader.Value; break; case "Type": fieldType = reader.Value; break; case "AllowNull": allowNull = Convert.ToBoolean(reader.Value); break; case "IsIdentity": isIdentity = Convert.ToBoolean(reader.Value); break; case "EnumValues": if (IsGlobalEnum(reader.Value)) { globalEnumName = reader.Value; } else { enumValues = reader.Value.Split("/".ToArray()); } break; default: throw new NotImplementedException("'" + attributeName + "' on field '" + fieldName + "' on entity '" + nameSingular + "' is not a valid primary key field attribute."); } } if (fieldName == "") { throw new ApplicationException("Primary key field for entity '" + nameSingular + "' must have a name."); } if (fieldType == "") { throw new ApplicationException("Primary key field '" + fieldName + "' on entity '" + nameSingular + "' must have a type."); } field = new PrimaryKeyField(nameSingular, fieldName, fieldType, allowNull, isIdentity); if (globalEnumName != "") { field.GlobalEnumName = globalEnumName; } else { if (enumValues != null) { field.EnumValues = enumValues; } } } else if (reader.Name == "ForeignKeyField") { string fieldName = ""; string fieldType = ""; string targetEntityName = ""; string targetFieldName = ""; bool allowNull = false; bool isParentConnection = false; List <int> uniqueKeyGroups = new List <int>(); while (reader.MoveToNextAttribute()) { string attributeName = reader.Name; switch (attributeName) { case "Name": fieldName = reader.Value; break; case "Type": fieldType = reader.Value; break; case "TargetEntity": targetEntityName = reader.Value; break; case "TargetField": targetFieldName = reader.Value; break; case "AllowNull": allowNull = Convert.ToBoolean(reader.Value); break; case "IsParentConnection": isParentConnection = Convert.ToBoolean(reader.Value); break; case "UniqueKeyGroup": string[] keyGroups = reader.Value.Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries); foreach (string sKeyGroup in keyGroups) { uniqueKeyGroups.Add(int.Parse(sKeyGroup)); } break; default: throw new NotImplementedException("'" + attributeName + "' on field '" + fieldName + "' on entity '" + nameSingular + "' is not a valid foreign key field attribute."); } } if (fieldName == "") { throw new ApplicationException("Foreign key field for entity '" + nameSingular + "' must have a name."); } if (fieldType == "") { throw new ApplicationException("Foreign key field '" + fieldName + "' on entity '" + nameSingular + "' must have a type."); } if (targetEntityName == "") { throw new ApplicationException("Foreign key field '" + fieldName + "' on entity '" + nameSingular + "' must have a target entity."); } if (targetFieldName == "") { throw new ApplicationException("Foreign key field '" + fieldName + "' on entity '" + nameSingular + "' must have a target field."); } var tableName = entityNames.Find(a => a.NameSingular == targetEntityName).NamePlural; field = new ForeignKeyField(nameSingular, fieldName, fieldType, tableName, targetFieldName, allowNull, isParentConnection, uniqueKeyGroups.ToArray()); if (isParentConnection) { parentNames.Add(targetEntityName); } if (uniqueKeyGroups.Count > 0) { foreach (int uniqueKeyGroup in uniqueKeyGroups) { AddToUniqueKeys(uniqueKeys, uniqueKeyGroup, field); } } } else if (reader.Name == "Field") { string fieldName = ""; string fieldType = ""; bool allowNull = false; List <int> uniqueKeyGroups = new List <int>(); string[] enumValues = null; string globalEnumName = ""; while (reader.MoveToNextAttribute()) { string attributeName = reader.Name; switch (attributeName) { case "Name": fieldName = reader.Value; break; case "Type": fieldType = reader.Value; break; case "AllowNull": allowNull = Convert.ToBoolean(reader.Value); break; case "UniqueKeyGroup": string[] keyGroups = reader.Value.Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries); foreach (string sKeyGroup in keyGroups) { uniqueKeyGroups.Add(int.Parse(sKeyGroup)); } break; case "EnumValues": if (IsGlobalEnum(reader.Value)) { globalEnumName = reader.Value; } else { enumValues = reader.Value.Split("/".ToArray()); } break; default: throw new NotImplementedException("'" + attributeName + "' on field '" + fieldName + "' on entity '" + nameSingular + "' is not a valid field attribute."); } } if (fieldName == "") { throw new ApplicationException("Field on entity '" + nameSingular + "' must have a name."); } if (fieldType == "") { throw new ApplicationException("Field '" + fieldName + "' entity '" + nameSingular + "' must have a type."); } field = new Field(nameSingular, fieldName, fieldType, allowNull, uniqueKeyGroups.ToArray()); if (globalEnumName != "") { field.GlobalEnumName = globalEnumName; } else { if (enumValues != null) { field.EnumValues = enumValues; } } if (uniqueKeyGroups.Count > 0) { foreach (int uniqueKeyGroup in uniqueKeyGroups) { AddToUniqueKeys(uniqueKeys, uniqueKeyGroup, field); } } } else if (reader.Name == "ViewField") { string fieldName = ""; string fieldType = ""; bool allowNull = false; while (reader.MoveToNextAttribute()) { string attributeName = reader.Name; switch (attributeName) { case "Name": fieldName = reader.Value; break; case "Type": fieldType = reader.Value; break; case "AllowNull": allowNull = Convert.ToBoolean(reader.Value); break; default: throw new NotImplementedException("'" + attributeName + "' on field '" + fieldName + "' on entity '" + nameSingular + "' is not a valid field attribute."); } } if (fieldName == "") { throw new ApplicationException("Field on entity '" + nameSingular + "' must have a name."); } if (fieldType == "") { throw new ApplicationException("Field '" + fieldName + "' entity '" + nameSingular + "' must have a type."); } field = new ViewField(nameSingular, fieldName, fieldType, allowNull); } else { throw new ApplicationException("When initiating entity '" + nameSingular + "', tags '<PrimaryKeyField>, <ForeighKeyField>, <Field> or <ViewField>' was expected, but got tag '<" + reader.Name + ">'"); } fields.Add(field); while (reader.Read() && reader.NodeType != XmlNodeType.Element && reader.NodeType != XmlNodeType.EndElement) { ; } } } else { throw new ApplicationException("When initiating entity '" + nameSingular + "', tag '<Fields>' was expected, but got tag '<" + reader.Name + ">'"); } Entities.Add(new Entity(this, nameSingular, namePlural, isView, fields.ToArray(), uniqueKeys.ToArray(), parentNames.ToArray())); } } // Loopa igenom alla entiteter och sätt barn på alla föräldrar foreach (Entity entity in Entities) { if (entity.HasParents) { foreach (string parentName in entity.ParentNames) { Entity parent = Entities.Find(e => e.NameSingular == parentName); parent.ChildNames.Add(entity.NameSingular); } } } }
public void MapObj(Type o) { bool isArray = false, isByRef = false; string ShortName = FixName(o, ref isArray, ref isByRef); if (Enums.Contains(ShortName)) { return; } Console.WriteLine(ShortName); Enums.Add(ShortName); XmlDocument CDOC = new XmlDocument(); string title = "class"; if (o.IsValueType) { title = "struct"; } if (o.IsInterface) { title = "interface"; } var x1 = NewNode(CDOC, title, FixName(o, ref isArray, ref isByRef)); AddAttribute(x1, "fullName", o.FullName); AddAttribute(x1, "assembly", o.Assembly.FullName); AddAttribute(x1, "location", o.Assembly.Location); IdType(o, x1); if (o.GetConstructor(Type.EmptyTypes) == null && o.IsAbstract && o.IsSealed) { AddAttribute(x1, "static", "1"); } x1.AppendChild(CDOC.CreateElement("interfaces")); x1.AppendChild(CDOC.CreateElement("constructors")); x1.AppendChild(CDOC.CreateElement("fields")); x1.AppendChild(CDOC.CreateElement("props")); var xMethods = (CDOC.CreateElement("methods")); x1.AppendChild(xMethods); CDOC.AppendChild(x1); foreach (var i in o.GetInterfaces()) { var Name = (i.FullName == null ? i.Name : i.FullName); if (Name != null) { bool dum = false; var x2 = NewNode(CDOC, "interface", FixName(i, ref dum, ref dum)); Type iT = i.GetType(); MapObj(i); x1.SelectSingleNode("interfaces").AppendChild(x2); } } foreach (var mi in o.GetConstructors()) { var x2 = (XmlElement)CDOC.CreateElement("constructor"); foreach (var pi in mi.GetParameters()) { var x3 = NewNode(CDOC, "param", pi.Name); IdType(pi.ParameterType, x3); x2.AppendChild(x3); } x1.SelectSingleNode("constructors").AppendChild(x2); } var pnames = new List <string>(); foreach (FieldInfo fi in o.GetFields()) { pnames.Add(fi.Name); var f = NewNode(CDOC, "field", fi.Name); AddAttribute(f, "value"); Type t = fi.FieldType; IdType(t, f); int iType = Convert.ToInt32(f.GetAttribute("type")); x1.SelectSingleNode("fields").AppendChild(f); } foreach (PropertyInfo pi in o.GetProperties()) { //necessary because adds prop twice if read/write if (!pnames.Contains(pi.Name)) { var p = NewNode(CDOC, "prop", pi.Name); var list = pi.GetIndexParameters(); if (list.Length > 0) { AddAttribute(p, "index", GetDataType(list[0].ParameterType).ToString()); } AddAttribute(p, "value"); AddAttribute(p, "read", pi.CanRead ? "1" : "0"); AddAttribute(p, "write", pi.CanWrite ? "1" : "0"); Type t = pi.PropertyType; IdType(t, p); x1.SelectSingleNode("props").AppendChild(p); pnames.Add(pi.Name); x1.SelectSingleNode("props").AppendChild(p); } } int staticMethods = 0; int totalMethods = 0; if (o.IsInterface) { int i = 0; } foreach (var mi in o.GetMethods()) { if (mi.Name.StartsWith("get_") || mi.Name.StartsWith("set_")) { continue; } if (mi.Name == "GetType") { continue; } totalMethods++; XmlElement x2 = null; XmlElement x3 = null; foreach (XmlElement x2a in xMethods.SelectNodes("method")) { if (x2a.GetAttribute("name") == mi.Name) { x2 = x2a; break; } } if (x2 == null) { x2 = NewNode(CDOC, "method", mi.Name); xMethods.AppendChild(x2); x3 = CDOC.CreateElement("overloads"); x2.AppendChild(x3); Type t = mi.ReturnType; IdType(t, x2); int iType = Convert.ToInt32(x2.GetAttribute("type")); } else { x3 = (XmlElement)x2.SelectSingleNode("overloads"); } if (mi.IsStatic) { staticMethods++; AddAttribute(x2, "static", "1"); } var x4 = CDOC.CreateElement("params"); foreach (var pi in mi.GetParameters()) { Type t = pi.ParameterType; var x5 = NewNode(CDOC, "param", pi.Name); IdType(t, x5); x4.AppendChild(x5); } bool dupe = false; foreach (XmlElement nowParms in x3.ChildNodes) { dupe = (nowParms.InnerXml == x4.InnerXml); if (dupe) { break; } } if (!dupe) { x3.AppendChild(x4); } } if (totalMethods == staticMethods && totalMethods != 0) { // this should be good cuz can't have non static methods in a static class AddAttribute(x1, "static", "1"); } if (ShortName == "System.Data.SqlClient.SqlCommand") { Debug.Print("bam"); } ; Write(CDOC); }