private void PopulateClassOrStructChildren(TypeDefinition objType, MemberItem parentItem)
{
PopulateNestedTypes(objType, parentItem);
PopulateMethods(objType, parentItem);
PopulateProperties(objType, parentItem);
PopulateFields(objType, parentItem);
}
private void PopulateFromMem()
{
string[] memFiles;
if (!DirectoryUtil.TryGetAllMemFiles(out memFiles))
{
Console.WriteLine("error getting source files");
return;
}
foreach (var memFile in memFiles)
{
// Get member name
var memberName = Path.GetFileNameWithoutExtension(memFile);
if (memberName == null)
{
Console.WriteLine("error: could not get file name from {0} ", memFile);
continue;
}
//HACK SPECIAL CASE
if (SkipSpecialCaseMember(memberName))
{
continue;
}
// Create or find MemberItem
if (!m_MapNameToItem.ContainsKey(memberName))
{
m_MapNameToItem[memberName] = new MemberItem(memberName, AssemblyType.Unknown);
}
}
}
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 MemberItem HandleMemberAndSignature(string itemName, string signatureName, AsmEntry asmEntry, MemberItem parentItem)
{
asmEntry.Private = m_ScanForPrivateMembers;
//HACK SPECIAL CASE
if (SkipSpecialCaseMember(itemName))
{
return(null);
}
// Create member item if not already existing
if (!m_MapNameToItem.ContainsKey(itemName))
{
if (!m_ScanForPrivateMembers)
{
m_MapNameToItem[itemName] = new MemberItem(itemName, asmEntry.EntryType);
}
else
{
return(null);
}
}
else if (!m_ScanForPrivateMembers && !m_MapNameToItem[itemName].MultipleSignaturesPossible)
{
Console.WriteLine("Same member name found twice for {0} (multiple signatures should not be possible for this type)", itemName);
}
// Get member item
MemberItem item = m_MapNameToItem[itemName];
// Create signature
if (!item.ContainsSignature(signatureName))
{
var sigEntry = new SignatureEntry(signatureName);
sigEntry.AddFromAssembly(asmEntry);
item.AddSignature(sigEntry);
}
else
{
if (!m_ScanForPrivateMembers)
{
Console.WriteLine("We should not see the same signature entry twice!! for {0} : {1}.", itemName, signatureName);
}
else
{
var sigEntry = item.GetSignature(signatureName, true);
if (!sigEntry.InAsm)
{
sigEntry.AddFromAssembly(asmEntry);
}
}
}
if (item != null && parentItem != null && !parentItem.ChildMembers.Contains(item))
{
parentItem.ChildMembers.Add(item);
}
return(item); //the item we just populated, may or may not be used
}
private void PopulateEnumChildren(TypeDefinition enumTypeDef, MemberItem parentItem)
{
foreach (var field in enumTypeDef.Fields)
{
if (field.Name == "value__")
{
continue;
}
AsmEntry asm = new AsmEntry(field.Name, AssemblyType.EnumValue);
HandleMemberAndSignature(GetMemberName(field), field.Name, asm, parentItem);
}
}
private void PopulateNestedTypes(TypeDefinition cecilType, MemberItem parentItem)
{
foreach (var nested in cecilType.NestedTypes)
{
bool isDelegate = IsDelegate(nested);
if (isDelegate)
{
//treat as a function, even though Cecil sees it as a class
PopulateDelegate(nested);
}
else
{
PopulateFromTypeDefinition(nested);
}
}
}
private void PopulateProperties(TypeDefinition cecilType, MemberItem parentItem)
{
foreach (PropertyDefinition prop in cecilType.Properties)
{
if (!m_ScanForPrivateMembers && (prop.GetMethod != null && !prop.GetMethod.IsPublic))
{
continue;
}
var signatureName = MemberNameGenerator.SignatureNameFromPropertyDefinition(prop);
AsmEntry asm = new AsmEntry(signatureName, AssemblyType.Property)
{
ReturnType = prop.PropertyType.ToString().SimplifyTypes()
};
HandleMemberAndSignature(GetMemberName(prop), signatureName, asm, parentItem);
}
}
private void PopulateFields(TypeDefinition cecilType, MemberItem parentItem)
{
foreach (var field in cecilType.Fields)
{
bool documentIt = m_ScanForPrivateMembers || (field.Attributes & FieldAttributes.Public) > 0;
if (!documentIt)
{
continue;
}
AsmEntry asm = new AsmEntry(field.Name, AssemblyType.Field)
{
ReturnType = field.FieldType.ToString().SimplifyTypes()
};
HandleMemberAndSignature(GetMemberName(field), field.Name, asm, parentItem);
}
}
