private static bool AnalyzeField(FieldDefinition fieldDefinition, XElement newElement)
{
bool result = false;
string[] supportByLibrary = _netOfficeSupportTable.GetTypeSupport(fieldDefinition.FieldType.FullName);
if (fieldDefinition.FieldType.FullName.StartsWith(_apiName, StringComparison.InvariantCultureIgnoreCase) &&
!fieldDefinition.FieldType.FullName.Equals(_apiName + ".dll", StringComparison.InvariantCultureIgnoreCase) && CountOf(fieldDefinition.FieldType.FullName, ".") > 1 && (null != supportByLibrary))
{
result = true;
string typeName = NetOfficeSupportTable.GetName(fieldDefinition.FieldType.FullName);
string componentName = NetOfficeSupportTable.GetLibrary(fieldDefinition.FieldType.FullName);
XElement fields = newElement.Element("Fields");
XElement newField = new XElement(new XElement("Entity",
new XAttribute("Type", fieldDefinition.FieldType.FullName),
new XAttribute("Name", fieldDefinition.Name),
new XAttribute("IsPublic", fieldDefinition.IsPublic.ToString()),
new XAttribute("Static", fieldDefinition.IsStatic)));
XElement supportByNode = new XElement("SupportByLibrary", new XAttribute("Api", componentName));
newField.Add(supportByNode);
if (null != supportByLibrary)
{
fields.Add(newField);
supportByNode.Add(new XAttribute("Name", typeName));
foreach (string item in supportByLibrary)
{
supportByNode.Add(new XElement("Version", item));
}
}
}
return(result);
}
private static bool AnalyzeMethodCreateNewObjects(MethodDefinition methodDefinition, XElement entity, XElement newMethodNode)
{
XElement createNode = null;
bool result = false;
Mono.Cecil.Cil.MethodBody body = methodDefinition.Body;
if (null != body)
{
// method calls
foreach (Instruction itemInstruction in body.Instructions)
{
if (itemInstruction.OpCode.Name.StartsWith("newobj"))
{
Mono.Cecil.MethodReference methodReference = itemInstruction.Operand as Mono.Cecil.MethodReference;
string typeName = GetNameFromNewObjMethodReference(methodReference);
string componentName = NetOfficeSupportTable.GetLibrary(typeName);
string[] supportByLibrary = _netOfficeSupportTable.GetTypeSupport(typeName);
if (typeName.StartsWith(_apiName) && !typeName.Equals(_apiName + ".dll", StringComparison.InvariantCultureIgnoreCase) &&
CountOf(typeName, ".") > 1 && (null != supportByLibrary))
{
result = true;
if (null == createNode)
{
createNode = new XElement("NewObjects");
newMethodNode.Add(createNode);
}
XElement newObject = new XElement("Entity",
new XAttribute("Type", typeName),
new XAttribute("Api", componentName));
createNode.Add(newObject);
XElement supportByNode = new XElement("SupportByLibrary");
newObject.Add(supportByNode);
if (null != supportByLibrary)
{
supportByNode.Add(new XAttribute("Name", typeName), new XAttribute("Api", componentName));
foreach (string item in supportByLibrary)
{
supportByNode.Add(new XElement("Version", item));
}
}
}
}
}
}
return(result);
}
private static bool AnalyzeMethodVariables(MethodDefinition methodDefinition, XElement entity, XElement newMethodNode)
{
XElement variablesNode = null;
bool result = false;
Mono.Cecil.Cil.MethodBody body = methodDefinition.Body;
if (null != body)
{
// local variables
foreach (VariableDefinition itemVariable in body.Variables)
{
if (itemVariable.VariableType.FullName.StartsWith(_apiName) && CountOf(itemVariable.VariableType.FullName, ".") > 1 && !itemVariable.VariableType.FullName.Equals(_apiName + ".dll", StringComparison.InvariantCultureIgnoreCase))
{
string componentName = NetOfficeSupportTable.GetLibrary(itemVariable.VariableType.FullName);
string typeName = NetOfficeSupportTable.GetName(itemVariable.VariableType.FullName);
if (null == variablesNode)
{
variablesNode = new XElement("Variables");
newMethodNode.Add(variablesNode);
}
result = true;
XElement newVar = new XElement("Entity",
new XAttribute("Type", itemVariable.VariableType.FullName),
new XAttribute("Name", itemVariable.ToString()),
new XAttribute("Api", componentName));
variablesNode.Add(newVar);
XElement supportByNode = new XElement("SupportByLibrary", new XAttribute("Api", componentName));
newVar.Add(supportByNode);
string[] supportByLibrary = _netOfficeSupportTable.GetTypeSupport(itemVariable.VariableType.FullName);
if (null != supportByLibrary)
{
supportByNode.Add(new XAttribute("Name", typeName));
foreach (string item in supportByLibrary)
{
supportByNode.Add(new XElement("Version", item));
}
}
}
}
}
return(result);
}
private static bool AnalyzeMethodFieldSets(MethodDefinition methodDefinition, XElement entity, XElement newMethodNode)
{
bool result = false;
Mono.Cecil.Cil.MethodBody body = methodDefinition.Body;
if (null != body)
{
foreach (Instruction itemInstruction in body.Instructions)
{
if (itemInstruction.OpCode.Name.StartsWith("stfld") || itemInstruction.OpCode.Name.StartsWith("stsfld"))
{
Mono.Cecil.Cil.Instruction methodInstruction = itemInstruction as Mono.Cecil.Cil.Instruction;
Mono.Cecil.FieldDefinition fieldDefinition = methodInstruction.Operand as Mono.Cecil.FieldDefinition;
if (fieldDefinition != null && fieldDefinition.FieldType.IsValueType)
{
Mono.Cecil.Cil.Instruction paramInstruction = GetParameterInstructionForField(methodInstruction);
if (null != paramInstruction)
{
bool sucseed = false;
int opValue = GetOperatorValue(paramInstruction, out sucseed);
if (sucseed)
{
string[] supportByLibrary = _netOfficeSupportTable.GetEnumMemberSupport(fieldDefinition.FieldType.FullName, (int)opValue);
if (null != supportByLibrary)
{
XElement newParameter = new XElement("Field", new XAttribute("Name", fieldDefinition.Name));
string componentName = NetOfficeSupportTable.GetLibrary(fieldDefinition.FieldType.FullName);
XElement supportByNode = new XElement("SupportByLibrary", new XAttribute("Api", componentName));
string memberName = _netOfficeSupportTable.GetEnumMemberNameFromValue(fieldDefinition.FieldType.FullName, opValue);
supportByNode.Add(new XAttribute("Name", fieldDefinition.FieldType + "." + memberName));
foreach (string item in supportByLibrary)
{
supportByNode.Add(new XElement("Version", item));
}
newParameter.Add(supportByNode);
newMethodNode.Element("FieldSets").Add(newParameter);
}
}
}
}
}
}
}
return(result);
}
private static bool AnalyzeMethodCallParameters(Instruction itemInstruction, XElement newMethodCallNode)
{
bool result = false;
Mono.Cecil.Cil.Instruction methodInstruction = itemInstruction as Mono.Cecil.Cil.Instruction;
Mono.Cecil.MethodReference methodReference = methodInstruction.Operand as Mono.Cecil.MethodReference;
int i = 1;
foreach (ParameterDefinition itemParameter in methodReference.Parameters)
{
string paramType = itemParameter.ParameterType.FullName;
if (paramType.StartsWith(_apiName) && CountOf(paramType, ".") > 1 && !paramType.Equals(_apiName + ".dll", StringComparison.InvariantCultureIgnoreCase))
{
result = true;
Mono.Cecil.Cil.Instruction parameterInstruction = GetParameterInstruction(itemInstruction, i);
if (itemParameter.ParameterType.IsValueType)
{
string[] supportByLibrary = _netOfficeSupportTable.GetEnumMemberSupport(itemParameter.ParameterType.FullName, GetOperatorValue(parameterInstruction));
if (null != supportByLibrary)
{
XElement newParameter = new XElement("Parameter");
string componentName = NetOfficeSupportTable.GetLibrary(itemParameter.ParameterType.FullName);
XElement supportByNode = new XElement("SupportByLibrary", new XAttribute("Api", componentName));
string enumMemberName = _netOfficeSupportTable.GetEnumMemberNameFromValue(itemParameter.ParameterType.FullName, GetOperatorValue(parameterInstruction));
if (null != enumMemberName)
{
supportByNode.Add(new XAttribute("Name", paramType + "." + enumMemberName));
}
else
{
supportByNode.Add(new XAttribute("Name", paramType + "." + GetOperatorValue(parameterInstruction).ToString()));
}
foreach (string item in supportByLibrary)
{
supportByNode.Add(new XElement("Version", item));
}
newParameter.Add(supportByNode);
newMethodCallNode.Element("Parameters").Add(newParameter);
}
}
else
{
string[] supportByLibrary = _netOfficeSupportTable.GetTypeSupport(itemParameter.ParameterType.FullName);
if (null != supportByLibrary)
{
XElement newParameter = new XElement("Parameter");
string componentName = NetOfficeSupportTable.GetLibrary(itemParameter.ParameterType.FullName);
XElement supportByNode = new XElement("SupportByLibrary", new XAttribute("Api", componentName));
supportByNode.Add(new XAttribute("Name", paramType));
foreach (string item in supportByLibrary)
{
supportByNode.Add(new XElement("Version", item));
}
newParameter.Add(supportByNode);
newMethodCallNode.Element("Parameters").Add(newParameter);
}
}
}
else
{
Instruction prevInstruction = methodInstruction.Previous;
while (prevInstruction.OpCode.Name.StartsWith("ld") || prevInstruction.OpCode.Name.StartsWith("box"))
{
if (null != prevInstruction.Operand)
{
string targetName = prevInstruction.Operand.ToString();
string[] dumyByLibrary = _netOfficeSupportTable.GetTypeSupport(targetName);
if (null != dumyByLibrary)
{
if (null != prevInstruction.Previous.Operand)
{
int temp = 0;
if (Int32.TryParse(prevInstruction.Previous.Operand.ToString(), out temp))
{
int opValue = Convert.ToInt32(temp);
string enumMemberName = _netOfficeSupportTable.GetEnumMemberNameFromValue(targetName, opValue);
if (null != enumMemberName)
{
string[] supportByLibrary = _netOfficeSupportTable.GetEnumMemberSupport(targetName, opValue);
if (null != supportByLibrary)
{
XElement newParameter = new XElement("Parameter");
string componentName = NetOfficeSupportTable.GetLibrary(targetName);
XElement supportByNode = new XElement("SupportByLibrary", new XAttribute("Api", componentName));
supportByNode.Add(new XAttribute("Name", targetName + "." + enumMemberName));
foreach (string item in supportByLibrary)
{
supportByNode.Add(new XElement("Version", item));
}
newParameter.Add(supportByNode);
newMethodCallNode.Element("Parameters").Add(newParameter);
}
}
}
}
}
}
prevInstruction = prevInstruction.Previous;
}
}
i++;
}
return(result);
}
private static bool AnalyzeMethodCalls(MethodDefinition methodDefinition, XElement entity, XElement newMethodNode)
{
XElement callsNode = null;
bool result = false;
Mono.Cecil.Cil.MethodBody body = methodDefinition.Body;
if (null != body)
{
// method calls
foreach (Instruction itemInstruction in body.Instructions)
{
if (itemInstruction.OpCode.Name.StartsWith("callvirt"))
{
Mono.Cecil.Cil.Instruction methodInstruction = itemInstruction as Mono.Cecil.Cil.Instruction;
Mono.Cecil.MethodReference methodReference = methodInstruction.Operand as Mono.Cecil.MethodReference;
string callName = GetCallNameFromAnalyzeMethodCalls(methodReference);
string typeName = GetNameFromNewObjMethodReference(methodReference);
string componentName = NetOfficeSupportTable.GetLibrary(typeName);
string[] testArray = typeName.Split(new string[] { "." }, StringSplitOptions.RemoveEmptyEntries);
if (testArray.Length >= 3 && testArray[2] == "Tools")
{
continue;
}
if ((typeName.StartsWith(_apiName)) && !typeName.Equals(_apiName + ".dll", StringComparison.InvariantCultureIgnoreCase) &&
CountOf(typeName, ".") > 1 && (!typeName.StartsWith("NetOffice.DeveloperToolbox")))
{
string[] supportByLibrary = _netOfficeSupportTable.GetTypeCallSupport(callName);
result = true;
if (null == callsNode)
{
callsNode = new XElement("Calls");
newMethodNode.Add(callsNode);
}
XElement newObject = new XElement("Entity",
new XElement("Parameters"),
new XAttribute("Type", typeName),
new XAttribute("Name", callName),
new XAttribute("Api", componentName));
callsNode.Add(newObject);
XElement supportByNode = new XElement("SupportByLibrary", new XAttribute("Api", componentName));
newObject.Add(supportByNode);
if (null != supportByLibrary)
{
supportByNode.Add(new XAttribute("Name", callName));
foreach (string item in supportByLibrary)
{
supportByNode.Add(new XElement("Version", item));
}
}
bool resultParameter = AnalyzeMethodCallParameters(itemInstruction, newObject);
}
}
}
}
return(result);
}
private static bool AnalyzeMethod(MethodDefinition methodDefinition, XElement entity)
{
bool result = false;
bool isProperty = methodDefinition.IsGetter || methodDefinition.IsSetter;
XElement newMethodNode = new XElement("Method", new XAttribute("Name", methodDefinition.Name), new XAttribute("IsProperty", isProperty.ToString()), new XAttribute("IsPublic", methodDefinition.IsPublic.ToString()), new XElement("FieldSets"), new XElement("LocalFieldSets"));
XElement parametersNode = null;
// parameter
foreach (ParameterDefinition paramDefintion in methodDefinition.Parameters)
{
string[] supportByLibrary = _netOfficeSupportTable.GetTypeSupport(paramDefintion.ParameterType.FullName);
if (paramDefintion.ParameterType.FullName.StartsWith(_apiName) && (!paramDefintion.ParameterType.FullName.StartsWith("NetOffice.DeveloperToolbox")) &&
!paramDefintion.ParameterType.FullName.Equals(_apiName + ".dll", StringComparison.InvariantCultureIgnoreCase) && CountOf(paramDefintion.ParameterType.FullName, ".") > 1 && (null != supportByLibrary))
{
if (null == parametersNode)
{
parametersNode = new XElement("Parameters");
newMethodNode.Add(parametersNode);
}
string componentName = NetOfficeSupportTable.GetLibrary(paramDefintion.ParameterType.FullName);
string typeName = NetOfficeSupportTable.GetName(paramDefintion.ParameterType.FullName);
result = true;
XElement newParam = new XElement("Entity",
new XAttribute("Type", paramDefintion.ParameterType.FullName),
new XAttribute("Name", paramDefintion.Name),
new XAttribute("Api", componentName));
parametersNode.Add(newParam);
XElement supportByNode = new XElement("SupportByLibrary", new XAttribute("Api", componentName));
newParam.Add(supportByNode);
if (null != supportByLibrary)
{
supportByNode.Add(new XAttribute("Name", typeName));
foreach (string item in supportByLibrary)
{
supportByNode.Add(new XElement("Version", item));
}
}
}
}
// returnvalue
if ((methodDefinition.ReturnType.FullName.StartsWith(_apiName) &&
!methodDefinition.ReturnType.FullName.Equals(_apiName + ".dll", StringComparison.InvariantCultureIgnoreCase) &&
CountOf(methodDefinition.ReturnType.FullName, ".") > 1 &&
(!methodDefinition.ReturnType.FullName.StartsWith("NetOffice.DeveloperToolbox"))))
{
result = true;
string componentName = NetOfficeSupportTable.GetLibrary(methodDefinition.ReturnType.FullName);
string typeName = NetOfficeSupportTable.GetName(methodDefinition.ReturnType.FullName);
XElement returnValueNode = new XElement("ReturnValue");
XElement returnValue = new XElement("Entity", new XAttribute("Type", typeName), new XAttribute("FullType", methodDefinition.ReturnType.FullName),
new XAttribute("Api", componentName));
XElement supportByNode = new XElement("SupportByLibrary", new XAttribute("Api", componentName));
returnValue.Add(supportByNode);
string[] supportByLibrary = _netOfficeSupportTable.GetTypeSupport(methodDefinition.ReturnType.FullName);
if (null != supportByLibrary)
{
supportByNode.Add(new XAttribute("Name", typeName));
foreach (string item in supportByLibrary)
{
supportByNode.Add(new XElement("Version", item));
}
}
returnValueNode.Add(returnValue);
newMethodNode.Add(returnValueNode);
}
bool resultVariables = AnalyzeMethodVariables(methodDefinition, entity, newMethodNode);
bool resultNewObjects = AnalyzeMethodCreateNewObjects(methodDefinition, entity, newMethodNode);
bool resultCalls = AnalyzeMethodCalls(methodDefinition, entity, newMethodNode);
bool fieldSetCalls = AnalyzeMethodFieldSets(methodDefinition, entity, newMethodNode);
bool fieldSetLocalCalls = AnalyzeMethodLocalFieldSets(methodDefinition, entity, newMethodNode);
if ((result) || (resultVariables) || (resultNewObjects) || (resultCalls) || (fieldSetCalls) || (fieldSetCalls))
{
entity.Element("Methods").Add(newMethodNode);
result = true;
}
return(result);
}
