/// <summary>
/// this will return the current CirFunction object for the signature provided or create a new CirFunction
/// object and return it
/// </summary>
/// <param name="cirData"></param>
/// <param name="functionSignature"></param>
/// <param name="functionType"></param>
/// <returns></returns>
public ICirFunction getCirFunction(ICirData cirData, string functionSignature, string functionType)
{
try
{
if (cirData.dFunctions_bySignature.ContainsKey(functionSignature))
return cirData.dFunctions_bySignature[functionSignature];
// create the function reference
var newCirFunction = new CirFunction(functionSignature);
cirData.dFunctions_bySignature.Add(functionSignature, newCirFunction);
// add it to the respective CirClas
var cirClass = getCirClass(cirData,functionType);
cirClass.dFunctions.Add(functionSignature, newCirFunction);
return newCirFunction;
}
catch (Exception ex)
{
DI.log.ex(ex, "in CirFactory.getCirFunction", true);
return null;
}
}
public ICirFunction addFunction(string newFunctionSignature)
{
if (newFunctionSignature == null || dFunctions.ContainsKey(newFunctionSignature))
{
return(null);
}
var cirFunction = new CirFunction(newFunctionSignature);
dFunctions.Add(newFunctionSignature, cirFunction);
return(cirFunction);
}
public ICirFunction addCalledFunction(string calledFunctionSignature, string file, int lineNumber)
{
ICirFunction calledCirFunction = null;
foreach (var existingCirFunctionCallReference in FunctionsCalledUniqueList)
{
if (calledFunctionSignature == existingCirFunctionCallReference.FunctionSignature)
{
calledCirFunction = existingCirFunctionCallReference;
}
}
if (calledCirFunction == null) // means we have not mapped a function with this signature before
{
calledCirFunction = new CirFunction(calledFunctionSignature);
calledCirFunction.File = file;
FunctionsCalledUniqueList.Add(calledCirFunction);
}
FunctionsCalled.Add(new CirFunctionCall(calledCirFunction, calledCirFunction.File, lineNumber));
return(calledCirFunction);
}
private bool processFunctionAndAddItToNode(TreeNodeCollection tncTargetNode, CirFunction cfCirFunction,
List<String> lsFunctionsAdded)
{
bool bMakesCallTo = false;
TreeNode tnMethod = O2Forms.newTreeNode(cfCirFunction.FunctionSignature, "", 2, cfCirFunction);
// add arguments and return value
if (cbShowArgsAndReturntype.Checked)
{
if (cfCirFunction.ReturnType != "")
tnMethod.Nodes.Add(
O2Forms.newTreeNode(
String.Format("retv: {0}", CirDataUtils.getSymbol(fcdCirData,cfCirFunction.ReturnType)), "", 3, null));
foreach (ICirFunctionParameter functionParameter in cfCirFunction.FunctionParameters)
tnMethod.Nodes.Add(O2Forms.newTreeNode(String.Format("arg: {0}", CirDataUtils.getSymbol(fcdCirData, functionParameter.ParameterType)),
"", 3, null));
}
// add variables
if (rbShowFieldsAndVariables.Checked)
{
foreach (String sSymbolRef in cfCirFunction.UsedTypes)
tnMethod.Nodes.Add(O2Forms.newTreeNode(String.Format("v: {0}", CirDataUtils.getSymbol(fcdCirData,sSymbolRef)), "",
4, null));
}
// add functions called by this method &
foreach (ICirFunction cirFunctionCalled in cfCirFunction.FunctionsCalledUniqueList)
{
var sSignature = cirFunctionCalled.FunctionSignature;
bool bAddSignature = false;
String sSignatureWithParams = sSignature.Substring(0, sSignature.IndexOf('('));
if ((false == cbCirAnalyzer_TextFilter_MakesCallsTo.Checked &&
false == cbCirAnalyzer_TextFilter_RemoveMakesCallsTo.Checked))
bAddSignature = true;
bool bMatchOnRemovesMakesCallTo = (cbCirAnalyzer_TextFilter_RemoveMakesCallsTo.Checked &&
sSignatureWithParams.IndexOf(
(string) tbCirAnalyszer_TextSearchFilter_RemoveMakesCallsTo.Text) == -1);
bool bMatchOnMakesCallTo = (cbCirAnalyzer_TextFilter_MakesCallsTo.Checked &&
sSignatureWithParams.IndexOf(
(string) tbCirAnalyszer_TextSearchFilter_MakesCallsTo.Text) > -1);
if ((bMatchOnRemovesMakesCallTo && false == cbCirAnalyzer_TextFilter_MakesCallsTo.Checked) ||
(bMatchOnMakesCallTo && false == cbCirAnalyzer_TextFilter_RemoveMakesCallsTo.Checked) ||
(bMatchOnRemovesMakesCallTo && bMatchOnMakesCallTo))
bAddSignature = true;
if (bAddSignature)
{
lsFunctionsAdded.Add(sSignature);
bMakesCallTo = true;
tnMethod.Nodes.Add(O2Forms.newTreeNode(String.Format("fCalled: {0}", sSignature), "", 10, null));
}
}
// add functions that call this method
foreach (ICirFunction cirIsCalledFunction in cfCirFunction.FunctionIsCalledBy)
tnMethod.Nodes.Add(O2Forms.newTreeNode(String.Format("isCalledBy: {0}", cirIsCalledFunction.FunctionSignature), "", 11, null));
if (cbCirAnalyzer_TextFilter_MakesCallsTo.Checked && false == bMakesCallTo)
return false;
tncTargetNode.Add(tnMethod);
return true;
}
public ICirFunction addCalledFunction(string calledFunctionSignature, string file, int lineNumber)
{
ICirFunction calledCirFunction = null;
foreach (var existingCirFunctionCallReference in FunctionsCalledUniqueList)
if (calledFunctionSignature == existingCirFunctionCallReference.FunctionSignature)
calledCirFunction = existingCirFunctionCallReference;
if (calledCirFunction == null) // means we have not mapped a function with this signature before
{
calledCirFunction = new CirFunction(calledFunctionSignature);
calledCirFunction.File = file;
FunctionsCalledUniqueList.Add(calledCirFunction);
}
FunctionsCalled.Add(new CirFunctionCall(calledCirFunction, calledCirFunction.File, lineNumber));
return calledCirFunction;
}
public void showDataForSignature(String sSignature)
{
// check if this function is on the current list (if not this is an edge)
if (false == cirDataAnalysis.dCirFunction_bySignature.ContainsKey(sSignature))
// this case do a hack by adding this edge as a function
{
var lsFunctionsThatCallSignature = new List<ICirFunctionCall>();
// first find everybody that calls into it
foreach (ICirFunction ccFunction in cirDataAnalysis.dCirFunction_bySignature.Values)
if (cirDataAnalysis.dCirFunction_bySignature.ContainsKey(sSignature))
if (ccFunction.FunctionsCalledUniqueList.Contains( cirDataAnalysis.dCirFunction_bySignature[sSignature]))
lsFunctionsThatCallSignature.Add(new CirFunctionCall(ccFunction));
var ccNewCirFunction = new CirFunction
{
FunctionSignature = sSignature,
FunctionIsCalledBy = lsFunctionsThatCallSignature
};
cirDataAnalysis.dCirFunction_bySignature.Add(sSignature, ccNewCirFunction);
}
var tvTraces = new TreeView();
var lFunctionsCalled = new List<string>();
const string sFilter_Signature = "";
const string sFilter_Parameter = "";
if (cbSearchMode.SelectedItem.ToString() == SearchModes.CalledFunctions.ToString())
TraceAnalysis.calculateAllTracesFromFunction(sSignature, tvTraces.Nodes, lFunctionsCalled,
sFilter_Signature, sFilter_Parameter, false,
cirDataAnalysis);
else
TraceAnalysis.calculateAllTracesFromFunction(sSignature, tvTraces.Nodes, lFunctionsCalled,
sFilter_Signature, sFilter_Parameter, true, cirDataAnalysis);
if (cbViewMode.SelectedItem.ToString() == ViewModes.List.ToString())
afv_Functions.showSignatures(lFunctionsCalled);
else
{
replaceTreeView(this, ref tvTreeView, tvTraces);
if (cbSearchMode.SelectedItem.ToString() == SearchModes.IsCalledBy.ToString())
tvTreeView.ExpandAll();
}
}
public static Dictionary<String, ICirFunction> analysis_getFunctionsThatHaveACallPathIntoFunction(
CirFunction cfTargetFunction, String sParameterFilter)
{
var dMatches = new Dictionary<string, ICirFunction>();
return dMatches;
}
// these Functions contains multiple analysis on o2CirDump data
/* public enum searchFilter
{
byClassName,
byFunctionName,
byParameterName
}*/
public static Dictionary<String, ICirFunction> analysis_getFunctionsThatHaveACallPathIntoFunction(
CirFunction cfTargetFunction)
{
return analysis_getFunctionsThatHaveACallPathIntoFunction(cfTargetFunction, "");
}
public static ICirFunction addFunction(ICirData cirData, Object oFunction, ICirClass ccCirClass)
{
ICirFunction cfCirFunction = null;
try
{
String sSignature = DI.reflection.getProperty("UniqueID", oFunction).ToString();
String sSymbolRef = DI.reflection.getProperty("SymbolRef", oFunction).ToString();
if (cirData.dFunctions_bySignature.ContainsKey(sSignature))
cfCirFunction = cirData.dFunctions_bySignature[sSignature];
if (cfCirFunction == null)
{
// create method object
cfCirFunction = new CirFunction { SymbolDef = sSymbolRef };
// ccCirClass.dFunctions.Add(sSymbolRef, cfCirFunction);
cirData.dFunctions_bySignature.Add(sSignature, cfCirFunction);
//cirData.dTemp_Functions_bySymbolDef.Add(sSymbolRef, cfCirFunction);
//addSymbol(cirData,sSymbolRef, sSignature);
/*if (cirData.dFunctions_bySymbolDef.ContainsKey(sSymbolRef))
{
cfCirFunction.FunctionParameters = cirData.dFunctions_bySymbolDef[sSymbolRef].FunctionParameters;
cfCirFunction.ReturnType = cirData.dFunctions_bySymbolDef[sSymbolRef].ReturnType; // _TODO: _BUG: I think there is a bug here where the ReturnType is not correctly set for ALL funtions
}*/
}
cfCirFunction.ParentClass = ccCirClass;
if (cfCirFunction.FunctionSignature != "" && cfCirFunction.FunctionSignature != sSignature) // error
{
DI.log.error("In addFunction cfCirFunction.FunctionSignature != FunctionSignature : {0} {1} != {2}",
sSymbolRef, cfCirFunction.FunctionSignature, sSignature);
return cfCirFunction;
}
//if (ccCirClass.dFunctions.ContainsKey(sSymbolRef)) // means we already processed this method
// return cfCirFunction;
//cmNewcirFunction.FunctionSignature = cmfMemberFunction.UniqueID;
// there are generic for both Static and Member Functions so we can use reflection to get them
cfCirFunction.FunctionSignature = sSignature;
// addSymbol(sSymbolRef, FunctionSignature); // this will make sure the dSymbol href table is correctly populated
//cfCirFunction.sSymbolRef = sSymbolRef;
// add Variables
processFunctionVariables(cirData,cfCirFunction, oFunction);
// process ControlFlowGraphs
if (processControlFlowGraph(cirData,cfCirFunction, oFunction))
if (null != ccCirClass)
ccCirClass.bClassHasMethodsWithControlFlowGraphs = true;
// keep track if this class has methods with ControlFlowGraphs
// add method to dClasses
if (null != ccCirClass && false == ccCirClass.dFunctions.ContainsKey(sSignature))
{
ccCirClass.dFunctions.Add(sSignature, cfCirFunction);
}
}
catch (Exception ex)
{
DI.log.error("in addFunction: {0}", ex.Message);
}
return cfCirFunction;
}
public static ICirFunction addFunction(ICirData cirData, String sSymbolRef, String sSignature)
{
if (cirData.dFunctions_bySignature.ContainsKey(sSignature))
{
// if (dSymbols[sSymbolRef] == CONST_NEED_SIGNATURE)
// dSymbols[sSymbolRef] = FunctionSignature;
return cirData.dFunctions_bySignature[sSignature];
}
var cfCirFunction = new CirFunction { SymbolDef = sSymbolRef, FunctionSignature = sSignature };
addSymbol(cirData, sSymbolRef, sSignature);
cirData.dFunctions_bySignature.Add(sSignature, cfCirFunction);
//mapFunctionCall(cirData, cfCirFunction, sSymbolRef, sSignature);
return cfCirFunction;
}
public static ICirFunction createTempCirFunctionWithReturnTypeAndArguments(ICirData cirData, CommonIRDumpCommonIRFunctionSigType fsSymbol)
{
//String sSymbolDef = fsSymbol.SymbolDef;
ICirFunction cfCirFunction = new CirFunction {};
//ICirFunction cfCirFunction;
/* var functionSignature = getSymbol(cirData, sSymbolDef);
if (cirData.dTemp_Functions_bySymbolDef.ContainsKey(sSymbolDef))
cfCirFunction = cirData.dTemp_Functions_bySymbolDef[sSymbolDef];
else
{
cfCirFunction = new CirFunction { SymbolDef = sSymbolDef };
cirData.dFunctions_bySignature.Add(functionSignature, cfCirFunction);
cirData.dTemp_Functions_bySymbolDef.Add(sSymbolDef, cfCirFunction);
//addSymbol(cirData, sSymbolDef, DI.CONST_NEED_SIGNATURE); // create an SymbolRef with no signature
}
/*if (cirData.dFunctions_bySymbolDef.ContainsKey(sSymbolDef))
cfCirFunction = cirData.dFunctions_bySymbolDef[sSymbolDef];
else
{
cfCirFunction = new CirFunction { SymbolDef = sSymbolDef };
cirData.dFunctions_bySignature.Add(functionSignature, cfCirFunction);
cirData.dFunctions_bySymbolDef.Add(sSymbolDef, cfCirFunction);
//addSymbol(cirData, sSymbolDef, DI.CONST_NEED_SIGNATURE); // create an SymbolRef with no signature
}*/
//if (cfCirFunction.ReturnType == "") // check if these values have been set
//{
//cfCirFunction.ReturnType = fsSymbol.ReturnType.SymbolRef;
cfCirFunction.ReturnType = fsSymbol.ReturnType.PrintableType;
//addSymbol(cirData, fsSymbol.ReturnType.SymbolRef, fsSymbol.ReturnType.PrintableType);
if (fsSymbol.ArgumentTypes != null)
foreach (CommonIRDumpCommonIRFunctionSigTypeArgument fsArgumentType in fsSymbol.ArgumentTypes)
{
if (false == ViewHelpers.getCirParameterTypeStringList(cfCirFunction.FunctionParameters).Contains(fsArgumentType.SymbolRef))
// if there are probs with more arguments than reality, i will need to add
// a more thorough check here (one that handles the differences between the first time data is added (which makes it an 'add' )
// and the 2nd time (which makes it an 'confirm that they are the same' )
{
cfCirFunction.FunctionParameters.Add(new CirFunctionParameter { ParameterName = "", ParameterType = fsArgumentType.PrintableType });//fsArgumentType.SymbolRef});
//addSymbol(cirData, fsArgumentType.SymbolRef, fsArgumentType.PrintableType);
}
}
//}
/*else if (cfCirFunction.ReturnType != fsSymbol.ReturnType.SymbolRef)
// double check that nothing major is wrong, since these values should match
DI.log.error(
"in addToFunction_ArgumentsAndReturnType, cfCirFunction.ReturnType != fsSymbol.ReturnType.SymbolRef: {0} != {1}",
cfCirFunction.ReturnType, fsSymbol.ReturnType.SymbolRef);*/
return cfCirFunction;
}
public ICirFunction addFunction(string newFunctionSignature)
{
if (newFunctionSignature == null || dFunctions.ContainsKey(newFunctionSignature))
return null;
var cirFunction = new CirFunction(newFunctionSignature);
dFunctions.Add(newFunctionSignature, cirFunction);
return cirFunction;
}