using System.Collections;
using System.CodeDom.Compiler;
using System.IO;
+using System.Text;
public class Outline {
+ Options options;
IndentedTextWriter o;
Type t;
- public Outline (Type t, TextWriter output)
+ public Outline (Type t, TextWriter output, Options options)
{
this.t = t;
this.o = new IndentedTextWriter (output, " ");
+ this.options = options;
}
- public void OutlineType (BindingFlags flags)
+ public void OutlineType ()
{
bool first;
o.Write (FormatType (method.ReturnType));
o.Write (" ");
- o.Write (t.Name);
+ o.Write (GetTypeName (t));
o.Write (" (");
OutlineParams (method.GetParameters ());
o.WriteLine (");");
return;
}
- o.Write (t.Name);
+ o.Write (GetTypeName (t));
if (((parent != null && parent != typeof (object) && parent != typeof (ValueType)) || interfaces.Length != 0) && ! t.IsEnum) {
first = true;
o.Write (" : ");
o.Write (FormatType (intf));
}
}
+
+ if (t.IsEnum) {
+ Type underlyingType = Enum.GetUnderlyingType (t);
+ if (underlyingType != typeof (int))
+ o.Write (" : {0}", FormatType (underlyingType));
+ }
o.WriteLine (" {");
o.Indent++;
first = true;
- foreach (ConstructorInfo ci in t.GetConstructors (flags)) {
+ foreach (ConstructorInfo ci in t.GetConstructors (DefaultFlags)) {
+
+ if (! ShowMember (ci))
+ continue;
+
if (first)
o.WriteLine ();
first = false;
first = true;
- foreach (MethodInfo m in Comparer.Sort (t.GetMethods (flags))) {
+ foreach (MethodInfo m in Comparer.Sort (t.GetMethods (DefaultFlags))) {
+
+ if (! ShowMember (m))
+ continue;
+
if ((m.Attributes & MethodAttributes.SpecialName) != 0)
continue;
first = true;
- foreach (MethodInfo m in t.GetMethods (flags)) {
+ foreach (MethodInfo m in t.GetMethods (DefaultFlags)) {
+
+ if (! ShowMember (m))
+ continue;
+
if ((m.Attributes & MethodAttributes.SpecialName) == 0)
continue;
if (!(m.Name.StartsWith ("op_")))
first = true;
- foreach (PropertyInfo pi in Comparer.Sort (t.GetProperties (flags))) {
+ foreach (PropertyInfo pi in Comparer.Sort (t.GetProperties (DefaultFlags))) {
+
+ if (! ((pi.CanRead && ShowMember (pi.GetGetMethod (true))) ||
+ (pi.CanWrite && ShowMember (pi.GetSetMethod (true)))))
+ continue;
if (first)
o.WriteLine ();
first = true;
- foreach (FieldInfo fi in t.GetFields (flags)) {
+ foreach (FieldInfo fi in t.GetFields (DefaultFlags)) {
+
+ if (! ShowMember (fi))
+ continue;
if (first)
o.WriteLine ();
first = true;
- foreach (EventInfo ei in Comparer.Sort (t.GetEvents (flags))) {
+ foreach (EventInfo ei in Comparer.Sort (t.GetEvents (DefaultFlags))) {
+
+ if (! ShowMember (ei.GetAddMethod ()))
+ continue;
if (first)
o.WriteLine ();
first = true;
- foreach (Type ntype in Comparer.Sort (t.GetNestedTypes (flags))) {
+ foreach (Type ntype in Comparer.Sort (t.GetNestedTypes (DefaultFlags))) {
+
+ if (! ShowMember (ntype))
+ continue;
if (first)
o.WriteLine ();
first = false;
- new Outline (ntype, o).OutlineType (flags);
+ new Outline (ntype, o, options).OutlineType ();
}
o.Indent--; o.WriteLine ("}");
}
+
+ BindingFlags DefaultFlags {
+ get {
+ BindingFlags f = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
+
+ if (options.DeclaredOnly)
+ f |= BindingFlags.DeclaredOnly;
+
+ return f;
+ }
+ }
// FIXME: add other interesting attributes?
void OutlineAttributes ()
void OutlineConstructor (ConstructorInfo ci)
{
o.Write (GetMethodVisibility (ci));
- o.Write (t.Name);
+ o.Write (RemoveGenericArity (t.Name));
o.Write (" (");
OutlineParams (ci.GetParameters ());
o.Write (");");
void OutlineProperty (PropertyInfo pi)
{
ParameterInfo [] idxp = pi.GetIndexParameters ();
- MethodBase accessor = pi.CanRead ? pi.GetGetMethod (true) : pi.GetSetMethod (true);
+ MethodBase g = pi.GetGetMethod (true);
+ MethodBase s = pi.GetSetMethod (true);
+ MethodBase accessor = g != null ? g : s;
+
+ if (pi.CanRead && pi.CanWrite) {
+
+
+ // Get the more accessible accessor
+ if ((g.Attributes & MethodAttributes.MemberAccessMask) !=
+ (s.Attributes & MethodAttributes.MemberAccessMask)) {
+
+ if (g.IsPublic) accessor = g;
+ else if (s.IsPublic) accessor = s;
+ else if (g.IsFamilyOrAssembly) accessor = g;
+ else if (s.IsFamilyOrAssembly) accessor = s;
+ else if (g.IsAssembly || g.IsFamily) accessor = g;
+ else if (s.IsAssembly || s.IsFamily) accessor = s;
+ }
+ }
o.Write (GetMethodVisibility (accessor));
o.Write (GetMethodModifiers (accessor));
o.WriteLine (" {");
o.Indent ++;
- if (pi.CanRead) o.WriteLine ("get;");
- if (pi.CanWrite) o.WriteLine ("set;");
+ if (g != null && ShowMember (g)) {
+ if ((g.Attributes & MethodAttributes.MemberAccessMask) !=
+ (accessor.Attributes & MethodAttributes.MemberAccessMask))
+ o.Write (GetMethodVisibility (g));
+ o.WriteLine ("get;");
+ }
+
+ if (s != null && ShowMember (s)) {
+ if ((s.Attributes & MethodAttributes.MemberAccessMask) !=
+ (accessor.Attributes & MethodAttributes.MemberAccessMask))
+ o.Write (GetMethodVisibility (s));
+ o.WriteLine ("set;");
+ }
o.Indent --;
o.Write ("}");
o.Write (FormatType (mi.ReturnType));
o.Write (" ");
o.Write (mi.Name);
+#if NET_2_0
+ o.Write (FormatGenericParams (mi.GetGenericArguments ()));
+#endif
o.Write (" (");
OutlineParams (mi.GetParameters ());
o.Write (");");
if (fi.IsFamily) o.Write ("protected ");
if (fi.IsPrivate) o.Write ("private ");
if (fi.IsAssembly) o.Write ("internal ");
- if (fi.IsLiteral) o.Write ("const ");
+ if (fi.IsLiteral) o.Write ("const ");
+ if (fi.IsInitOnly) o.Write ("readonly ");
+
o.Write (FormatType (fi.FieldType));
o.Write (" ");
o.Write (fi.Name);
return "internal";
}
}
+
+ string FormatGenericParams (Type [] args)
+ {
+ StringBuilder sb = new StringBuilder ();
+ if (args.Length == 0)
+ return "";
+
+ sb.Append ("<");
+ for (int i = 0; i < args.Length; i++) {
+ if (i > 0)
+ sb.Append (",");
+ sb.Append (FormatType (args [i]));
+ }
+ sb.Append (">");
+ return sb.ToString ();
+ }
string FormatType (Type t)
{
- string type = t.FullName;
+ string type = GetFullName (t);
if (!type.StartsWith ("System.")) {
if (t.Namespace == this.t.Namespace)
return type;
}
+ public static string RemoveGenericArity (string name)
+ {
+ int start = 0;
+ StringBuilder sb = new StringBuilder ();
+ while (start < name.Length) {
+ int pos = name.IndexOf ('`', start);
+ if (pos < 0) {
+ sb.Append (name.Substring (start));
+ break;
+ }
+ sb.Append (name.Substring (start, pos-start));
+
+ pos++;
+
+ while ((pos < name.Length) && Char.IsNumber (name [pos]))
+ pos++;
+
+ start = pos;
+ }
+
+ return sb.ToString ();
+ }
+
+ string GetTypeName (Type t)
+ {
+ StringBuilder sb = new StringBuilder ();
+ GetTypeName (sb, t);
+ return sb.ToString ();
+ }
+
+ void GetTypeName (StringBuilder sb, Type t)
+ {
+ sb.Append (RemoveGenericArity (t.Name));
+#if NET_2_0
+ sb.Append (FormatGenericParams (t.GetGenericArguments ()));
+#endif
+ }
+
+ string GetFullName (Type t)
+ {
+ StringBuilder sb = new StringBuilder ();
+ GetFullName_recursed (sb, t, false);
+ return sb.ToString ();
+ }
+
+ void GetFullName_recursed (StringBuilder sb, Type t, bool recursed)
+ {
+#if NET_2_0
+ if (t.IsGenericParameter) {
+ sb.Append (t.Name);
+ return;
+ }
+#endif
+
+ if (t.DeclaringType != null) {
+ GetFullName_recursed (sb, t.DeclaringType, true);
+ sb.Append (".");
+ }
+
+ if (!recursed) {
+ string ns = t.Namespace;
+ if ((ns != null) && (ns != "")) {
+ sb.Append (ns);
+ sb.Append (".");
+ }
+ }
+
+ GetTypeName (sb, t);
+ }
+
string OperatorFromName (string name)
{
switch (name) {
default: return name;
}
}
+
+ bool ShowMember (MemberInfo mi)
+ {
+ if (mi.MemberType == MemberTypes.Constructor && ((MethodBase) mi).IsStatic)
+ return false;
+
+ if (options.ShowPrivate)
+ return true;
+
+ switch (mi.MemberType) {
+ case MemberTypes.Constructor:
+ case MemberTypes.Method:
+ MethodBase mb = mi as MethodBase;
+
+ if (mb.IsFamily || mb.IsPublic || mb.IsFamilyOrAssembly)
+ return true;
+
+ return false;
+
+
+ case MemberTypes.Field:
+ FieldInfo fi = mi as FieldInfo;
+
+ if (fi.IsFamily || fi.IsPublic || fi.IsFamilyOrAssembly)
+ return true;
+
+ return false;
+
+
+ case MemberTypes.NestedType:
+ case MemberTypes.TypeInfo:
+ Type t = mi as Type;
+
+ switch (t.Attributes & TypeAttributes.VisibilityMask){
+ case TypeAttributes.Public:
+ case TypeAttributes.NestedPublic:
+ case TypeAttributes.NestedFamily:
+ case TypeAttributes.NestedFamORAssem:
+ return true;
+ }
+
+ return false;
+ }
+
+ // What am I !!!
+ return true;
+ }
}
public class Comparer : IComparer {