public void Conditional_Is_Visible_With_True(string condition)
{
var target = new VariableResolver(new List <Variable>());
var result = target.TransformVariables("Hello\n<!--[if " + condition + "]-->\ntobi!\n<!--[endif]-->");
Assert.AreEqual("Hello\r\ntobi!", result);
}
public void Multiple_Conditional_Transforming(string condition1, string condition2, string assert)
{
var variableList = new List <Variable>()
{
new Variable()
{
Name = "true.condition", Value = "true"
},
new Variable()
{
Name = "false.condition", Value = "false"
},
};
var target = new VariableResolver(variableList);
var result = target.TransformVariables("<!-- [if " + condition1 + "] -->" + System.Environment.NewLine +
"content 1" + System.Environment.NewLine +
"<!-- [endif] -->" + System.Environment.NewLine +
"<!-- [if " + condition2 + "] -->" + System.Environment.NewLine +
"content 2" + System.Environment.NewLine +
"<!-- [endif] -->");
Assert.AreEqual(assert, result);
}
private TaintSets Node_FuncCall(XmlNode node)
{
if (!isConditional)
{
return(null);
}
// We use the True scope as both True and False are the same at this point in time
var functionCallExtractor = new FunctionCallExtractor();
var functionCall = functionCallExtractor.ExtractFunctionCall(node);
var condSaniFunc = _funcHandler.FindCondSanitizerByName(functionCall.Name);
if (condSaniFunc != null)
{
var parameter = functionCall.Arguments;
var varResolverFalse = new VariableResolver(_variables[EdgeType.False]);
if (parameter.Any(x => varResolverFalse.IsResolvableNode(x.Value)) &&
condSaniFunc.DefaultStatus == MixedStatus.XSSSQL_SAFE)
{
if (isNegated)
{
var var = varResolverFalse.ResolveVariable(parameter.First(x => varResolverFalse.IsResolvableNode(x.Value)).Value);
var.Variable.Info.Taints = new TaintSets().ClearTaint();
}
else
{
var varResolverTrue = new VariableResolver(_variables[EdgeType.True]);
var var = varResolverTrue.ResolveVariable(parameter.First(x => varResolverTrue.IsResolvableNode(x.Value)).Value);
var.Variable.Info.Taints = new TaintSets().ClearTaint();
}
}
}
return(new TaintSets().ClearTaint());
}
public void Dont_Resolve_Escaped_Variable()
{
var target = new VariableResolver(new List <Variable>());
var result = target.TransformVariables("Hello _$_{Escaped}!");
Assert.AreEqual("Hello ${Escaped}!", result);
}
public void Conditional_Not_Visible_With_False_Negated(string condition)
{
var target = new VariableResolver(new List <Variable>());
var result = target.TransformVariables("Hello\n<!--[if not " + condition + "]-->\ntobi!\n<!--[endif]-->");
Assert.AreEqual("Hello", result);
}
public void List_Multiple_Missing_Variables_Test()
{
var target = new VariableResolver(new List <Variable>());
target.TransformVariables("${a} ${b} ${c}");
Assert.AreEqual(3, target.VariableUsageList.Count(v => v.IsMissingValue));
}
public void Resolve_Using_Default_Value_Test()
{
var variableList = new List <Variable>();
var target = new VariableResolver(variableList);
var result = target.TransformVariables("Hello ${FirstName=Mila} ${LastName=Kunis}!");
Assert.AreEqual("Hello Mila Kunis!", result);
}
public void SetUp()
{
dynamic variables = new ExpandoObject();
variables.scalarIntVariable = "1";
this.intNamedType = GetIntNamedType();
this.schemaRepository = Substitute.For <ISchemaRepository>();
this.variableResolver = new VariableResolver(variables, this.schemaRepository, this.GetVariableDefinitions());
}
public void SetUp()
{
dynamic variables = new ExpandoObject();
variables.scalarIntVariable = "1";
this.intNamedType = GetIntNamedType();
this.typeTranslator = Substitute.For <ITypeTranslator>();
this.variableResolver = new VariableResolver(variables, this.typeTranslator, this.GetVariableDefinitions());
}
private EnvironmentVariablesDto GetEnvironment(string name, bool fetchVariables)
{
using (var session = DocumentStore.OpenSession())
{
var environment = session.Query <Environment>().FirstOrDefault(e => e.Name == name);
if (environment == null)
{
throw HttpError.NotFound("Environment {0} not found.".Fmt(name));
}
using (var workspace = new Workspace(FileSystem, ServerSettings))
{
var result = new EnvironmentVariablesDto()
{
Environment = environment.ToDto()
};
if (fetchVariables)
{
workspace.UpdateSources();
var provider = new EnvironmentProvider();
try
{
var serializedEnvironment = provider.GetEnvironmentFromFile(Path.Combine(workspace.EnviornmentPath, name + ".xml"));
var resolver = new VariableResolver(serializedEnvironment.Variables);
result.Variables = new List <VariableDto>();
result.Variables.AddRange(serializedEnvironment.Variables.Select(v => new VariableDto()
{
Name = v.Name,
Value = v.Value,
Resolved = resolver.TransformVariables(v.Value)
}));
if (resolver.VariableUsageList.Any(v => v.IsMissingValue))
{
result.MissingVariables =
new List <string>(resolver.VariableUsageList.Where(v => v.IsMissingValue).Select(v => v.Variable.Name));
}
}
catch (FileNotFoundException e)
{
result.Variables = new List <VariableDto>();
result.Warning = "No xml file found for this environment!";
}
}
return(result);
}
}
}
public ImmutableVariableStorage Analyze(XmlNode node, ImmutableVariableStorage knownTaint)
{
Preconditions.NotNull(knownTaint, "knownTaint");
_variableStorage = knownTaint.ToMutable();
_varResolver = new VariableResolver(_variableStorage, _analysisScope);
Analyze(node);
return ImmutableVariableStorage.CreateFromMutable(_variableStorage);
}
[Ignore] // TODO: add warning also for default values
public void Resolve_Default_Value_With_Missing_Variable_Test()
{
var variableList = new List <Variable>()
{
new Variable()
{
Name = "FirstName", Value = "Jack"
}
};
var target = new VariableResolver(variableList);
var result = target.TransformVariables("Hello ${FullName=$[gugus]}");
Assert.AreEqual(1, target.VariableUsageList.Count(vu => vu.IsMissingValue));
}
public void Resolve_One_Variable_Test()
{
var variableList = new List <Variable>()
{
new Variable()
{
Name = "Var1", Value = "Jack Bauer"
}
};
var target = new VariableResolver(variableList);
var result = target.TransformVariables("Hello ${Var1}!");
Assert.AreEqual("Hello Jack Bauer!", result);
}
public void Conditional_Is_Visible_With_False_Variable_Negated(string condition)
{
var variableList = new List <Variable>()
{
new Variable()
{
Name = "condition", Value = condition
}
};
var target = new VariableResolver(variableList);
var result = target.TransformVariables("Hello\r\n<!--[if not ${condition}]-->\r\ntobi!\r\n<!--[endif]-->");
Assert.AreEqual("Hello", result);
}
public void List_Missing_Variables_Test()
{
var variableList = new List <Variable>()
{
new Variable()
{
Name = "FirstName", Value = "Jack"
},
};
var target = new VariableResolver(variableList);
var result = target.TransformVariables("Hello ${FirstName} ${LastName}!");
Assert.AreEqual(1, target.VariableUsageList.Count(v => v.IsMissingValue));
Assert.AreEqual("Hello Jack !!Missing variable for LastName!!!", result);
}
public IImmutableDictionary<EdgeType, ImmutableVariableStorage> AnalyzeCond(XmlNode node, ImmutableVariableStorage knownTaint)
{
Preconditions.NotNull(knownTaint, "knownTaint");
_variables.Remove(EdgeType.Normal);
_variables.Add(EdgeType.Normal, knownTaint.ToMutable());
_varResolver = new VariableResolver(_variables[EdgeType.Normal], _analysisScope);
_variables.Remove(EdgeType.False);
_variables.Remove(EdgeType.True);
Analyze(node);
isConditional = false;
var variablestore = _variables.Keys.ToDictionary(edgetype => edgetype, edgetype => ImmutableVariableStorage.CreateFromMutable(_variables[edgetype]));
return ImmutableDictionary<EdgeType, ImmutableVariableStorage>.Empty.AddRange(variablestore);
}
public void ResolveMultipleArrayElements(string phpCode)
{
XmlNode ast = PHPParseUtils.ParsePHPCode(phpCode, Config.PHPSettings.PHPParserPath).FirstChild.NextSibling;
var xmlNodes = ast.FirstChild.Cast <XmlNode>().ToList();
var varNodes = xmlNodes.Where(node => node.LocalName == AstConstants.Nodes.Expr_ArrayDimFetch);
var varResolver = new VariableResolver(new VariableStorage(), AnalysisScope.File);
var firstVar = varNodes.First();
var result = varResolver.ResolveVariable(firstVar);
result = varResolver.ResolveVariable(firstVar);
Assert.IsFalse(result.IsNew, "Var");
result = varResolver.ResolveVariable(varNodes.ElementAt(1));
Assert.IsTrue(result.IsNew, "First lookup of second var");
}
public IImmutableDictionary <EdgeType, ImmutableVariableStorage> AnalyzeCond(XmlNode node, ImmutableVariableStorage knownTaint)
{
Preconditions.NotNull(knownTaint, "knownTaint");
_variables.Remove(EdgeType.Normal);
_variables.Add(EdgeType.Normal, knownTaint.ToMutable());
_varResolver = new VariableResolver(_variables[EdgeType.Normal], _analysisScope);
_variables.Remove(EdgeType.False);
_variables.Remove(EdgeType.True);
Analyze(node);
isConditional = false;
var variablestore = _variables.Keys.ToDictionary(edgetype => edgetype, edgetype => ImmutableVariableStorage.CreateFromMutable(_variables[edgetype]));
return(ImmutableDictionary <EdgeType, ImmutableVariableStorage> .Empty.AddRange(variablestore));
}
public void ResolveStaticPropertyFetch(string phpCode, string expectedVarName, string nodeType)
{
XmlNode ast = PHPParseUtils.ParsePHPCode(phpCode, Config.PHPSettings.PHPParserPath).FirstChild.NextSibling;
var xmlNodes = ast.FirstChild.Cast <XmlNode>()
.Where(node => node.LocalName == nodeType);
var propFetch = xmlNodes.First();
var varResolver = new VariableResolver(new VariableStorage(), AnalysisScope.File);
var result = varResolver.ResolveVariable(propFetch);
Assert.AreEqual(expectedVarName, result.Variable.Name, "Name should match");
Assert.IsTrue(result.IsNew, "New var");
result = varResolver.ResolveVariable(propFetch);
Assert.AreEqual(expectedVarName, result.Variable.Name, "Names should still match");
Assert.IsFalse(result.IsNew, "Variable is no longer new");
}
public void ResolveArrayElement(string phpCode, string varName)
{
XmlNode ast = PHPParseUtils.ParsePHPCode(phpCode, Config.PHPSettings.PHPParserPath).FirstChild.NextSibling;
var xmlNodes = ast.FirstChild.Cast <XmlNode>().ToList();
var varNodes = xmlNodes.Where(node => node.LocalName == AstConstants.Nodes.Expr_ArrayDimFetch);
var varResolver = new VariableResolver(new VariableStorage(), AnalysisScope.File);
foreach (var varNode in varNodes)
{
var result = varResolver.ResolveVariable(varNode);
Assert.AreEqual(varName, result.Variable.Name, "Names should match");
Assert.IsTrue(result.IsNew, "Variable should be new");
result = varResolver.ResolveVariable(varNode);
Assert.AreEqual(varName, result.Variable.Name, "Names should still match");
Assert.IsFalse(result.IsNew, "Variable is no longer new");
}
}
public void Resolve_With_Default_Value_Set_Test()
{
var variableList = new List <Variable>()
{
new Variable()
{
Name = "FirstName", Value = "Jack"
},
new Variable()
{
Name = "LastName", Value = "Bauer"
},
};
var target = new VariableResolver(variableList);
var result = target.TransformVariables("Hello ${FirstName=Mila} ${LastName=Kunis}!");
Assert.AreEqual("Hello Jack Bauer!", result);
}
private TaintSets EqualsComparison(XmlNode node)
{
if (!isConditional)
{
return(null);
}
var leftNode = node.GetSubNode(AstConstants.Subnode + ":" + AstConstants.Subnodes.Left)
.GetSubNodesByPrefix(AstConstants.Node).Single();
var rightNode = node.GetSubNode(AstConstants.Subnode + ":" + AstConstants.Subnodes.Right)
.GetSubNodesByPrefix(AstConstants.Node).Single();
var scalarNodes = new[]
{
AstConstants.Nodes.Scalar_DNumber,
AstConstants.Nodes.Scalar_LNumber,
AstConstants.Nodes.Scalar_MagicConst_Class,
AstConstants.Nodes.Scalar_MagicConst_Dir,
AstConstants.Nodes.Scalar_MagicConst_File,
AstConstants.Nodes.Scalar_MagicConst_Function,
AstConstants.Nodes.Scalar_MagicConst_Line,
AstConstants.Nodes.Scalar_MagicConst_Method,
AstConstants.Nodes.Scalar_MagicConst_Namespace,
AstConstants.Nodes.Scalar_MagicConst_Trait,
AstConstants.Nodes.Scalar_String,
};
if (_varResolver.IsResolvableNode(leftNode) && scalarNodes.Contains(rightNode.LocalName))
{
var varResolver = new VariableResolver(_variables[isNegated ? EdgeType.False : EdgeType.True]);
var var = varResolver.ResolveVariable(leftNode);
var.Variable.Info.Taints = new TaintSets().ClearTaint();
}
else if (scalarNodes.Contains(leftNode.LocalName) && _varResolver.IsResolvableNode(rightNode))
{
var varResolver = new VariableResolver(_variables[isNegated ? EdgeType.False : EdgeType.True]);
var var = varResolver.ResolveVariable(rightNode);
var.Variable.Info.Taints = new TaintSets().ClearTaint();
}
return(new TaintSets().ClearTaint());
}
public void ResolveArrayElementMixIndexType()
{
string phpCode = @"<?php $a['1']; $a[1];";
XmlNode ast = PHPParseUtils.ParsePHPCode(phpCode, Config.PHPSettings.PHPParserPath).FirstChild.NextSibling;
var xmlNodes = ast.FirstChild.Cast <XmlNode>().ToList();
var varNodes = xmlNodes.Where(node => node.LocalName == AstConstants.Nodes.Expr_ArrayDimFetch);
var varResolver = new VariableResolver(new VariableStorage(), AnalysisScope.File);
var arrayfetch = varNodes.First();
var result = varResolver.ResolveVariable(arrayfetch);
Assert.AreEqual("1", result.Variable.Name, "Names should match");
Assert.IsTrue(result.IsNew, "Variable should be new");
result = varResolver.ResolveVariable(varNodes.ElementAt(1));
Assert.AreEqual("1", result.Variable.Name, "Names should still match");
Assert.IsFalse(result.IsNew, "Variable is no longer new");
}
private static EvaluatorState Evaluate(string statement, string prompt)
{
Console.WriteLine();
if (string.IsNullOrWhiteSpace(statement))
{
return(null);
}
VariableResolver resolver = new VariableResolver();
var tokens = tokenizer.Tokenize(statement);
var ast = parser.Parse(tokens);
var variables = resolver.Resolve(ast);
foreach (var resolved in variables)
{
var nestedPrompt = $"{resolved.Key} = ";
var stmt = ProcessKeyEvents(nestedPrompt);
var value = Evaluate(stmt, nestedPrompt);
printer.Print(new Run()
{
Text = " --------", Color = RunColor.White
});
var existing = variables[resolved.Key];
existing.IsSigned = value.IsSigned;
existing.Type = value.Type;
existing.Value = value.Value;
}
var result = evaluator.Evaluate(ast, variables, printer, context);
return(result);
}
private static void CreatePiscesDatabaseWithModsimNodeNames(
TimeSeriesDatabase dbVic,
DataTable correlation, string period, string scenario = "")
{
string fn = period + scenario + ".pdb";
if (File.Exists(fn))
{
Console.WriteLine("Warning: Overwriting existing file " + fn);
File.Delete(fn);
}
else
{
Console.WriteLine("creating " + fn);
}
SQLiteServer svr = new SQLiteServer(fn);
TimeSeriesDatabase db = new TimeSeriesDatabase(svr);
VariableResolver vr = new VariableResolver(dbVic, LookupOption.SeriesName);
Console.WriteLine("-------------------------------");
Console.WriteLine("database records");
Console.WriteLine("Series saved");
Console.WriteLine("-------------------------------");
for (int i = 0; i < correlation.Rows.Count; i++)
{
var gain = correlation.Rows[i]["ModsimGain"].ToString();
var neg = correlation.Rows[i]["ModsimNeg"].ToString();
var equation = correlation.Rows[i]["Equation"].ToString().Trim();
if (equation != "")
{
equation = IncludeScenarioAndPeriod(equation, period, scenario);
AddSeries(period, scenario, db, vr, gain, equation, ModsimType.Gain);
AddSeries(period, scenario, db, vr, neg, equation, ModsimType.Negative);
}
}
}
public void Resolve_On_Multiple_Lines_Test()
{
var variableList = new List <Variable>()
{
new Variable()
{
Name = "FirstName", Value = "Jack"
},
new Variable()
{
Name = "LastName", Value = "Bauer"
},
new Variable()
{
Name = "SecondLine", Value = "2"
},
};
var target = new VariableResolver(variableList);
var result = target.TransformVariables(@"Hello ${FirstName} ${LastName}!\r\nThis is another line:${SecondLine}");
Assert.AreEqual(@"Hello Jack Bauer!\r\nThis is another line:2", result);
}
public void Resolve_Variable_In_Variable_In_Variable_Test()
{
var variableList = new List <Variable>()
{
new Variable()
{
Name = "A", Value = "A + ${B}"
},
new Variable()
{
Name = "B", Value = "B + ${C}"
},
new Variable()
{
Name = "C", Value = "C"
},
};
var target = new VariableResolver(variableList);
var result = target.TransformVariables("${A}");
Assert.AreEqual("A + B + C", result);
}
public void Resolve_Variable_In_Variable_Test()
{
var variableList = new List <Variable>()
{
new Variable()
{
Name = "FirstName", Value = "Mila"
},
new Variable()
{
Name = "LastName", Value = "Kunis"
},
new Variable()
{
Name = "Fullname", Value = "${FirstName} ${LastName}"
},
};
var target = new VariableResolver(variableList);
var result = target.TransformVariables("Hello ${Fullname}!");
Assert.AreEqual("Hello Mila Kunis!", result);
}
private static void AddSeries(string period, string scenario,
TimeSeriesDatabase db, VariableResolver vr,
string name, string equation, ModsimType mType)
{
if (name.Trim().ToLower() == "nan")
{
return;
}
if (name.Trim() == "")
{
Console.WriteLine("--- WARNING modsim Node Name is missing. Type = " +
mType.ToString());
return;
}
CalculationSeries cs = new CalculationSeries(name);
cs.TimeInterval = TimeInterval.Monthly;
if (mType == ModsimType.Gain)
{
cs.Expression = string.Format("Max({0}, 0)", equation);
}
if (mType == ModsimType.Negative)
{
cs.Expression = string.Format("Abs(Min({0}, 0))", equation);
}
cs.TimeSeriesDatabase = db;
cs.Parser.VariableResolver = vr;
cs.Units = "cfs";
db.AddSeries(cs); // add series before calcualte to get an id assigned.
cs.Calculate(); // Calculate also saves the data.
SetSeriesDatesToBeginningOfMonth(cs);
ConsolePrintSeriesNameAndCount(cs);
}
private static void AddSeries(string period, string scenario,
TimeSeriesDatabase db, VariableResolver vr,
string name, string equation, ModsimType mType)
{
if (name.Trim().ToLower() == "nan")
{
return;
}
if (name.Trim() == "")
{
Console.WriteLine("--- WARNING modsim Node Name is missing. Type = " +
mType.ToString());
return;
}
CalculationSeries cs = new CalculationSeries(name);
cs.TimeInterval = TimeInterval.Monthly;
if (mType == ModsimType.Gain)
{
cs.Expression = string.Format("Max({0}, 0)", equation);
}
if (mType == ModsimType.Negative)
{
cs.Expression = string.Format("Abs(Min({0}, 0))", equation);
}
cs.TimeSeriesDatabase = db;
cs.Parser.VariableResolver = vr;
cs.Units = "cfs";
db.AddSeries(cs); // add series before calcualte to get an id assigned.
cs.Calculate(); // Calculate also saves the data.
SetSeriesDatesToBeginningOfMonth(cs);
ConsolePrintSeriesNameAndCount(cs);
}
public static string ResolveValue(this TestCaseContext testCaseContext, string value)
{
return(VariableResolver.Resolve(value, item => testCaseContext.GetRequiredItem(item)));
}
public void ResolveFuncThrows(string value)
{
Assert.That(() => VariableResolver.Resolve(value, (key) => throw new KeyNotFoundException()), Throws.InstanceOf <KeyNotFoundException>());
}
public void ResolveThrows(string value)
{
Assert.That(() => VariableResolver.Resolve(value, (key) => _variables[key]), Throws.InstanceOf <ArgumentException>());
}
private TaintSets Node_FuncCall(XmlNode node)
{
if (!isConditional)
{
return null;
}
// We use the True scope as both True and False are the same at this point in time
var functionCallExtractor = new FunctionCallExtractor();
var functionCall = functionCallExtractor.ExtractFunctionCall(node);
FunctionsHandler fh = FunctionsHandler.Instance;
var condSaniFunc = fh.FindCondSanitizerByName(functionCall.Name);
if (condSaniFunc != null)
{
var parameter = functionCall.Arguments;
var varResolverFalse = new VariableResolver(_variables[EdgeType.False]);
if (parameter.Any(x => varResolverFalse.IsResolvableNode(x.Value))
&& condSaniFunc.DefaultStatus == MixedStatus.XSSSQL_SAFE)
{
if (isNegated)
{
var var = varResolverFalse.ResolveVariable(parameter.First(x => varResolverFalse.IsResolvableNode(x.Value)).Value);
var.Variable.Info.Taints = new TaintSets().ClearTaint();
}
else
{
var varResolverTrue = new VariableResolver(_variables[EdgeType.True]);
var var = varResolverTrue.ResolveVariable(parameter.First(x => varResolverTrue.IsResolvableNode(x.Value)).Value);
var.Variable.Info.Taints = new TaintSets().ClearTaint();
}
}
}
return new TaintSets().ClearTaint();
}
private TaintSets EqualsComparison(XmlNode node)
{
if (!isConditional)
{
return null;
}
var leftNode = node.GetSubNode(AstConstants.Subnode + ":" + AstConstants.Subnodes.Left)
.GetSubNodesByPrefix(AstConstants.Node).Single();
var rightNode = node.GetSubNode(AstConstants.Subnode + ":" + AstConstants.Subnodes.Right)
.GetSubNodesByPrefix(AstConstants.Node).Single();
var scalarNodes = new[]
{
AstConstants.Nodes.Scalar_DNumber,
AstConstants.Nodes.Scalar_LNumber,
AstConstants.Nodes.Scalar_MagicConst_Class,
AstConstants.Nodes.Scalar_MagicConst_Dir,
AstConstants.Nodes.Scalar_MagicConst_File,
AstConstants.Nodes.Scalar_MagicConst_Function,
AstConstants.Nodes.Scalar_MagicConst_Line,
AstConstants.Nodes.Scalar_MagicConst_Method,
AstConstants.Nodes.Scalar_MagicConst_Namespace,
AstConstants.Nodes.Scalar_MagicConst_Trait,
AstConstants.Nodes.Scalar_String,
};
if (_varResolver.IsResolvableNode(leftNode) && scalarNodes.Contains(rightNode.LocalName))
{
var varResolver = new VariableResolver(_variables[isNegated ? EdgeType.False : EdgeType.True]);
var var = varResolver.ResolveVariable(leftNode);
var.Variable.Info.Taints = new TaintSets().ClearTaint();
}
else if (scalarNodes.Contains(leftNode.LocalName) && _varResolver.IsResolvableNode(rightNode))
{
var varResolver = new VariableResolver(_variables[isNegated ? EdgeType.False : EdgeType.True]);
var var = varResolver.ResolveVariable(rightNode);
var.Variable.Info.Taints = new TaintSets().ClearTaint();
}
return new TaintSets().ClearTaint();
}
private static void CreatePiscesDatabaseWithModsimNodeNames(
TimeSeriesDatabase dbVic,
DataTable correlation, string period, string scenario = "")
{
string fn = period + scenario + ".pdb";
if (File.Exists(fn))
{
Console.WriteLine("Warning: Overwriting existing file " + fn);
File.Delete(fn);
}
else
{
Console.WriteLine("creating " + fn);
}
SQLiteServer svr = new SQLiteServer(fn);
TimeSeriesDatabase db = new TimeSeriesDatabase(svr);
VariableResolver vr = new VariableResolver(dbVic, LookupOption.SeriesName);
Console.WriteLine("-------------------------------");
Console.WriteLine("database records");
Console.WriteLine("Series saved");
Console.WriteLine("-------------------------------");
for (int i = 0; i < correlation.Rows.Count; i++)
{
var gain = correlation.Rows[i]["ModsimGain"].ToString();
var neg = correlation.Rows[i]["ModsimNeg"].ToString();
var equation = correlation.Rows[i]["Equation"].ToString().Trim();
if (equation != "")
{
equation = IncludeScenarioAndPeriod(equation, period, scenario);
AddSeries(period, scenario, db, vr, gain, equation, ModsimType.Gain);
AddSeries(period, scenario, db, vr, neg, equation, ModsimType.Negative);
}
}
}
private ExpressionInfo Expr_Ternary(XmlNode node)
{
var condNode = node.GetSubNode(AstConstants.Subnode + ":" + AstConstants.Subnodes.Cond);
var ifTrueNode = node.GetSubNode(AstConstants.Subnode + ":" + AstConstants.Subnodes.If);
var ifFalseNode = node.GetSubNode(AstConstants.Subnode + ":" + AstConstants.Subnodes.Else);
Analyze(condNode);
var condAnalyzer = new ConditionTaintAnalyser(_analysisScope, this._inclusionResolver, _analysisStacks.IncludeStack);
var condResult = condAnalyzer.AnalyzeCond(condNode, ImmutableVariableStorage.CreateFromMutable(_variableStorage));
var currentResolver = this._varResolver;
this._varResolver = new VariableResolver(condResult[EdgeType.True].ToMutable());
var leftTaint = Analyze(ifTrueNode);
this._varResolver = new VariableResolver(condResult[EdgeType.False].ToMutable());
var rightTaint = Analyze(ifFalseNode);
this._varResolver = currentResolver;
return leftTaint.Merge(rightTaint);
}
public SeriesExpressionParser()
{
// default resolver requires adding variables in advance
m_variableResolver = new VariableResolver();
m_VariableParser = new VariableParser();
}
Types tokType; // holds token's type
#endregion Fields
#region Constructors
public SeriesExpressionParser(TimeSeriesDatabase db,LookupOption lookup= LookupOption.SeriesName)
{
m_db = db;
m_variableResolver = new VariableResolver(db, lookup);
m_VariableParser = new VariableParser();
}
