private static bool ChkPropertyVisible(PropertyDefinition property)
{
MethodDefinition method;
bool get_visible = false;
bool set_visible = false;
if ((method = property.GetMethod) != null &&
(DocUtils.IsExplicitlyImplemented(method) ||
(!method.IsPrivate && !method.IsAssembly && !method.IsFamilyAndAssembly)))
{
get_visible = true;
}
if ((method = property.SetMethod) != null &&
(DocUtils.IsExplicitlyImplemented(method) ||
(!method.IsPrivate && !method.IsAssembly && !method.IsFamilyAndAssembly)))
{
set_visible = true;
}
if ((set_visible == false) && (get_visible == false))
{
return(false);
}
else
{
return(true);
}
}
protected override string GetPropertyDeclaration(PropertyDefinition property)
{
MethodDefinition gm = null, sm = null;
string get_visible = null;
if ((gm = property.GetMethod) != null &&
(DocUtils.IsExplicitlyImplemented(gm) ||
(!gm.IsPrivate && !gm.IsAssembly && !gm.IsFamilyAndAssembly)))
{
get_visible = AppendVisibility(new StringBuilder(), gm).ToString();
}
string set_visible = null;
if ((sm = property.SetMethod) != null &&
(DocUtils.IsExplicitlyImplemented(sm) ||
(!sm.IsPrivate && !sm.IsAssembly && !sm.IsFamilyAndAssembly)))
{
set_visible = AppendVisibility(new StringBuilder(), sm).ToString();
}
if ((set_visible == null) && (get_visible == null))
{
return(null);
}
StringBuilder buf = new StringBuilder()
.Append(".property ");
if (!(gm ?? sm).IsStatic)
{
buf.Append("instance ");
}
_AppendTypeName(buf, property.PropertyType, AttributeParserContext.Create(property));
buf.Append(' ').Append(property.Name);
if (!property.HasParameters || property.Parameters.Count == 0)
{
return(buf.ToString());
}
buf.Append('(');
bool first = true;
foreach (ParameterDefinition p in property.Parameters)
{
if (!first)
{
buf.Append(", ");
}
first = false;
_AppendTypeName(buf, p.ParameterType, AttributeParserContext.Create(p));
}
buf.Append(')');
return(buf.ToString());
}
protected override StringBuilder AppendMethodName(StringBuilder buf, MethodDefinition method)
{
if (DocUtils.IsExplicitlyImplemented(method))
{
TypeReference iface;
MethodReference ifaceMethod;
DocUtils.GetInfoForExplicitlyImplementedMethod(method, out iface, out ifaceMethod);
return(buf.Append(new CSharpMemberFormatter(this.TypeMap).GetName(iface))
.Append('.')
.Append(ifaceMethod.Name));
}
return(base.AppendMethodName(buf, method));
}
protected override string GetPropertyDeclaration(PropertyDefinition property)
{
MethodDefinition method;
string get_visible = null;
if ((method = property.GetMethod) != null &&
(DocUtils.IsExplicitlyImplemented(method) ||
(!method.IsPrivate && !method.IsAssembly && !method.IsFamilyAndAssembly)))
{
get_visible = AppendVisibility(new StringBuilder(), method).ToString();
}
string set_visible = null;
if ((method = property.SetMethod) != null &&
(DocUtils.IsExplicitlyImplemented(method) ||
(!method.IsPrivate && !method.IsAssembly && !method.IsFamilyAndAssembly)))
{
set_visible = AppendVisibility(new StringBuilder(), method).ToString();
}
if ((set_visible == null) && (get_visible == null))
{
return(null);
}
string visibility;
StringBuilder buf = new StringBuilder();
if (get_visible != null && (set_visible == null || (set_visible != null && get_visible == set_visible)))
{
buf.Append(visibility = get_visible);
}
else if (set_visible != null && get_visible == null)
{
buf.Append(visibility = set_visible);
}
else
{
buf.Append(visibility = "public");
}
// Pick an accessor to use for static/virtual/override/etc. checks.
method = property.SetMethod;
if (method == null)
{
method = property.GetMethod;
}
string modifiers = String.Empty;
if (method.IsStatic)
{
modifiers += " static";
}
if (method.IsVirtual && !method.IsAbstract)
{
if ((method.Attributes & MethodAttributes.NewSlot) != 0)
{
modifiers += " virtual";
}
else
{
modifiers += " override";
}
}
TypeDefinition declDef = (TypeDefinition)method.DeclaringType;
if (method.IsAbstract && !declDef.IsInterface)
{
modifiers += " abstract";
}
if (method.IsFinal)
{
modifiers += " sealed";
}
if (modifiers == " virtual sealed")
{
modifiers = "";
}
buf.Append(modifiers).Append(' ');
if (property.PropertyType.IsByReference)
{
buf.Append("ref ");
}
buf.Append(GetTypeName(property.PropertyType, new DynamicParserContext(property))).Append(' ');
IEnumerable <MemberReference> defs = property.DeclaringType.GetDefaultMembers();
string name = property.Name;
foreach (MemberReference mi in defs)
{
if (mi == property)
{
name = "this";
break;
}
}
buf.Append(name == "this" ? name : DocUtils.GetPropertyName(property, NestedTypeSeparator));
if (property.Parameters.Count != 0)
{
AppendParameters(buf, method, property.Parameters, '[', ']');
}
buf.Append(" {");
if (get_visible != null)
{
if (get_visible != visibility)
{
buf.Append(' ').Append(get_visible);
}
buf.Append(" get;");
}
if (set_visible != null)
{
if (set_visible != visibility)
{
buf.Append(' ').Append(set_visible);
}
buf.Append(" set;");
}
buf.Append(" }");
return(buf[0] != ' ' ? buf.ToString() : buf.ToString(1, buf.Length - 1));
}
protected override StringBuilder AppendMethodName(StringBuilder buf, MethodDefinition method)
{
if (DocUtils.IsExplicitlyImplemented(method))
{
TypeReference iface;
MethodReference ifaceMethod;
DocUtils.GetInfoForExplicitlyImplementedMethod(method, out iface, out ifaceMethod);
return(buf.Append(new CSharpMemberFormatter(this.TypeMap).GetName(iface))
.Append('.')
.Append(ifaceMethod.Name));
}
if (method.Name.StartsWith("op_", StringComparison.Ordinal))
{
// this is an operator
switch (method.Name)
{
case "op_Implicit":
case "op_Explicit":
buf.Length--; // remove the last space, which assumes a member name is coming
return(buf);
case "op_Addition":
case "op_UnaryPlus":
return(buf.Append("operator +"));
case "op_Subtraction":
case "op_UnaryNegation":
return(buf.Append("operator -"));
case "op_Division":
return(buf.Append("operator /"));
case "op_Multiply":
return(buf.Append("operator *"));
case "op_Modulus":
return(buf.Append("operator %"));
case "op_BitwiseAnd":
return(buf.Append("operator &"));
case "op_BitwiseOr":
return(buf.Append("operator |"));
case "op_ExclusiveOr":
return(buf.Append("operator ^"));
case "op_LeftShift":
return(buf.Append("operator <<"));
case "op_RightShift":
return(buf.Append("operator >>"));
case "op_LogicalNot":
return(buf.Append("operator !"));
case "op_OnesComplement":
return(buf.Append("operator ~"));
case "op_Decrement":
return(buf.Append("operator --"));
case "op_Increment":
return(buf.Append("operator ++"));
case "op_True":
return(buf.Append("operator true"));
case "op_False":
return(buf.Append("operator false"));
case "op_Equality":
return(buf.Append("operator =="));
case "op_Inequality":
return(buf.Append("operator !="));
case "op_LessThan":
return(buf.Append("operator <"));
case "op_LessThanOrEqual":
return(buf.Append("operator <="));
case "op_GreaterThan":
return(buf.Append("operator >"));
case "op_GreaterThanOrEqual":
return(buf.Append("operator >="));
default:
return(base.AppendMethodName(buf, method));
}
}
else
{
return(base.AppendMethodName(buf, method));
}
}
protected override string GetMethodDeclaration(MethodDefinition method)
{
if (method.IsPrivate && !DocUtils.IsExplicitlyImplemented(method))
{
return(null);
}
var buf = new StringBuilder();
buf.Append(".method ");
AppendVisibility(buf, method);
if (method.IsStatic)
{
buf.Append("static ");
}
if (method.IsHideBySig)
{
buf.Append("hidebysig ");
}
if (method.IsPInvokeImpl && method.PInvokeInfo != null)
{
var info = method.PInvokeInfo;
buf.Append("pinvokeimpl (\"")
.Append(info.Module.Name)
.Append("\" as \"")
.Append(info.EntryPoint)
.Append("\"");
if (info.IsCharSetAuto)
{
buf.Append(" auto");
}
if (info.IsCharSetUnicode)
{
buf.Append(" unicode");
}
if (info.IsCharSetAnsi)
{
buf.Append(" ansi");
}
if (info.IsCallConvCdecl)
{
buf.Append(" cdecl");
}
if (info.IsCallConvStdCall)
{
buf.Append(" stdcall");
}
if (info.IsCallConvWinapi)
{
buf.Append(" winapi");
}
if (info.IsCallConvThiscall)
{
buf.Append(" thiscall");
}
if (info.SupportsLastError)
{
buf.Append(" lasterr");
}
buf.Append(")");
}
if (method.IsSpecialName)
{
buf.Append("specialname ");
}
if (method.IsRuntimeSpecialName)
{
buf.Append("rtspecialname ");
}
if (method.IsNewSlot)
{
buf.Append("newslot ");
}
if (method.IsVirtual)
{
buf.Append("virtual ");
}
if (!method.IsStatic)
{
buf.Append("instance ");
}
_AppendTypeName(buf, method.ReturnType, AttributeParserContext.Create(method.MethodReturnType));
buf.Append(' ')
.Append(method.Name);
if (method.IsGenericMethod())
{
var state = MemberFormatterState;
MemberFormatterState = MemberFormatterState.WithinGenericTypeParameters;
IList <GenericParameter> args = method.GenericParameters;
if (args.Count > 0)
{
buf.Append("<");
_AppendTypeName(buf, args[0], null);
for (int i = 1; i < args.Count; ++i)
{
_AppendTypeName(buf.Append(", "), args[i], null);
}
buf.Append(">");
}
MemberFormatterState = state;
}
buf.Append('(');
bool first = true;
for (int i = 0; i < method.Parameters.Count; ++i)
{
var param = method.Parameters[i];
if (!first)
{
buf.Append(", ");
}
first = false;
if (param.IsOut)
{
buf.Append("[out] ");
}
else if (param.IsIn)
{
buf.Append("[in]");
}
_AppendTypeName(buf, param.ParameterType, AttributeParserContext.Create(param));
if (param.ParameterType.IsByReference)
{
buf.Append("&");
}
buf.Append(' ');
buf.Append(param.Name);
}
buf.Append(')');
if (method.IsIL)
{
buf.Append(" cil");
}
if (method.IsRuntime)
{
buf.Append(" runtime");
}
if (method.IsManaged)
{
buf.Append(" managed");
}
return(buf.ToString());
}
