private MemoryEntry getReverse_abs(MemoryEntry entry)
{
var values = new HashSet <Value>();
foreach (IntegerValue value in entry.PossibleValues)
{
values.Add(_outSet.CreateInt(value.Value));
values.Add(_outSet.CreateInt(-value.Value));
}
return(new MemoryEntry(values));
}
private void setOrderedArguments(FlowOutputSet callInput, MemoryEntry[] arguments)
{
var argCount = new MemoryEntry(callInput.CreateInt(arguments.Length));
var argCountEntry = callInput.GetVariable(new VariableIdentifier(".argument_count"));
argCountEntry.WriteMemory(callInput.Snapshot, argCount);
var index = 0;
var callPoint = (Flow.CurrentProgramPoint as ExtensionPoint).Caller as RCallPoint;
foreach (var arg in callPoint.Arguments)
{
var argVar = argument(index);
var argumentEntry = callInput.GetVariable(new VariableIdentifier(argVar));
//determine that argument value is based on variable, so we can get it's alias
var aliasProvider = arg as LValuePoint;
if (aliasProvider == null)
{
//assign value for parameter
argumentEntry.WriteMemory(callInput.Snapshot, arguments[index]);
}
else
{
//join parameter with alias (for testing we join all possible arguments)
//be carefull here - Flow.OutSet belongs to call context already - so we has to read variable from InSet
argumentEntry.SetAliases(callInput.Snapshot, aliasProvider.LValue);
}
++index;
}
}
public IntegerValue CreateInt(int number)
{
return(valueFactory.CreateInt(number));
}
/// <summary>
/// Creates new instance of NativeConstantAnalyzer. Is private because this class is singleton.
/// </summary>
/// <param name="outset">FlowOutputSet</param>
private NativeConstantAnalyzer(FlowOutputSet outset)
{
using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(Resources.php_constants)))
using (XmlReader reader = XmlReader.Create(stream))
{
string value = "";
string name = "";
string type = "";
HashSet <string> types = new HashSet <string>();
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
if (reader.Name == "constant")
{
name = reader.GetAttribute("name");
value = reader.GetAttribute("value");
}
else if (reader.Name == "type")
{
type = reader.GetAttribute("name");
types.Add(type);
}
break;
case XmlNodeType.Text:
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
break;
case XmlNodeType.Comment:
break;
case XmlNodeType.EndElement:
if (reader.Name == "constant")
{
QualifiedName qname = new QualifiedName(new Name(name));
Value constantValue = null;
switch (type)
{
case "boolean":
if (isValueUnknown(value))
{
constantValue = outset.AnyBooleanValue;
}
else
{
if (value == "1")
{
constantValue = outset.CreateBool(true);
}
else
{
constantValue = outset.CreateBool(false);
}
}
break;
case "integer":
if (isValueUnknown(value))
{
constantValue = outset.AnyIntegerValue;
}
else
{
constantValue = outset.CreateInt(int.Parse(value));
}
break;
case "string":
if (isValueUnknown(value))
{
constantValue = outset.AnyStringValue;
}
else
{
constantValue = outset.CreateString(value);
}
break;
case "NULL":
constantValue = outset.UndefinedValue;
break;
case "resource":
constantValue = outset.AnyResourceValue;
break;
case "double":
if (isValueUnknown(value))
{
constantValue = outset.AnyFloatValue;
}
else
{
switch (value)
{
case "NAN":
constantValue = outset.CreateDouble(double.NaN);
break;
case "INF":
constantValue = outset.CreateDouble(double.PositiveInfinity);
break;
default:
constantValue = outset.CreateDouble(double.Parse(value, __numberFormat));
break;
}
}
break;
default:
constantValue = outset.AnyValue;
break;
}
constants.Add(qname, new NativeConstant(qname, constantValue));
}
break;
}
}
}
/*
* var it = types.GetEnumerator();
* while (it.MoveNext())
* {
* Console.WriteLine(it.Current);
*
* }
*/
}
/// <inheritdoc />
public override void VisitIntLiteral(IntLiteral x)
{
literal = outSet.CreateInt((int)x.Value);
}
/// <summary>
/// Creates a new instance of NativeObjectAnalyzer. It parses the xml with information about the objects.
/// </summary>
/// <param name="outSet">FlowOutputSet</param>
private NativeObjectAnalyzer(FlowOutputSet outSet)
{
using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(Resources.php_classes)))
using (XmlReader reader = XmlReader.Create(stream))
{
nativeObjects = new Dictionary <QualifiedName, ClassDecl>();
NativeObjectsAnalyzerHelper.mutableNativeObjects = new Dictionary <QualifiedName, ClassDeclBuilder>();
Visibility methodVisibility = Visibility.PUBLIC;
ClassDeclBuilder currentClass = null;
NativeMethod currentMethod = null;
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
switch (reader.Name)
{
case "class":
case "interface":
currentClass = new ClassDeclBuilder();
var classFinal = reader.GetAttribute("isFinal");
if (classFinal == "true")
{
currentClass.IsFinal = true;
}
else
{
currentClass.IsFinal = false;
}
currentClass.QualifiedName = new QualifiedName(new Name(reader.GetAttribute("name")));
if (reader.GetAttribute("baseClass") != null)
{
currentClass.BaseClasses = new List <QualifiedName>();
currentClass.BaseClasses.Add(new QualifiedName(new Name(reader.GetAttribute("baseClass"))));
}
else
{
currentClass.BaseClasses = null;
}
NativeObjectsAnalyzerHelper.mutableNativeObjects[currentClass.QualifiedName] = currentClass;
if (reader.Name == "class")
{
currentClass.IsInterface = false;
}
else
{
currentClass.IsInterface = true;
}
break;
case "field":
string fieldName = reader.GetAttribute("name");
string fieldVisibility = reader.GetAttribute("visibility");
string fieldIsStatic = reader.GetAttribute("isStatic");
string fieldIsConst = reader.GetAttribute("isConst");
string fieldType = reader.GetAttribute("type");
fieldTypes.Add(fieldType);
Visibility visibility;
switch (fieldVisibility)
{
case "public":
visibility = Visibility.PUBLIC;
break;
case "protectd":
visibility = Visibility.PROTECTED;
break;
case "private":
visibility = Visibility.PRIVATE;
break;
default:
visibility = Visibility.PUBLIC;
break;
}
if (fieldIsConst == "false")
{
Value initValue = outSet.UndefinedValue;
string stringValue = reader.GetAttribute("value");
int intValue;
bool boolValue;
long longValue;
double doubleValue;
if (stringValue == null)
{
initValue = outSet.UndefinedValue;
}
else if (bool.TryParse(stringValue, out boolValue))
{
initValue = outSet.CreateBool(boolValue);
}
else if (int.TryParse(stringValue, out intValue))
{
initValue = outSet.CreateInt(intValue);
}
else if (long.TryParse(stringValue, out longValue))
{
initValue = outSet.CreateLong(longValue);
}
else if (double.TryParse(stringValue, out doubleValue))
{
initValue = outSet.CreateDouble(doubleValue);
}
else
{
initValue = outSet.CreateString(stringValue);
}
currentClass.Fields[new FieldIdentifier(currentClass.QualifiedName, new VariableName(fieldName))] = new FieldInfo(new VariableName(fieldName), currentClass.QualifiedName, fieldType, visibility, new MemoryEntry(initValue), bool.Parse(fieldIsStatic));
}
else
{
string value = reader.GetAttribute("value");
//resolve constant
VariableName constantName = new VariableName(fieldName);
var constIdentifier = new FieldIdentifier(currentClass.QualifiedName, constantName);
switch (fieldType)
{
case "int":
case "integer":
try
{
currentClass.Constants[constIdentifier] = new ConstantInfo(constantName, currentClass.QualifiedName, visibility, new MemoryEntry(outSet.CreateInt(int.Parse(value))));
}
catch (Exception)
{
currentClass.Constants[constIdentifier] = new ConstantInfo(constantName, currentClass.QualifiedName, visibility, new MemoryEntry(outSet.CreateDouble(double.Parse(value))));
}
break;
case "string":
currentClass.Constants[constIdentifier] = new ConstantInfo(constantName, currentClass.QualifiedName, visibility, new MemoryEntry(outSet.CreateString(value)));
break;
case "boolean":
currentClass.Constants[constIdentifier] = new ConstantInfo(constantName, currentClass.QualifiedName, visibility, new MemoryEntry(outSet.CreateBool(bool.Parse(value))));
break;
case "float":
currentClass.Constants[constIdentifier] = new ConstantInfo(constantName, currentClass.QualifiedName, visibility, new MemoryEntry(outSet.CreateDouble(double.Parse(value))));
break;
case "NULL":
currentClass.Constants[constIdentifier] = new ConstantInfo(constantName, currentClass.QualifiedName, visibility, new MemoryEntry(outSet.UndefinedValue));
break;
default:
break;
}
}
break;
case "method":
currentMethod = new NativeMethod(new QualifiedName(new Name(reader.GetAttribute("name"))), reader.GetAttribute("returnType"), new List <NativeFunctionArgument>());
currentMethod.IsFinal = bool.Parse(reader.GetAttribute("final"));
currentMethod.IsStatic = bool.Parse(reader.GetAttribute("static"));
returnTypes.Add(reader.GetAttribute("returnType"));
if (currentMethod.Name == new QualifiedName(new Name("getLastErrors")))
{
}
methodVisibility = Visibility.PUBLIC;
if (reader.GetAttribute("visibility") == "private")
{
methodVisibility = Visibility.PRIVATE;
}
else if (reader.GetAttribute("visibility") == "protected")
{
methodVisibility = Visibility.PROTECTED;
}
else
{
methodVisibility = Visibility.PUBLIC;
}
if (reader.IsEmptyElement)
{
NativeAnalyzerMethod analyzer;
if (currentMethod.Name.Name.Equals(new Name("__construct")))
{
analyzer = new NativeObjectsAnalyzerHelper(currentMethod, currentClass.QualifiedName).Construct;
}
else
{
analyzer = new NativeObjectsAnalyzerHelper(currentMethod, currentClass.QualifiedName).Analyze;
}
MethodInfo methodInfo = new MethodInfo(currentMethod.Name.Name, currentClass.QualifiedName, methodVisibility, analyzer, currentMethod.ConvertArguments(), currentMethod.IsFinal, currentMethod.IsStatic, currentMethod.IsAbstract);
currentClass.ModeledMethods[new MethodIdentifier(currentClass.QualifiedName, methodInfo.Name)] = methodInfo;
}
break;
case "arg":
currentMethod.Arguments.Add(new NativeFunctionArgument(reader.GetAttribute("type"), bool.Parse(reader.GetAttribute("optional")), bool.Parse(reader.GetAttribute("byReference")), bool.Parse(reader.GetAttribute("dots"))));
methodTypes.Add(reader.GetAttribute("type"));
break;
}
break;
case XmlNodeType.Text:
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
break;
case XmlNodeType.Comment:
break;
case XmlNodeType.EndElement:
switch (reader.Name)
{
case "method":
NativeAnalyzerMethod analyzer;
if (currentMethod.Name.Name.Equals(new Name("__construct")))
{
analyzer = new NativeObjectsAnalyzerHelper(currentMethod, currentClass.QualifiedName).Construct;
}
else
{
analyzer = new NativeObjectsAnalyzerHelper(currentMethod, currentClass.QualifiedName).Analyze;
}
MethodInfo methodInfo = new MethodInfo(currentMethod.Name.Name, currentClass.QualifiedName, methodVisibility, analyzer, currentMethod.ConvertArguments(), currentMethod.IsFinal, currentMethod.IsStatic, currentMethod.IsAbstract);
currentClass.ModeledMethods[new MethodIdentifier(currentClass.QualifiedName, methodInfo.Name)] = methodInfo;
break;
}
break;
}
}
}
/*
* check if every ancestor exist
*/
foreach (var nativeObject in NativeObjectsAnalyzerHelper.mutableNativeObjects.Values)
{
if (nativeObject.QualifiedName != null)
{
if (!NativeObjectsAnalyzerHelper.mutableNativeObjects.ContainsKey(nativeObject.QualifiedName))
{
throw new Exception();
}
}
}
//generate result
foreach (var nativeObject in NativeObjectsAnalyzerHelper.mutableNativeObjects.Values)
{
List <QualifiedName> newBaseClasses = new List <QualifiedName>();
if (nativeObject.BaseClasses != null)
{
QualifiedName baseClassName = nativeObject.BaseClasses.Last();
while (true)
{
newBaseClasses.Add(baseClassName);
var baseClass = NativeObjectsAnalyzerHelper.mutableNativeObjects[baseClassName];
foreach (var constant in baseClass.Constants)
{
nativeObject.Constants[constant.Key] = constant.Value;
}
foreach (var field in baseClass.Fields)
{
nativeObject.Fields[field.Key] = field.Value;
}
foreach (var method in baseClass.ModeledMethods)
{
nativeObject.ModeledMethods[method.Key] = method.Value;
}
if (baseClass.BaseClasses != null && baseClass.BaseClasses.Count > 0)
{
baseClassName = baseClass.BaseClasses.Last();
}
else
{
break;
}
}
}
newBaseClasses.Reverse();
nativeObject.BaseClasses = newBaseClasses;
nativeObjects[nativeObject.QualifiedName] = nativeObject.Build();
}
initReportingFunctions();
initCleaningFunctions();
}