private Dictionary <object, FunctionValue> resolveMethod(ReadSnapshotEntryBase thisObject, QualifiedName methodName)
{
NativeAnalyzerMethod analyzer;
var result = new Dictionary <object, FunctionValue>();
if (_nativeAnalyzers.TryGetValue(methodName.Name.Value, out analyzer))
{
//we have native analyzer - create it's program point graph
var function = OutSet.CreateFunction(methodName.Name, new NativeAnalyzer(analyzer, Flow.CurrentPartial));
result[function.DeclaringElement] = function;
}
else
{
var methods = thisObject.ResolveMethod(OutSnapshot, methodName);
foreach (var method in methods)
{
result[method.DeclaringElement] = method;
}
}
return(result);
}
private Dictionary <object, FunctionValue> resolveFunction(QualifiedName name)
{
NativeAnalyzerMethod analyzer;
var result = new Dictionary <object, FunctionValue>();
if (_nativeAnalyzers.TryGetValue(name.Name.Value, out analyzer))
{
//we have native analyzer - create it's program point graph
var function = OutSet.CreateFunction(name.Name, new NativeAnalyzer(analyzer, Flow.CurrentPartial));
result[function.DeclaringElement] = function;
}
else
{
var functions = OutSet.ResolveFunction(name);
foreach (var function in functions)
{
result[function.DeclaringElement] = function;
}
}
return(result);
}
/// <summary>
/// Creates new function implementation without name from lambda declaration
/// </summary>
/// <param name="lambda">Definition of lambda function</param>
/// <returns>New function implementation</returns>
public virtual MemoryEntry CreateLambda(LambdaFunctionExpr lambda)
{
return(new MemoryEntry(OutSet.CreateFunction(lambda, Flow.CurrentScript)));
}
private ClassDecl convertToType(TypeDecl declaration)
{
ClassDeclBuilder result = new ClassDeclBuilder();
result.BaseClasses = new List <QualifiedName>();
if (declaration.BaseClassName.HasValue)
{
result.BaseClasses.Add(declaration.BaseClassName.Value.QualifiedName);
}
result.IsFinal = declaration.Type.IsFinal;
result.IsInterface = declaration.Type.IsInterface;
result.IsAbstract = declaration.Type.IsAbstract;
result.QualifiedName = new QualifiedName(declaration.Name);
foreach (var member in declaration.Members)
{
if (member is FieldDeclList)
{
foreach (FieldDecl field in (member as FieldDeclList).Fields)
{
Visibility visibility;
if (member.Modifiers.HasFlag(PhpMemberAttributes.Private))
{
visibility = Visibility.PRIVATE;
}
else if (member.Modifiers.HasFlag(PhpMemberAttributes.Protected))
{
visibility = Visibility.PROTECTED;
}
else
{
visibility = Visibility.PUBLIC;
}
bool isStatic = member.Modifiers.HasFlag(PhpMemberAttributes.Static);
//multiple declaration of fields
if (result.Fields.ContainsKey(new FieldIdentifier(result.QualifiedName, field.Name)))
{
//dont need to set warning in simpleAnalysis
// setWarning("Cannot redeclare field " + field.Name, member, AnalysisWarningCause.CLASS_MULTIPLE_FIELD_DECLARATION);
}
else
{
result.Fields.Add(new FieldIdentifier(result.QualifiedName, field.Name), new FieldInfo(field.Name, result.QualifiedName, "any", visibility, field.Initializer, isStatic));
}
}
}
else if (member is ConstDeclList)
{
foreach (var constant in (member as ConstDeclList).Constants)
{
if (result.Constants.ContainsKey(new FieldIdentifier(result.QualifiedName, constant.Name)))
{
//dont need to set warning in simpleAnalysis
// setWarning("Cannot redeclare constant " + constant.Name, member, AnalysisWarningCause.CLASS_MULTIPLE_CONST_DECLARATION);
}
else
{
//in php all object constatns are public
Visibility visbility = Visibility.PUBLIC;
result.Constants.Add(new FieldIdentifier(result.QualifiedName, constant.Name), new ConstantInfo(constant.Name, result.QualifiedName, visbility, constant.Initializer));
}
}
}
else if (member is MethodDecl)
{
var methosIdentifier = new MethodIdentifier(result.QualifiedName, (member as MethodDecl).Name);
if (!result.SourceCodeMethods.ContainsKey(methosIdentifier))
{
result.SourceCodeMethods.Add(methosIdentifier, OutSet.CreateFunction(member as MethodDecl, Flow.CurrentScript));
}
else
{
//dont need to set warning in simpleAnalysis
// setWarning("Cannot redeclare constant " + (member as MethodDecl).Name, member, AnalysisWarningCause.CLASS_MULTIPLE_CONST_DECLARATION);
}
}
else
{
//ignore traits are not supported by AST, only by parser
}
}
// NativeTypeDecl result=new NativeTypeDecl();
return(result.Build());
}