private string GetMemberName(MemberReference memberReference) { var methodDefinition = memberReference as MethodDefinition; string memberName = ""; if (methodDefinition != null) { if (methodDefinition.IsConstructor) { memberName = "ctor"; } else if (methodDefinition.Name.StartsWith("op_Implicit")) { memberName = "implop_" + methodDefinition.ReturnType.ToString().SimplifyTypes() + "(" + methodDefinition.Parameters[0].ParameterType.ToString().SimplifyTypes() + ")"; } else if (methodDefinition.Name.StartsWith("op_")) { memberName = StringConvertUtils.ConvertOperatorFromAssembly(memberReference.Name); } else { memberName = StringConvertUtils.LowerCaseNeedsUnderscore(memberReference.Name); } } else { var memName = memberReference.Name; memberName = memName == "Item" ? "this" : StringConvertUtils.LowerCaseNeedsUnderscore(memName); } return(GetTypeName(memberReference.DeclaringType) + "." + memberName); }
private void PopulateMethods(TypeDefinition cecilType, MemberItem parentItem) { foreach (var method in cecilType.Methods) { if (!m_ScanForPrivateMembers && !method.IsPublic) { continue; } if (method.IsGetter || method.IsSetter) { continue; } AssemblyType asmType = AssemblyType.Method; var methodName = method.Name; if (method.IsConstructor) { methodName = "constructor"; asmType = AssemblyType.Constructor; } else if (methodName.StartsWith("op_Implicit")) { methodName = method.ReturnType.ToString().SimplifyTypes(); asmType = AssemblyType.ImplOperator; } else if (methodName.StartsWith("op_")) { methodName = StringConvertUtils.ConvertOperatorFromAssembly(methodName).Substring(3); // Skip the op_ part asmType = AssemblyType.Operator; } string modifier = ""; if (method.IsStatic) { modifier = "static"; } var asmEntry = new AsmEntry(methodName, asmType, modifier); foreach (var param in method.Parameters) { string paramType = param.ParameterType.ToString().SimplifyTypes(); bool paramAttribute = IsParams(param); string paramModifiers = paramAttribute? "params": ""; var paramElement = new ParamElement(param.Name, paramType, paramModifiers); asmEntry.ParamList.Add(paramElement); } foreach (GenericParameter param in method.GenericParameters) { string paramType = param.GetElementType().ToString().SimplifyTypes(); asmEntry.GenericParamList.Add(paramType); } asmEntry.ReturnType = method.ReturnType.ToString().SimplifyTypes(); var signatureName = MemberNameGenerator.SignatureNameFromMethodDefinition(method); HandleMemberAndSignature(GetMemberName(method), signatureName, asmEntry, parentItem); } }
private static string MemberNameFromMethodDefinition(MethodDefinition methodInfo, bool simplified) { if (methodInfo.Name.Contains("Slider")) { int k = 0; } var sb = new StringBuilder(); if (methodInfo.Name.Contains("ctor")) { sb.Append("ctor"); } else if (methodInfo.Name.Contains("op_Implicit")) { sb.Append("implop_"); var retString = methodInfo.ReturnType.ToString(); sb.Append(retString.SimplifyTypesAndArrays()); } else if (methodInfo.Name.Contains("op_")) { sb.Append(StringConvertUtils.ConvertOperatorFromAssembly(methodInfo.Name)); sb.Replace("op_", ""); } else { sb.Append(methodInfo.Name); } if (methodInfo.HasGenericParameters) { foreach (var generic in methodInfo.GenericParameters) { sb.AppendFormat("_{0}_", generic.Name); } } if (!simplified) { foreach (var param in methodInfo.Parameters) { var paramString = param.ParameterType.ToString(); sb.Append("_"); sb.Append(paramString.SimplifyTypesAndArrays()); } } return(sb.ToString()); }
private static void AppendName(string methodInfoName, StringBuilder sb) { if (methodInfoName.Equals(".ctor")) { sb.Append("ctor"); } else if (methodInfoName.Contains("op_Implicit")) { Assert.Fail("We are handling this as a special case"); //sb.Append("implop_"); //sb.Append(retString.SimplifyTypesAndArrays()); } else if (methodInfoName.Contains("op_")) { sb.Append(StringConvertUtils.ConvertOperatorFromAssembly(methodInfoName)); sb.Replace("op_", ""); } else { sb.Append(methodInfoName); } }
internal static void InitRegexList(out RegexMatcher[] regexList) { regexList = new[] { new RegexMatcher(ImplOperatorMarker, m => { string ret = m.Groups[1].ToString(); string extras = StringConvertUtils.ConvertArgsToString(m.Groups[2].ToString()); return(String.Concat("implop_", ret, extras)); }, "IMPLICIT OPERATOR"), new RegexMatcher(ImplOperatorFromAssembly, m => { string ret = m.Groups[1].ToString(); string extras = StringConvertUtils.ConvertArgsToString(m.Groups[2].ToString()); return(String.Concat("implop_", ret, extras)); }, "IMPLICIT OPERATOR"), new RegexMatcher(OperatorFromAssembly, m => { string name = StringConvertUtils.ConvertOperatorFromAssembly(m.Groups[2].ToString()); string extras = StringConvertUtils.ConvertArgsToString(m.Groups[3].ToString()); return(String.Concat(name, extras)); }, "OPERATOR"), new RegexMatcher(IndexerMarker, m => { string extras = StringConvertUtils.ConvertArgsToString(m.Groups[2].ToString()); return(String.Concat("this", extras)); }, "INDEXER"), new RegexMatcher(MethodMarker, m => { string extras = StringConvertUtils.ConvertArgsToString(m.Groups[3].ToString()); return(String.Concat(m.Groups[2].ToString(), extras)); }, "METHOD", m => m.Groups[2].ToString()), new RegexMatcher(OperatorMarker, m => { string name = StringConvertUtils.ConvertOperator(m.Groups[2].ToString()); string extras = StringConvertUtils.ConvertArgsToString(m.Groups[3].ToString()); return(String.Concat(name, extras)); }, "OPERATOR"), new RegexMatcher(FieldAssignmentMarker, DefaultMatcher, "FIELD ASSIGNMENT"), new RegexMatcher(FieldMarker, DefaultMatcher, "FIELD"), new RegexMatcher(ConstMarker, DefaultMatcher, "CONST"), new RegexMatcher(ConstructorMarker, ConstructorDestructorMatcher, "CONSTRUCTOR", m => "ctor"), new RegexMatcher(DestructorMarker, ConstructorDestructorMatcher, "DESTRUCTOR"), new RegexMatcher(ConstructorFromAssemblyMarker, m => { var sb = new StringBuilder(m.Groups[0].ToString()); sb.Replace("Void .ctor(", ""); sb.Replace(")", ""); string args = StringConvertUtils.ConvertArgsToString(sb.ToString()); return(String.Concat("ctor", args)); }, "CONSTRUCTOR_ASSEMBLY"), new RegexMatcher(EnumEntryAssignmentMarker, m => m.Groups[1].ToString(), "ENUM_ENTRY"), new RegexMatcher(EnumEntryNoAssignment, m => m.Groups[1].ToString(), "ENUM_ENTRY_NOASS"), }; }