private EventDefinition FindEvent(MethodDefinition eventMethod, TypeDefinition type)
{
if (type == null)
{
throw new Exception("Can't find event named \"" + GetNameOfPropertyOrEvent(eventMethod.Name) + "\" in null type");
}
foreach (EventDefinition @event in type.Events)
{
if (@event.AddMethod == eventMethod || @event.RemoveMethod == eventMethod)
{
return(@event);
}
}
string eventName = "";
if (AnalysisUtils.IsMethodExplicitlyImplemented(eventMethod))
{
eventName += eventMethod.Name.Substring(0, eventMethod.Name.LastIndexOf('.') + 1);
}
eventName += GetNameOfPropertyOrEvent(eventMethod.Name);
EventDefinition newEvent = new EventDefinition(eventName, EventAttributes.None, eventMethod.Parameters[0].ParameterType);
if (eventMethod.Name.Contains("add_"))
{
newEvent.AddMethod = eventMethod;
newEvent.RemoveMethod = GetSecondMethodOfPropertyOrEvent(eventMethod, type);
}
else
{
newEvent.AddMethod = GetSecondMethodOfPropertyOrEvent(eventMethod, type);
newEvent.RemoveMethod = eventMethod;
}
return(newEvent);
}
/// <summary>
/// Check if the method is an acual method, or a member of a property or event.
/// </summary>
/// <param name="method"></param>
/// <returns></returns>
private MethodType IsMethodOrPropertyOrEvent(MethodDefinition method)
{
string methodName;
if (AnalysisUtils.IsMethodExplicitlyImplemented(method))
{
methodName = method.Name.Substring(method.Name.LastIndexOf('.') + 1);
}
else
{
methodName = method.Name;
}
if (methodName.StartsWith("get_") || methodName.StartsWith("set_"))
{
return(MethodType.PROPERTY);
}
else if (methodName.StartsWith("add_") || methodName.StartsWith("remove_"))
{
return(MethodType.EVENT);
}
else
{
return(MethodType.METHOD);
}
}
/// <summary>
/// 获取导套
/// </summary>
/// <param name="cylinder"></param>
/// <returns></returns>
public List <AbstractCylinderBody> GetGuideBushing(List <AbstractCylinderBody> cylinder)
{
List <AbstractCylinderBody> bush = new List <AbstractCylinderBody>();
foreach (AbstractCylinderBody ab in cylinder)
{
if (ab.Radius >= 6)
{
Vector3d vec1 = ab.Direction;
Vector3d vec2 = new Vector3d(-vec1.X, -vec1.Y, -vec1.Z);
int count1 = TraceARay.AskTraceARay(this.Body, ab.StratPt, vec1);
int count2 = TraceARay.AskTraceARay(this.Body, ab.StratPt, vec2);
if (count1 == 0 && count2 == 0)
{
List <Body> bodys = new List <Body>();
NXOpen.GeometricAnalysis.SimpleInterference.Result res = AnalysisUtils.SetInterferenceOutResult(this.Body, ab.Body, out bodys);
if (res == NXOpen.GeometricAnalysis.SimpleInterference.Result.OnlyEdgesOrFacesInterfere && bodys.Count == 0)
{
if (ab is CylinderBody)
{
ab.Name = "直司";
}
else
{
ab.Name = "托司";
}
bush.Add(ab);
continue;
}
}
}
}
return(bush);
}
private List <string> EleInterference(string Pich)
{
List <string> info = new List <string>();
Body eleBody = GetOccsInBods(this.eleModel.PartTag)[0];
foreach (Part work in this.workpiecePart)
{
List <Body> bodys = new List <Body>();
Body workpieceBody = GetOccsInBods(work)[0];
NXOpen.GeometricAnalysis.SimpleInterference.Result re = AnalysisUtils.SetInterferenceOutResult(eleBody, workpieceBody, out bodys);
if (re == NXOpen.GeometricAnalysis.SimpleInterference.Result.NoInterference)
{
info.Add(this.eleModel.AssembleName + " " + work.Name + Pich + "没有干涉！");
}
if (re == NXOpen.GeometricAnalysis.SimpleInterference.Result.InterferenceExists)
{
info.Add(this.eleModel.AssembleName + " " + work.Name + Pich + "有干涉！");
}
if (bodys.Count > 0)
{
foreach (Body body in bodys)
{
body.Layer = 252;
}
}
}
return(info);
}
/// <summary>
/// Try to generate a value for a given type that is not null (by calling the constructor).
/// It returns null only if we can't find a constructor to call or a know value to return
/// (like 0 for an int, string.Empty for a string ...).
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public string GenerateDefaultValue(TypeReference type, bool isRecursiveCall = false)
{
MethodDefinition constructorIfAny;
if (TryGetConstructor(type, out constructorIfAny))
{
string res = "new " + AnalysisUtils.GetFullTypeName(type, Configuration.TypesThatNeedToBeRenamed, Configuration.TypesThatNeedFullName, _outputOptions.OutputFullTypeName) + "(";
bool isFirstParam = true;
foreach (ParameterDefinition param in constructorIfAny.Parameters)
{
if (!isFirstParam)
{
res += ", ";
}
else
{
isFirstParam = false;
}
res += GenerateDefaultValue(param.ParameterType, true);
}
res += ")";
return(res);
}
else
{
return(AnalysisUtils.GetSafeTypeReferenceDefaultValueAsString(type, _outputOptions.OutputFullTypeName));
}
}
public void refreshSmartTraceTreeView()
{
tvSmartTrace.Nodes.Clear();
if (tvSmartTrace.Tag == null)
{
return;
}
var fviFindingViewItem = (FindingViewItem)tvSmartTrace.Tag;
if (fviFindingViewItem.fFinding.Trace != null)
{
//String sNodeText = fviFindingViewItem.fFinding.caller_name;
String sNodeText = "O2 Trace";
//(fviFindingViewItem.fFinding.caller_name != null) ? fviFindingViewItem.fFinding.caller_name : o2.analysis.Analysis.getStringIndexValue(UInt32.Parse(fviFindingViewItem.fFinding.caller_name_id), fviFindingViewItem.oadO2AssessmentDataOunceV6);
var tnRootNode = new TreeNode(sNodeText);
tnRootNode.Tag = fviFindingViewItem.fFinding;
AnalysisUtils.addCallsToNode_Recursive(fviFindingViewItem.fFinding.Trace, tnRootNode,
fviFindingViewItem.oadO2AssessmentDataOunceV6, stfSmartTraceFilter);
tvSmartTrace.Nodes.Add(tnRootNode.Nodes[0]);
tvSmartTrace.ExpandAll();
if (ascx_SelectVisiblePanels1.getCheckBox(4).Checked)
{
ascx_Glee1.setAssessmentData(fviFindingViewItem.oadO2AssessmentDataOunceV6);
ascx_Glee1.addTreeNodeToComboxWithNodesToPlot(tvSmartTrace.Nodes[0], fviFindingViewItem.fFinding,
fviFindingViewItem.oadO2AssessmentDataOunceV6);
// the way the Smart traces are build we want to add the 2nd child
ascx_Glee1.showLoadedTracesInGleeViewer();
}
}
ascx_SourceCodeEditor1.gotoLine(
fviFindingViewItem.oadO2AssessmentDataOunceV6.dFindings[fviFindingViewItem.fFinding].filename,
(Int32)fviFindingViewItem.fFinding.line_number);
}
/// <summary>
/// 干涉面
/// </summary>
public void GetInterferenceOfFace()
{
List <Tag> outFace = new List <Tag>();
Body eleBody = GetOccsInBods(this.eleModel.PartTag)[0];
Body workpieceBody = GetOccsInBods(this.workpiece)[0];
List <Face> faces = AnalysisUtils.SetInterferenceOutFace(eleBody, workpieceBody);
for (int i = 0; i < (faces.Count) / 2 - 1; i++)
{
FaceData data1 = FaceUtils.AskFaceData(faces[i * 2]);
FaceData data2 = FaceUtils.AskFaceData(faces[i * 2 + 1]);
if (data1.Equals(data2))
{
Tag face3;
NXOpen.Features.Feature feat1 = AssmbliesUtils.WaveFace(faces[i * 2]);
NXOpen.Features.Feature feat2 = AssmbliesUtils.WaveFace(faces[i * 2 + 1]);
Body[] bodys1 = (feat1 as NXOpen.Features.BodyFeature).GetBodies();
Body[] bodys2 = (feat2 as NXOpen.Features.BodyFeature).GetBodies();
Tag bodyTag1 = Intersect(bodys1[0], bodys2[0]);
if (bodyTag1 != Tag.Null)
{
outFace.Add(bodyTag1);
}
}
}
SewSolidBody(outFace);
}
/// <summary>
/// Check if parent type if abstract and get abstract methods that would have not been implemented if it is the case
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private HashSet <string> GetAbstractMethodsThatWouldntBeImlemented(TypeDefinition type)
{
HashSet <string> res = new HashSet <string>();
if (type.BaseType != null)
{
AddUsing(type.BaseType.Namespace);
TypeDefinition baseType = AnalysisUtils.GetTypeDefinitionFromTypeReference(type.BaseType, _modules);
if (baseType != null)
{
if (baseType.IsAbstract)
{
if (baseType.HasMethods)
{
foreach (MethodDefinition method in baseType.Methods)
{
if (AnalysisUtils.IsMethodAbstract(method))
{
if (MethodAnalyzer.IsMethodUnsupported(method) ||
analyzeHelpher._coreSupportedMethods.Contains(baseType.Namespace, baseType.Name, method.Name) ||
analyzeHelpher.IsMethodSupported(method))
{
res.Add(method.Name);
}
}
}
}
res.UnionWith(GetAbstractMethodsThatWouldntBeImlemented(baseType));
}
}
}
return(res);
}
/// <summary>
/// Analyze the current type and save the type generated from it.
/// </summary>
public void Execute()
{
if (AnalysisUtils.IsTypeADelegate(Element))
{
GetUsingsForDelegate(Element);
}
else if (!Element.IsEnum)
{
AnalyzeParentAndInterfacesType(Element);
if (Element.HasMethods)
{
AddConstructorToUnsupportedMethod();
HashSet <string> methodsFromInterfaces = GetMethodsInheritedFromInterfaces(Element);
_unsupportedMethodsInCurrentType.UnionWith(methodsFromInterfaces);
UpdateUnsupportedMethodsInfo(methodsFromInterfaces);
_unsupportedMethodsInCurrentType.UnionWith(GetAbstractMethodsThatWouldntBeImlemented(Element));
GetCustomAttributes(_unsupportedMethodsInCurrentType);
MethodAnalyzer.SetForType(_unsupportedMethodsInCurrentType, _hasAnIndexer);
foreach (MethodDefinition method in Element.Methods)
{
MethodAnalyzer.SetForMethod(method);
MethodAnalyzer.Run();
}
}
}
_typeBuilder.SetAndRun(Element, GetAdditionalCodeIfAny(_assemblyName, Element.Name), _implementedInterfaces, _hasAnIndexer, _assemblyName, 0);
//Used to make sure we don't implement twice the same type. A type could be generated once with a few methods and could be override afterward with less methods defined, but it can't be the other way.
_alreadyImplementedTypes.Add(_assemblyName + '.' + Element.FullName);
}
public void GetInterferenceOfArea()
{
Body eleBody = GetOccsInBods(this.eleModel.PartTag)[0];
Body workpieceBody = GetOccsInBods(this.workpiece)[0];
List <Face> faces = AnalysisUtils.SetInterferenceOutFace(eleBody, workpieceBody);
double minArea = 0;
for (int i = 0; i < (faces.Count) / 2 - 1; i++)
{
FaceData data1 = FaceUtils.AskFaceData(faces[i * 2]);
FaceData data2 = FaceUtils.AskFaceData(faces[i * 2 + 1]);
if (data1.Equals(data2))
{
double area1 = FaceUtils.GetFaceArea(faces[i * 2]);
double area2 = FaceUtils.GetFaceArea(faces[i * 2 + 1]);
if (area1 > area2)
{
minArea += area2;
}
else
{
minArea += area1;
}
}
}
AttributeUtils.AttributeOperation("Area", minArea, this.eleModel.PartTag);
}
private bool TryGetConstructor(TypeReference type, out MethodDefinition constructor, bool returnConstructorIfAbstractType = false)
{
if (!returnConstructorIfAbstractType)
{
TypeDefinition td = AnalysisUtils.GetTypeDefinitionFromTypeReference(type, _modules);
if (td == null || AnalysisUtils.IsTypeAbstract(td))
{
constructor = null;
return(false);
}
}
HashSet <MethodDefinition> constructors;
if (TryGetConstructors(type, out constructors))
{
constructor = ConvertConstructorToGenericInstanceMethod(GetConstructorWithMinimumParameters(constructors), type);
return(true);
}
// we should never be in this situation
else
{
constructor = null;
return(false);
}
}
/// <summary>
/// Analyze the current method and return a method generated from this one.
/// </summary>
/// <returns></returns>
public void Run()
{
if (!_isInitialized)
{
throw new Exception("MethodAnalyzer must be initialized. Please call Init() first.");
}
if (CanWorkOnElement())
{
_isMethodOrPropertyOrEvent = IsMethodOrPropertyOrEvent(Element);
CheckParametersAndReturnValueType();
string dependencyPropertyNameIfAny;
switch (_isMethodOrPropertyOrEvent)
{
case MethodType.PROPERTY:
PropertyDefinition property = FindProperty(Element, Element.DeclaringType);
if (AddDependencyPropertyIfDefined(property, out dependencyPropertyNameIfAny))
{
_parentClassAnalyzer.AddProperty(new Builder.PropertyInfo(property, true, dependencyPropertyNameIfAny));
}
else
{
if (!AnalysisUtils.IsMethodAbstract(property) && _outputOptions.OutputPropertyOptions == OutputPropertyOptions.OUTPUT_PRIVATE_FIELD)
{
string fieldName = property.Name.Contains(".") ? property.Name.Substring(property.Name.LastIndexOf('.') + 1) : property.Name;
fieldName = "_" + fieldName.Substring(0, 1).ToLower() + fieldName.Substring(1);
string newFieldName;
_parentClassAnalyzer.AddField(fieldName, property.PropertyType, false, false, AnalysisUtils.IsMethodStatic(property), null, null, out newFieldName);
_parentClassAnalyzer.AddProperty(new Builder.PropertyInfo(property, false, newFieldName));
}
else
{
_parentClassAnalyzer.AddProperty(new Builder.PropertyInfo(property));
}
}
break;
case MethodType.METHOD:
if (AddDependencyPropertyIfDefined(Element, out dependencyPropertyNameIfAny))
{
_parentClassAnalyzer.AddMethod(new Builder.MethodInfo(Element, Element.Name.StartsWith("Get"), Element.Name.StartsWith("Set"), dependencyPropertyNameIfAny));
}
else
{
_parentClassAnalyzer.AddMethod(new Builder.MethodInfo(Element));
}
break;
case MethodType.EVENT:
EventDefinition @event = FindEvent(Element, Element.DeclaringType);
_parentClassAnalyzer.AddEvent(@event);
break;
}
AddMethodToImplementedMethodsSet(Element);
}
}
public static void addVelocityMappings(TreeView tvRawData)
{
String sFunctionSignature = "ModelMap.addAttribute";
O2Timer tTimer = new O2Timer("Adding Velocity Mappings : {0} ").start();
Dictionary <AssessmentAssessmentFileFinding, O2AssessmentData_OunceV6> dMatches =
analyzer.getSinksFindingsThatMatchRegEx(tvRawData, sFunctionSignature);
foreach (AssessmentAssessmentFileFinding fFinding in dMatches.Keys)
{
// resolve addAddtibute name
String sSinkContext = AnalysisUtils.getSinkContext(fFinding, dMatches[fFinding]);
var fsFilteredSignature = new FilteredSignature(sSinkContext);
String sParameters = fsFilteredSignature.sParameters.Replace("\"", "");
String sSpringParameter = sParameters.Substring(0, sParameters.IndexOf(',')).Trim();
// create a unique name for it:
String sSink = AnalysisUtils.getSink(fFinding, dMatches[fFinding]);
// String sSinkWithAttributeName = sSink.Replace("(", "_" + sSpringParameter + "(");
String sVelocityMapping = String.Format("{0} 0", sSink);
TreeNode tnVelocityNode = tvRawData.Nodes[sSink];
if (tnVelocityNode != null)
{
var otbO2TraceBlockWithVelocityMappings = (O2TraceBlock_OunceV6)tnVelocityNode.Tag;
String sUniqueSignature = analyzer.getUniqueSignature(fFinding, TraceType.Known_Sink,
dMatches[fFinding], true);
var otbO2TraceBlockToAddVelocityMappings = (O2TraceBlock_OunceV6)tvRawData.Nodes[sUniqueSignature].Tag;
// sUniqueSignature = sUniqueSignature.Replace("_" + sSpringParameter + "(", "(");
// O2TraceBlock_OunceV6 otbO2TraceBlockToAddVelocityMappings = (O2TraceBlock_OunceV6)tvRawData.Nodes[sUniqueSignature].Tag;
if (otbO2TraceBlockWithVelocityMappings.dSinks.Count > 1)
{
}
foreach (
AssessmentAssessmentFileFinding fVelocityFinding in
otbO2TraceBlockWithVelocityMappings.dSinks.Keys)
{
if (false == otbO2TraceBlockToAddVelocityMappings.dGluedSinks.ContainsKey(fVelocityFinding))
{
otbO2TraceBlockToAddVelocityMappings.dGluedSinks.Add(fVelocityFinding,
otbO2TraceBlockWithVelocityMappings
.dSinks[fVelocityFinding]);
}
if (false == otbO2TraceBlockToAddVelocityMappings.dSinks.ContainsKey(fVelocityFinding))
{
otbO2TraceBlockToAddVelocityMappings.dSinks.Add(fVelocityFinding,
otbO2TraceBlockWithVelocityMappings.
dSinks[fVelocityFinding]);
}
}
}
}
}
public static Dictionary <AssessmentAssessmentFileFinding, O2AssessmentData_OunceV6> getSinksFindingsThatMatchRegEx(
TreeView tvRawData, String sRegExToSearch)
{
var dMatches = new Dictionary <AssessmentAssessmentFileFinding, O2AssessmentData_OunceV6>();
Dictionary <AssessmentAssessmentFileFinding, O2AssessmentData_OunceV6> dAllSinkFindings =
getUniqueListOfSinks(tvRawData);
foreach (AssessmentAssessmentFileFinding fFinding in dAllSinkFindings.Keys)
{
if (RegEx.findStringInString(AnalysisUtils.getSink(fFinding, dAllSinkFindings[fFinding]), sRegExToSearch))
{
dMatches.Add(fFinding, dAllSinkFindings[fFinding]);
}
}
return(dMatches);
}
/// <summary>
/// Initialyze the StubGenerator
/// </summary>
private void Init()
{
_outputOptions = Configuration.OutputOptions;
_inputAssemblies = GetAssemblies(Configuration.assembliesToAnalyzePath, true).ToArray <string>();
_referencedAssembliesFolderPath = Configuration.ReferencedAssembliesFolderPath;
_referencedAssembliesToLookInto = GetAssemblies(_referencedAssembliesFolderPath);
GetModules();
AnalysisUtils.SetModules(_modules);
GetUnsupportedMethods();
AddUndetectedMethodToUnsupportedMethods(Configuration.MethodsToAddManuallyBecauseTheyAreUndetected);
_assemblyAnalyzer = new AssemblyAnalyzer(
Configuration.SLMigrationCoreAssemblyFolderPath,
_unsupportedMethodsInfo,
_modules,
_outputOptions);
}
private MethodSignature GetSignatureOfSecondMethodOfPropertyFromFirstMethod(MethodDefinition method)
{
bool isExplicitlyImplemented = AnalysisUtils.IsMethodExplicitlyImplemented(method);
string name = GetNameOfPropertyOrEvent(method.Name);
string fromInterface = "";
string returnType;
bool hasParameters;
List <string> parameters = new List <string>();
if (isExplicitlyImplemented)
{
fromInterface = method.Name.Substring(0, method.Name.LastIndexOf('.') + 1);
}
string newPrefix;
if (method.Name.Contains("get_"))
{
newPrefix = "set_";
returnType = "System.Void";
hasParameters = true;
if (method.HasParameters)
{
foreach (ParameterDefinition param in method.Parameters)
{
parameters.Add(param.ParameterType.FullName);
}
}
parameters.Add(method.ReturnType.FullName);
}
else
{
newPrefix = "get_";
returnType = method.Parameters[method.Parameters.Count - 1].ParameterType.FullName;
hasParameters = (method.Parameters.Count > 1);
if (hasParameters)
{
for (int i = 0; i < method.Parameters.Count - 1; i++)
{
parameters.Add(method.Parameters[i].ParameterType.FullName);
}
}
}
string fullName = fromInterface + newPrefix + name;
return(new MethodSignature(fullName, returnType, hasParameters, parameters));
}
/// <summary>
/// Resolve inheritance issues
/// </summary>
/// <param name="assemblyName"></param>
/// <param name="typeName"></param>
/// <param name="methodName"></param>
/// <returns></returns>
private MethodInfo GetMethodInfoResolvingInheritance(string assemblyName, string typeName, string methodName)
{
TypeDefinition currentType = null;
int i = 0;
bool keepSearching = true;
while (i < _modules.Count && keepSearching)
{
ModuleDefinition module = _modules[i];
if (module.Name.Replace(".dll", "") == assemblyName)
{
if (module.HasTypes)
{
int j = 0;
while (j < module.Types.Count && keepSearching)
{
TypeDefinition type = module.Types[j];
if (type.Name == typeName)
{
currentType = type;
keepSearching = false;
}
j++;
}
}
keepSearching = false;
}
i++;
}
while (currentType != null)
{
if (currentType.HasMethods)
{
foreach (MethodDefinition method in currentType.Methods)
{
if (method.Name == methodName)
{
return(new MethodInfo(currentType.Scope.Name.Replace(".dll", ""), currentType.Name, methodName, true));
}
}
}
currentType = AnalysisUtils.GetTypeDefinitionFromTypeReference(currentType.BaseType, _modules);
}
return(new MethodInfo(assemblyName, typeName, methodName, true));
}
/// <summary>
/// 干涉检查
/// </summary>
/// <param name="eleCtBody"></param>
/// <param name="eleName"></param>
/// <param name="post"></param>
/// <param name="picth"></param>
/// <param name="err"></param>
private void Interference(Component eleCt, string eleName, string post, string picth, ref List <string> err)
{
Body eleCtBody = GetOccsInBods(eleCt);
foreach (Part pt in work.GetAllWorkpiece())
{
Component ptCoo = GetPartInOcc(pt);
if (ptCoo != null && !ptCoo.IsSuppressed)
{
Body by = GetOccsInBods(ptCoo);
List <Body> bodys = new List <Body>();
if (by != null)
{
try
{
NXOpen.GeometricAnalysis.SimpleInterference.Result re = AnalysisUtils.SetInterferenceOutResult(eleCtBody, by, out bodys);
if (re == NXOpen.GeometricAnalysis.SimpleInterference.Result.NoInterference)
{
err.Add(eleName + " " + pt.Name + picth + "没有干涉！");
}
if (re == NXOpen.GeometricAnalysis.SimpleInterference.Result.InterferenceExists)
{
err.Add(eleName + " " + pt.Name + picth + "有干涉！");
}
if (bodys.Count > 0)
{
foreach (Body body in bodys)
{
body.Layer = 252;
}
}
}
catch
{
ClassItem.WriteLogFile("干涉检查错误！");
}
}
else
{
err.Add(pt.Name + " 无法找到工件体，请检查引用集！");
}
}
}
}
public static void mapInterfaces(TreeView tvRawData, ICirData cdCirData, String sHardCodedInterfaceKeywork,
bool bAddGluedTracesAsRealTraces)
{
DI.log.debug("Mapping Interfaces");
O2Timer tTimer = new O2Timer("Interfaces mapping completed").start();
// Int32 iItemsProcessed = 0;
Dictionary <AssessmentAssessmentFileFinding, O2AssessmentData_OunceV6> dAllSinkFindings =
analyzer.getUniqueListOfSinks(tvRawData);
foreach (AssessmentAssessmentFileFinding fFinding in dAllSinkFindings.Keys)
{
String sSink = AnalysisUtils.getSink(fFinding, dAllSinkFindings[fFinding]);
if (sSink != "" && sSink.IndexOf(sHardCodedInterfaceKeywork) > -1)
{
if (false == cdCirData.dFunctions_bySignature.ContainsKey(sSink))
{
DI.log.error("in mapInterfaces, could not find signature in loaded CirData file: {0}",
sSink);
}
else
{
ICirFunction cfCirFunction = cdCirData.dFunctions_bySignature[sSink];
ICirClass ccCirClass = cfCirFunction.ParentClass;
foreach (ICirClass ccIsSuperClassedBy in ccCirClass.dIsSuperClassedBy.Values)
{
String sMappedMethodName = cfCirFunction.FunctionSignature.Replace(ccCirClass.Signature,
ccIsSuperClassedBy.
Signature);
List <O2TraceBlock_OunceV6> lotdMatches =
analyzer.getO2TraceBlocksThatMatchSignature(sMappedMethodName, tvRawData);
foreach (O2TraceBlock_OunceV6 otbO2TraceBlockWithTracesToGlue in lotdMatches)
{
addFindingAsGlueTrace(otbO2TraceBlockWithTracesToGlue, fFinding,
dAllSinkFindings[fFinding], tvRawData,
bAddGluedTracesAsRealTraces);
}
}
}
}
}
tTimer.stop();
}
/// <summary>
/// Check if a type define both get and set for a given property.
/// </summary>
/// <param name="methodToLookFor"></param>
/// <param name="typeToLookInto"></param>
/// <returns></returns>
private AccessModifierEnum IsPropertyMethodDefined(MethodSignature methodToLookFor, TypeDefinition typeToLookInto)
{
if (typeToLookInto != null)
{
if (typeToLookInto.HasMethods)
{
MethodSignature methodToCompare;
foreach (MethodDefinition m in typeToLookInto.Methods)
{
methodToCompare = new MethodSignature(m);
if (methodToLookFor == methodToCompare)
{
return(AnalysisUtils.GetMethodAccessModifier(m));
}
}
}
}
return(AccessModifierEnum.NONE);
}
private bool PrepareForAdditionalType(TypeReference type, HashSet <string> methods)
{
var typeDef = AnalysisUtils.GetTypeDefinitionFromTypeReference(type, _modules);
if (typeDef == null)
{
//we can't find the type.
return(false);
}
bool isCoreSupported = analyzeHelpher._coreSupportedMethods.ContainsType(type.Name, type.Namespace);
bool isMscorlibSupported = analyzeHelpher.IsTypeSupported(type);
if (isCoreSupported || isMscorlibSupported)
{
//type is already supported.
return(false);
}
Set(typeDef, methods);
return(true);
}
/// <summary>
/// 获得齿最小距离
/// </summary>
/// <returns></returns>
public double AskMinDim()
{
double min = 9999;
double[] pt1 = new double[3];
double[] pt2 = new double[3];
for (int i = 0; i < this.HeadBodys.Count - 1; i++)
{
for (int j = i + 1; j < this.HeadBodys.Count; j++)
{
double temp = AnalysisUtils.AskMinimumDist(this.HeadBodys[i].Tag, this.HeadBodys[j].Tag, out pt1, out pt2);
temp = Math.Round(temp, 3);
if (min >= temp)
{
min = temp;
}
}
}
return(min);
}
/// <summary>
/// If the member is "override", this method returns the type where the
/// corresponding "virtual" member is defined, otherwise it returns the
/// member declaring type.
/// </summary>
public static TypeReference GetDeclaringTypeResolvingOverrides(MemberReference memberReference)
{
if (Cache.ContainsKey(memberReference))
{
return(Cache[memberReference]);
}
else
{
TypeReference declaringType = memberReference.DeclaringType;
string memberName = memberReference.Name;
if (memberReference is MethodReference)
{
MethodReference methodReference = (MethodReference)memberReference;
MethodDefinition methodDefinition = null;
try
{
methodDefinition = methodReference.Resolve();
}
catch { }
if (methodDefinition != null)
{
if (AnalysisUtils.IsMethodOverride(methodDefinition))
{
TypeDefinition typeDefinition = AnalysisUtils.GetTypeDefinitionFromTypeReference(declaringType, null);
MethodDefinition methodIsFirstDefinitionInParentType = AnalysisUtils.LookForMethodInParents(methodDefinition, typeDefinition);
if (methodIsFirstDefinitionInParentType != null)
{
return(methodIsFirstDefinitionInParentType.DeclaringType);
}
}
}
}
Cache.Add(memberReference, declaringType);
return(declaringType);
}
}
private bool TryGetConstructors(TypeReference type, out HashSet <MethodDefinition> constructorsIfAny)
{
if (Constructors.ContainsKey(type))
{
constructorsIfAny = Constructors[type];
return(constructorsIfAny != null && constructorsIfAny.Count > 0);
}
else
{
bool isTypeWithNoConstructor;
if (AnalysisUtils.TryGetConstructors(type, _modules, out constructorsIfAny, out isTypeWithNoConstructor))
{
Constructors.Add(type, constructorsIfAny);
return(true);
}
else
{
constructorsIfAny = null;
Constructors.Add(type, null);
return(false);
}
}
}
public void Run()
{
if (!_isInitialized)
{
throw new Exception("ClassAnalyzer must be initialized. Please call Init() first.");
}
if (CanWorkOnElement())
{
Stack <TypeDefinition> typesToAnalyze = new Stack <TypeDefinition>();
// We don't directly analyze the selected type because we want to start with its "oldest" parent.
// Sometimes, we have to update our set of unsupported methods, so we need to start with the oldest parent to make sure we don't forget to implement a method from an interface or an abstract class which has been added during the execution of the program.
do
{
typesToAnalyze.Push(Element);
Element = AnalysisUtils.GetTypeDefinitionFromTypeReference(Element.BaseType, _modules);
}while (Element != null && (Element.FullName != "System.Object" || Element.FullName != "System.ValueType") && CanWorkOnElement(Element));
while (typesToAnalyze.Count > 0)
{
TypeDefinition firstParent = typesToAnalyze.Pop();
string parentAssembly = firstParent.Scope.Name.Replace(".dll", "");
HashSet <string> unsupportedMethodsInParent;
if (_unsupportedMethods.ContainsKey(parentAssembly))
{
if (_unsupportedMethods[parentAssembly].TryGetValue(firstParent.Name, out unsupportedMethodsInParent))
{
Set(firstParent, unsupportedMethodsInParent);
}
else
{
Set(firstParent, new HashSet <string>());
}
Execute();
}
}
}
}
/// <summary>
/// Executes the command.
/// Opens the AnalysisOptionsDialog, creates the export file, sends it to the Server and waits for it to have results.
/// </summary>
/// <param name="services">CommandServices object to interact with the system</param>
public override void Run(Canguro.Controller.CommandServices services)
{
gettingResults = false;
System.Windows.Forms.DialogResult result = services.ShowDialog(new Canguro.Commands.Model.AnalysisOptionsDialog(services));
string message = "";
if (result == System.Windows.Forms.DialogResult.Cancel)
{
services.Model.Undo.Rollback();
}
else if (result == System.Windows.Forms.DialogResult.OK)
{
try
{
System.Windows.Forms.Cursor cursor = System.Windows.Forms.Cursor.Current;
bool isConnected;
bool canAnalyze = false;
JoinCmd.RepairJoints(services.Model);
new Canguro.Commands.Model.UnselectCmd().Run(services);
if (!(canAnalyze = AnalysisUtils.CanAnalyze(services.Model, ref message, out isConnected)))
{
if (!isConnected)
{
if (System.Windows.Forms.MessageBox.Show(message, Culture.Get("error"),
System.Windows.Forms.MessageBoxButtons.YesNo, System.Windows.Forms.MessageBoxIcon.Error) ==
System.Windows.Forms.DialogResult.Yes)
{
System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.WaitCursor;
new JoinCmd().Run(services);
canAnalyze = AnalysisUtils.CanAnalyze(services.Model, ref message, out isConnected);
System.Windows.Forms.Cursor.Current = cursor;
}
else
{
return;
}
}
}
if (canAnalyze)
{
System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.WaitCursor;
string modelPath = System.IO.Path.GetTempFileName();
System.Diagnostics.Debug.WriteLine(modelPath);
FixPDelta(services.Model.AbstractCases);
Stream stream = File.Create(modelPath);
new Canguro.Model.Serializer.Serializer(services.Model).Serialize(stream, false);
stream.Close();
System.Windows.Forms.Cursor.Current = cursor;
System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.WaitCursor;
// TODO: ANALYZE STRUCTURE!!!
//analysisID = ws.Analyze(userNameURL, passwordURL, host, serial, file, analysisOptions, modelSize, quotation);
System.Windows.Forms.Cursor.Current = cursor;
services.Model.Results = new Canguro.Model.Results.Results(0);
// TODO: GET RESULTS
services.ReportProgress(5);
}
else // Can't analyze
{
if (!isConnected)
{
message = Culture.Get("structureIsDisconnectedWrn");
}
System.Windows.Forms.MessageBox.Show(message, Culture.Get("error"), System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
}
}
catch (Exception)
{
System.Windows.Forms.MessageBox.Show(Culture.Get("ErrorAnalyzing"), Culture.Get("error"), System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
}
}
}
/// <summary>
/// Executes the command.
/// Opens the SaveTo dialog, creates the xml file, sends it to the Server and waits for it to have the manifest for the exported s2k.
/// </summary>
/// <param name="services">CommandServices object to interact with the system</param>
public override void Run(Canguro.Controller.CommandServices services)
{
gettingResults = false;
try
{
string message = "";
System.Windows.Forms.Cursor cursor = System.Windows.Forms.Cursor.Current;
bool isConnected;
bool canAnalyze = false;
new Canguro.Commands.Model.UnselectCmd().Run(services);
// Verify model consistency for analysis (e.g. graph connectivity)
if (!(canAnalyze = AnalysisUtils.CanAnalyze(services.Model, ref message, out isConnected)))
{
if (!isConnected)
{
if (System.Windows.Forms.MessageBox.Show(message, Culture.Get("error"),
System.Windows.Forms.MessageBoxButtons.YesNo, System.Windows.Forms.MessageBoxIcon.Error) ==
System.Windows.Forms.DialogResult.Yes)
{
System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.WaitCursor;
new JoinCmd().Run(services);
canAnalyze = AnalysisUtils.CanAnalyze(services.Model, ref message, out isConnected);
System.Windows.Forms.Cursor.Current = cursor;
}
else
{
return;
}
}
}
if (canAnalyze)
{
System.Windows.Forms.SaveFileDialog dlg = new System.Windows.Forms.SaveFileDialog();
dlg.Filter = "S2K File (*.s2k)|*.s2k";
dlg.DefaultExt = "s2k";
dlg.AddExtension = true;
dlg.Title = Culture.Get("ExportS2KTitle");
if (!string.IsNullOrEmpty(services.Model.CurrentPath))
{
dlg.FileName = Path.Combine(Path.GetDirectoryName(services.Model.CurrentPath), Path.GetFileNameWithoutExtension(services.Model.CurrentPath)) + ".s2k";
}
else
{
dlg.FileName = Culture.Get("defaultModelName");
}
System.Windows.Forms.DialogResult result = (dlg).ShowDialog();
if (result == System.Windows.Forms.DialogResult.Cancel)
{
return;
}
string dstFile = dlg.FileName;
System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.WaitCursor;
// Serialize the model
string modelPath = System.IO.Path.GetTempFileName();
AnalysisCmd.FixPDelta(services.Model.AbstractCases);
Stream stream = File.Create(modelPath);
new Canguro.Model.Serializer.Serializer(services.Model).Serialize(stream, false);
stream.Close();
System.Windows.Forms.Cursor.Current = cursor;
System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.WaitCursor;
// Export to s2k
Export(modelPath, dstFile);
System.Windows.Forms.Cursor.Current = cursor;
}
else // Can't export
{
if (!isConnected)
{
message = Culture.Get("structureIsDisconnectedWrn");
}
System.Windows.Forms.MessageBox.Show(message, Culture.Get("error"), System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
}
}
catch (Exception)
{
System.Windows.Forms.MessageBox.Show(Culture.Get("ErrorExporting"), Culture.Get("error"), System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
}
}
/// <summary>
///检查体
/// </summary>
/// <returns></returns>
public BodyInfo GetBodyInfoForInterference(bool extract, out List <string> err)
{
err = new List <string>();
List <Face> dischargeFace = new List <Face>();
List <Face> temp = new List <Face>();
List <Body> bodys = new List <Body>();
try
{
AnalysisUtils.SetInterferenceOutFace(this.eleBody, this.toolBody, out temp, out bodys);
}
catch (NXException ex)
{
err.Add("干涉检查错误！" + ex.Message);
}
if (bodys.Count > 0)
{
LayerUtils.MoveDisplayableObject(252, bodys.ToArray());
if (extract)
{
this.eleBody.Color = 186;
}
err.Add("电极头有过切，请检查！");
}
dischargeFace = temp.Where(a => a.GetBody().Equals((this.eleBody))).Distinct().ToList(); //过滤电极面
List <Face> tt = temp.Where(a => a.GetBody().Equals((this.toolBody))).Distinct().ToList();
List <Face> faces = new List <Face>();
foreach (Face fe in dischargeFace)
{
FaceData data1 = FaceUtils.AskFaceData(fe);
foreach (Face fa in tt)
{
FaceData fd = FaceUtils.AskFaceData(fa);
if (UMathUtils.SelfDis(data1.Dir) == 0)
{
if (data1.FaceType == fd.FaceType && data1.IntNorm == -fd.IntNorm)
{
faces.Add(fe);
break;
}
}
else
{
double anlge = UMathUtils.Angle(data1.Dir, fd.Dir);
if (data1.FaceType == fd.FaceType && data1.IntNorm == -fd.IntNorm && UMathUtils.IsEqual(anlge, Math.PI))
{
faces.Add(fe);
break;
}
}
}
}
if (extract)
{
ExtractFace(this.toolBody, faces.ToArray());
}
BodyInfo info = new BodyInfo(eleBody, faces);
info.SetAttribute(csys, matr);
return(info);
}
private MethodDefinition ConvertConstructorToGenericInstanceMethod(MethodDefinition constructor, TypeReference declaringType)
{
if (!declaringType.IsGenericInstance)
{
return(constructor);
}
else
{
GenericInstanceType type = (GenericInstanceType)declaringType;
if (type.HasGenericArguments)
{
MethodAttributes attributes = MethodAttributes.RTSpecialName
| MethodAttributes.SpecialName
| MethodAttributes.Assembly;
MethodDefinition newConstructor = new MethodDefinition(".ctor", attributes, InstanceOfTypeSystem.Void);
foreach (ParameterDefinition param in constructor.Parameters)
{
if (param.ParameterType.IsGenericParameter)
{
int indexOfGenericType = 0;
foreach (GenericParameter genericParameter in type.ElementType.GenericParameters)
{
if (genericParameter.Name == param.ParameterType.Name)
{
break;
}
else
{
indexOfGenericType++;
}
}
if (indexOfGenericType < type.ElementType.GenericParameters.Count)
{
newConstructor.Parameters.Add(new ParameterDefinition(param.Name, param.Attributes, type.GenericArguments[indexOfGenericType]));
}
else
{
// this should not happen and will create an error in the generated code.
newConstructor.Parameters.Add(new ParameterDefinition(param.Name, param.Attributes, InstanceOfTypeSystem.Void));
}
}
else if (param.ParameterType.HasGenericParameters)
{
newConstructor.Parameters.Add(new ParameterDefinition(param.Name, param.Attributes, AnalysisUtils.MakeInstanceTypeFromTypeReference(param.ParameterType, type.GenericArguments.ToArray())));
}
else if (param.ParameterType.IsGenericInstance)
{
TypeReference paramElementType = ((GenericInstanceType)param.ParameterType).ElementType;
if (paramElementType.HasGenericParameters)
{
newConstructor.Parameters.Add(new ParameterDefinition(param.Name, param.Attributes, AnalysisUtils.MakeInstanceTypeFromTypeReference(paramElementType, type.GenericArguments.ToArray())));
}
else
{
newConstructor.Parameters.Add(new ParameterDefinition(param.Name, param.Attributes, param.ParameterType));
}
}
else
{
newConstructor.Parameters.Add(new ParameterDefinition(param.Name, param.Attributes, param.ParameterType));
}
}
return(newConstructor);
}
else
{
return(constructor);
}
}
}
public string CallBaseConstructorIfAny(MethodDefinition constructor, TypeReference declaringType = null)
{
MethodDefinition baseConstructor;
if (declaringType == null)
{
declaringType = constructor.DeclaringType;
}
if (TryGetBaseConstructorMatchingBestThisContructor(constructor, out baseConstructor))
{
if (!baseConstructor.HasParameters)
{
return("");
}
else
{
string res = " : base(";
bool isFirstParameter = true;
ParameterDefinition matchingParameter;
foreach (ParameterDefinition param in baseConstructor.Parameters)
{
matchingParameter = null;
if (!isFirstParameter)
{
res += ", ";
}
else
{
isFirstParameter = false;
}
if (AnalysisUtils.TryGetParameterMatchingVariableInMethodArguments(param.Name, param.ParameterType, constructor.Parameters, out matchingParameter))
{
res += "@" + matchingParameter.Name;
}
else
{
if (param.ParameterType.IsGenericParameter)
{
if (constructor.DeclaringType.BaseType.IsGenericInstance)
{
int genericParameterIndex = -1;
if (baseConstructor.DeclaringType.HasGenericParameters)
{
int index = 0;
foreach (GenericParameter gp in baseConstructor.DeclaringType.GenericParameters)
{
if (gp.Name == param.ParameterType.Name)
{
genericParameterIndex = index;
break;
}
index++;
}
}
if (genericParameterIndex > -1)
{
res += GenerateDefaultValue(((GenericInstanceType)constructor.DeclaringType.BaseType).GenericArguments[genericParameterIndex]);
}
}
}
else
{
res += GenerateDefaultValue(param.ParameterType);
}
}
}
res += ")";
return(res);
}
}
else
{
return("");
}
}
