/// <summary>
/// Set fields to values as valuation
/// </summary>
/// <param name="valuation"></param>
private static void UpdateVarsBasedOnValuation(Valuation valuation)
{
if (valuation.Variables != null)
{
foreach (StringDictionaryEntryWithKey <ExpressionValue> pair in valuation.Variables._entries)
{
if (pair != null)
{
if (pair.Value is RecordValue)
{
RecordValue arrayOfValues = pair.Value as RecordValue;
int[] values = new int[arrayOfValues.Associations.Length];
for (int i = 0; i < values.Length; i++)
{
values[i] = int.Parse(arrayOfValues.Associations[i].ExpressionID);
}
SetValue(pair.Key, values);
}
else if (pair.Value is BoolConstant)
{
int value = (pair.Value as BoolConstant).Value ? 1 : 0;
SetValue(pair.Key, value);
}
else
{
SetValue(pair.Key, int.Parse(pair.Value.ExpressionID));
}
}
}
}
}
public override Expression GetClone()
{
Expression[] newAssociations = new Expression[Associations.Length];
for (int i = 0; i < Associations.Length; i++)
{
newAssociations[i] = Associations[i].GetClone();
}
RecordValue newrv = new RecordValue(newAssociations);
return(newrv);
}
public static void CheckVariableRange(string x, ExpressionValue v, int line, int position)
{
#if !OPTIMAL_FOR_EXP
if (VariableLowerBound.Count > 0 || VariableUpperLowerBound.Count > 0)
{
if (v is IntConstant)
{
int val = (v as IntConstant).Value;
if (VariableLowerBound.ContainsKey(x))
{
int bound = VariableLowerBound.GetContainsKey(x);
if (bound > val)
{
throw new ParsingException(
"Variable " + x + "'s current value " + val + " is smaller than its lower bound " +
bound, line, position, x);
}
}
if (VariableUpperLowerBound.ContainsKey(x))
{
int bound = VariableUpperLowerBound.GetContainsKey(x);
if (val > bound)
{
throw new ParsingException(
"Variable " + x + "'s current value " + val + " is greater than its upper bound " +
bound, line, position, x);
}
}
}
else if (v is RecordValue)
{
RecordValue record = v as RecordValue;
foreach (ExpressionValue value in record.Associations)
{
CheckVariableRange(x, value, line, position);
}
}
}
#endif
}
/// <summary>
/// Evaluate an expression as text and return the result.
/// </summary>
/// <param name="expressionText">textual representation of the formula</param>
/// <param name="parameters">parameters for formula. The fields in the parameter record can
/// be acecssed as top-level identifiers in the formula.</param>
/// <returns>The formula's result</returns>
public FormulaValue Eval(string expressionText, RecordValue parameters = null)
{
if (parameters == null)
{
parameters = RecordValue.Empty();
}
var check = Check(expressionText, parameters.IRContext.ResultType);
check.ThrowOnErrors();
var binding = check._binding;
(IntermediateNode irnode, ScopeSymbol ruleScopeSymbol) = IRTranslator.Translate(binding);
var ev2 = new EvalVisitor(_cultureInfo);
FormulaValue newValue = irnode.Accept(ev2, SymbolContext.New().WithGlobals(parameters));
return(newValue);
}
private static string RecordValueToString(RecordValue singleValue)
{
if (singleValue.asciiStringValue != null)
{
return(singleValue.asciiStringValue.value);
}
if (singleValue.intValue != null)
{
return(singleValue.intValue.value.ToString());
}
if (singleValue.binaryDataValue != null)
{
return("<binaryBlob>");
}
if (singleValue.booleanValue != null)
{
return(singleValue.booleanValue.value.ToString());
}
if (singleValue.byteValue != null)
{
return(singleValue.byteValue.value.ToString());
}
if (singleValue.dateAndTimeValue != null)
{
return(singleValue.dateAndTimeValue.value.ToString());
}
if (singleValue.floatValue != null)
{
return(singleValue.shortValue.value.ToString());
}
if (singleValue.shortValue != null)
{
return(singleValue.shortValue.value.ToString());
}
if (singleValue.unicodeStringValue != null)
{
return(singleValue.unicodeStringValue.value);
}
return("<empty>");
}
private static void UpdateValuationBasedOnClassValues(Valuation valuation)
{
if (valuation.Variables != null)
{
foreach (StringDictionaryEntryWithKey <ExpressionValue> pair in valuation.Variables._entries)
{
if (pair != null)
{
if (pair.Value is RecordValue)
{
RecordValue recordValue = (RecordValue)pair.Value;
int[] values = (int[])GetValue(pair.Key);
for (int i = 0; i < values.Length; i++)
{
if (recordValue.Associations[0] is IntConstant)
{
recordValue.Associations[i] = new IntConstant(values[i]);
}
else
{
recordValue.Associations[i] = new BoolConstant(values[i] > 0);
}
}
}
else if (pair.Value is BoolConstant)
{
int value = (int)GetValue(pair.Key);
pair.Value = new BoolConstant(value > 0);
}
else
{
int value = (int)GetValue(pair.Key);
pair.Value = new IntConstant(value);
}
}
}
}
}
/// <summary>
/// Based on the list of global variables in the Valuation, add them to the model
/// </summary>
/// <param name="valuation"></param>
public void AddGlobalVars(Valuation valuation)
{
if (valuation.Variables != null && valuation.Variables.Count > 0)
{
foreach (StringDictionaryEntryWithKey <ExpressionValue> pair in valuation.Variables._entries)
{
if (pair != null)
{
int lowerBound = Model.BDD_INT_LOWER_BOUND;
if (Valuation.VariableLowerBound.ContainsKey(pair.Key))
{
lowerBound = Valuation.VariableLowerBound.GetContainsKey(pair.Key);
}
int upperBound = Model.BDD_INT_UPPER_BOUND;
if (Valuation.VariableUpperLowerBound.ContainsKey(pair.Key))
{
upperBound = Valuation.VariableUpperLowerBound.GetContainsKey(pair.Key);
}
if (pair.Value is RecordValue)
{
RecordValue array = pair.Value as RecordValue;
this.model.AddGlobalArray(pair.Key, array.Associations.Length, lowerBound, upperBound);
}
else if (pair.Value is BoolConstant)
{
this.model.AddGlobalVar(pair.Key, 0, 1);
}
else
{
this.model.AddGlobalVar(pair.Key, lowerBound, upperBound);
}
}
}
}
}
public RecordScope(RecordValue context)
{
_context = context;
}
// evaluate starts evaluation with fresh environment
public static ExpressionValue Evaluate(Expression exp, Valuation env)
{
switch (exp.ExpressionType)
{
case ExpressionType.Constant:
return(exp as ExpressionValue);
case ExpressionType.Variable:
// Look up variable in environment; we assume
// that value is found
try
{
return(env.Variables[exp.expressionID]);
}
catch (KeyNotFoundException)
{
throw new EvaluatingException("Access the non existing variable: " + exp.expressionID);
}
catch (Exception ex)
{
throw new EvaluatingException("Variable evaluation exception for variable '" + exp.expressionID + "':" + ex.Message);
}
case ExpressionType.Record:
{
Expression[] ass = ((Record)exp).Associations;
ExpressionValue[] values = new ExpressionValue[ass.Length];
for (int i = 0; i < ass.Length; i++)
{
//rv.Put(association.Property, store.Extend(Eval(association.Expression, env)));
//rv.Put(Eval(association, env));
values[i] = Evaluate(ass[i], env);
#if !OPTIMAL_FOR_EXP
if (values[i] == null)
{
throw new RuntimeException("Invalid expression assignment: " + exp);
}
#endif
}
RecordValue rv = new RecordValue(values);
return(rv);
}
case ExpressionType.PrimitiveApplication:
// First evaluate the first argument, then the second, and
// then evaluate using evalPrimAppl.
{
PrimitiveApplication newexp = exp as PrimitiveApplication;
ExpressionValue x1 = Evaluate(newexp.Argument1, env);
Debug.Assert(x1 != null);
#if !OPTIMAL_FOR_EXP
if (x1 == null)
{
throw new RuntimeException("Invalid expression assignment: " + exp);
}
#endif
return(EvalPrimAppl(newexp, x1, newexp.Argument2, env));
}
case ExpressionType.Assignment:
{
//Assign the rhs to lhs
String lhs = ((Assignment)exp).LeftHandSide;
Expression rhs = ((Assignment)exp).RightHandSide;
ExpressionValue rhsV = Evaluate(rhs, env);
#if !OPTIMAL_FOR_EXP
if (rhsV == null)
{
throw new RuntimeException("Invalid expression assignment: " + exp);
}
Valuation.CheckVariableRange(lhs, rhsV);
#endif
env.Variables[lhs] = rhsV;
return(rhsV);
}
case ExpressionType.PropertyAssignment:
{
try
{
PropertyAssignment pa = (PropertyAssignment)exp;
RecordValue rec = (RecordValue)Evaluate(pa.RecordExpression, env);
IntConstant pro = (IntConstant)Evaluate(pa.PropertyExpression, env);
ExpressionValue rhs = Evaluate(pa.RightHandExpression, env);
//rec.Put(pro.PropertyName, store.Extend(rhs));
int index = pro.Value;
if (index < 0)
{
throw new NegativeArraySizeException("Access negative index " + index + " for variable " + pa.RecordExpression.ToString());
}
else if (index >= rec.Associations.Length)
{
throw new IndexOutOfBoundsException("Index " + index + " is out of range for variable " + pa.RecordExpression.ToString());
}
#if !OPTIMAL_FOR_EXP
if (rhs == null)
{
throw new RuntimeException("Invalid expression assignment: " + exp);
}
Valuation.CheckVariableRange(pa.RecordExpression.ToString(), rhs);
#endif
rec.Associations[index] = rhs;
//Note:Important!!! must recalculate the ID here, otherwise ID is obsolete and the verification result is wrong
rec.GetID();
return(rhs);
}
catch (InvalidCastException ex)
{
throw new RuntimeException("Invalid Cast Exception for " + exp + ": " + ex.Message.Replace("PAT.Common.Classes.Expressions.ExpressionClass.", ""));
}
}
case ExpressionType.If:
// Conditionals are evaluated by evaluating the then-part or
// else-part depending of the result of evaluating the condition.
{
ExpressionValue cond = Evaluate(((If)exp).Condition, env);
if (((BoolConstant)cond).Value)
{
return(Evaluate(((If)exp).ThenPart, env));
}
else if (((If)exp).ElsePart != null)
{
return(Evaluate(((If)exp).ElsePart, env));
}
else
{
return(null);
}
}
case ExpressionType.Sequence:
// firstPart;secondPart
Expression fP = ((Sequence)exp).FirstPart;
Expression sP = ((Sequence)exp).SecondPart;
Evaluate(fP, env);
return(Evaluate(sP, env));
case ExpressionType.While:
Expression test = ((While)exp).Test;
Expression body = ((While)exp).Body;
// the value of test may not be a Value.
// here we assume it is always a Value, which
// may cause run time exception due to non-Value.
if (((BoolConstant)Evaluate(test, env)).Value)
{
// test is ture
Evaluate(body, env); // body serves to change the store
return(Evaluate(exp, env)); // evaluate the While again
}
else
{
return(null);
}
case ExpressionType.StaticMethodCall:
try
{
StaticMethodCall methodCall = (StaticMethodCall)exp;
if (methodCall.Arguments.Length > 0)
{
ChannelQueue queue;
string cname = null;
if ((methodCall.Arguments[0] is Variable))
{
cname = (methodCall.Arguments[0] as Variable).ExpressionID;
}
else if (methodCall.Arguments[0] is PrimitiveApplication)
{
PrimitiveApplication pa = (methodCall.Arguments[0] as PrimitiveApplication);
ExpressionValue ind = Evaluate(pa.Argument2, env);
cname = pa.Argument1 + "[" + ind + "]";
}
switch (methodCall.MethodName)
{
case Common.Classes.Ultility.Constants.cfull:
if (env.Channels.TryGetValue(cname, out queue))
{
return(new BoolConstant(queue.IsFull()));
}
else
{
throw new RuntimeException("Channel " + cname +
" is not used in the model. Therefore it is meaningless to query channel information using " +
methodCall + ".");
}
case Common.Classes.Ultility.Constants.cempty:
if (env.Channels.TryGetValue(cname, out queue))
{
return(new BoolConstant(queue.IsEmpty()));
}
else
{
throw new RuntimeException("Channel " + cname +
" is not used in the model. Therefore it is meaningless to query channel information using " +
methodCall + ".");
}
case Common.Classes.Ultility.Constants.ccount:
if (env.Channels.TryGetValue(cname, out queue))
{
return(new IntConstant(queue.Count));
}
else
{
throw new RuntimeException("Channel " + cname +
" is not used in the model. Therefore it is meaningless to query channel information using " +
methodCall + ".");
}
case Common.Classes.Ultility.Constants.csize:
if (env.Channels.TryGetValue(cname, out queue))
{
return(new IntConstant(queue.Size));
}
else
{
throw new RuntimeException("Channel " + cname +
" is not used in the model. Therefore it is meaningless to query channel information using " +
methodCall + ".");
}
case Common.Classes.Ultility.Constants.cpeek:
if (env.Channels.TryGetValue(cname, out queue))
{
if (queue.Count == 0)
{
throw new IndexOutOfBoundsException("Channel " + cname +
"'s buffer is empty!");
}
return(new RecordValue(queue.Peek()));
}
else
{
throw new RuntimeException("Channel " + cname +
" is not used in the model. Therefore it is meaningless to query channel information using " +
methodCall + ".");
}
}
}
object[] paras = new object[methodCall.Arguments.Length];
for (int i = 0; i < paras.Length; i++)
{
ExpressionValue x1 = Evaluate(methodCall.Arguments[i], env);
paras[i] = GetValueFromExpression(x1);
}
string key = methodCall.MethodName + paras.Length;
if (Common.Utility.Utilities.CSharpMethods.ContainsKey(key))
{
object resultv = Common.Utility.Utilities.CSharpMethods[key].Invoke(null, paras);
if (Common.Utility.Utilities.CSharpMethods[key].ReturnType.Name == "Void")
{
return(null);
}
if (resultv is bool)
{
return(new BoolConstant((bool)resultv));
}
else if (resultv is int || resultv is short || resultv is byte || resultv is double)
{
return(new IntConstant(Convert.ToInt32(resultv)));
}
else if (resultv is int[])
{
int[] list = resultv as int[];
ExpressionValue[] vals = new ExpressionValue[list.Length];
for (int i = 0; i < vals.Length; i++)
{
vals[i] = new IntConstant(list[i]);
}
return(new RecordValue(vals));
}
else if (resultv is ExpressionValue)
{
return(resultv as ExpressionValue);
}
return(new NullConstant());
//the following check is not necessary, since we will only keep bool, int and int[] methods
//else
//{
// throw new Expressions.ExpressionClass.RuntimeException("Call expression can only return int, short, byte, bool or int[] types. Please check your methods.");
//}
}
throw new RuntimeException("Invalid Method Call: " + methodCall + "! Make sure you have defined the method in the library.");
}
catch (TargetInvocationException ex)
{
if (ex.InnerException != null)
{
RuntimeException exception =
new RuntimeException("Exception happened at expression " + exp + ": " +
ex.InnerException.Message);
exception.InnerStackTrace = ex.InnerException.StackTrace;
throw exception;
}
else
{
throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message);
}
}
catch (Exception ex)
{
throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message);
}
case ExpressionType.ClassMethodCall:
try
{
ClassMethodCall methodCall = (ClassMethodCall)exp;
ExpressionValue variable = env.Variables[methodCall.Variable];
if (variable == null)
{
throw new RuntimeException("Exception happened at expression " + exp + ": variable " + methodCall.Variable + "'s value is null");
}
object[] paras = new object[methodCall.Arguments.Length];
for (int i = 0; i < paras.Length; i++)
{
ExpressionValue x1 = Evaluate(methodCall.Arguments[i], env);
paras[i] = GetValueFromExpression(x1);
}
MethodInfo methodInfo = variable.GetType().GetMethod(methodCall.MethodName);
if (methodInfo != null)
{
object resultv = methodInfo.Invoke(variable, BindingFlags.InvokeMethod, null, paras, CultureInfo.InvariantCulture);
if (methodInfo.ReturnType.Name == "Void")
{
return(null);
}
if (resultv is bool)
{
return(new BoolConstant((bool)resultv));
}
else if (resultv is int || resultv is short || resultv is byte || resultv is double)
{
return(new IntConstant(Convert.ToInt32(resultv)));
}
else if (resultv is int[])
{
int[] list = resultv as int[];
ExpressionValue[] vals = new ExpressionValue[list.Length];
for (int i = 0; i < vals.Length; i++)
{
vals[i] = new IntConstant(list[i]);
}
return(new RecordValue(vals));
}
else if (resultv is ExpressionValue)
{
return(resultv as ExpressionValue);
}
else if (resultv == null)
{
return(new NullConstant());
}
//return null;
//the following check is not necessary, since we will only keep bool, int and int[] methods
throw new RuntimeException("Call expression can only return int, short, byte, bool or int[] types. Please check your statement: " + methodCall.ToString() + ".");
}
throw new RuntimeException("Invalid Method Call: " + methodCall + "! Make sure you have defined the method in the library.");
}
catch (TargetInvocationException ex)
{
if (ex.InnerException != null)
{
RuntimeException exception =
new RuntimeException("Exception happened at expression " + exp + ": " +
ex.InnerException.Message);
exception.InnerStackTrace = ex.InnerException.StackTrace;
throw exception;
}
else
{
throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message);
}
}
catch (Exception ex)
{
throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message);
}
case ExpressionType.ClassMethodCallInstance:
try
{
ClassMethodCallInstance methodCall = (ClassMethodCallInstance)exp;
ExpressionValue variable = Evaluate(methodCall.Variable, env);
object[] paras = new object[methodCall.Arguments.Length];
for (int i = 0; i < paras.Length; i++)
{
ExpressionValue x1 = Evaluate(methodCall.Arguments[i], env);
paras[i] = GetValueFromExpression(x1);
}
MethodInfo methodInfo = variable.GetType().GetMethod(methodCall.MethodName);
if (methodInfo != null)
{
object resultv = methodInfo.Invoke(variable, paras);
if (methodInfo.ReturnType.Name == "Void")
{
return(null);
}
if (resultv is bool)
{
return(new BoolConstant((bool)resultv));
}
else if (resultv is int || resultv is short || resultv is byte || resultv is double)
{
return(new IntConstant(Convert.ToInt32(resultv)));
}
else if (resultv is int[])
{
int[] list = resultv as int[];
ExpressionValue[] vals = new ExpressionValue[list.Length];
for (int i = 0; i < vals.Length; i++)
{
vals[i] = new IntConstant(list[i]);
}
return(new RecordValue(vals));
}
else if (resultv is ExpressionValue)
{
return(resultv as ExpressionValue);
}
else if (resultv == null)
{
return(new NullConstant());
}
//return null;
//the following check is not necessary, since we will only keep bool, int and int[] methods
throw new RuntimeException("Call expression can only return int, short, byte, bool or int[] types. Please check your statement: " + methodCall.ToString() + ".");
}
throw new RuntimeException("Invalid Method Call: " + methodCall + "! Make sure you have defined the method in the library.");
}
catch (TargetInvocationException ex)
{
if (ex.InnerException != null)
{
RuntimeException exception =
new RuntimeException("Exception happened at expression " + exp + ": " +
ex.InnerException.Message);
exception.InnerStackTrace = ex.InnerException.StackTrace;
throw exception;
}
else
{
throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message);
}
}
catch (Exception ex)
{
throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message);
}
case ExpressionType.ClassProperty:
try
{
ClassProperty property = (ClassProperty)exp;
ExpressionValue variable = Evaluate(property.Variable, env);
PropertyInfo propertyInfo = variable.GetType().GetProperty(property.PropertyName);
object resultv = null;
if (propertyInfo != null)
{
resultv = propertyInfo.GetValue(variable, null);
}
else
{
FieldInfo fieldInfo = variable.GetType().GetField(property.PropertyName);
if (fieldInfo != null)
{
resultv = fieldInfo.GetValue(variable);
}
}
if (resultv != null)
{
if (resultv is bool)
{
return(new BoolConstant((bool)resultv));
}
else if (resultv is int || resultv is short || resultv is byte || resultv is double)
{
return(new IntConstant(Convert.ToInt32(resultv)));
}
else if (resultv is int[])
{
int[] list = resultv as int[];
ExpressionValue[] vals = new ExpressionValue[list.Length];
for (int i = 0; i < vals.Length; i++)
{
vals[i] = new IntConstant(list[i]);
}
return(new RecordValue(vals));
}
else if (resultv is ExpressionValue)
{
return(resultv as ExpressionValue);
}
//else if (resultv == null)
//{
// return new NullConstant();
//}
//return null;
//the following check is not necessary, since we will only keep bool, int and int[] methods
throw new RuntimeException("Call expression can only return int, short, byte, bool or int[] types. Please check your statement: " + property.ToString() + ".");
}
throw new RuntimeException("Invalid Property Accessing: " + property + "! Make sure you have defined the method in the library.");
}
catch (TargetInvocationException ex)
{
if (ex.InnerException != null)
{
RuntimeException exception =
new RuntimeException("Exception happened at expression " + exp + ": " +
ex.InnerException.Message);
exception.InnerStackTrace = ex.InnerException.StackTrace;
throw exception;
}
else
{
throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message);
}
}
catch (Exception ex)
{
throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message);
}
case ExpressionType.ClassPropertyAssignment:
{
try
{
ClassPropertyAssignment pa = (ClassPropertyAssignment)exp;
ExpressionValue rhs = Evaluate(pa.RightHandExpression, env);
#if !OPTIMAL_FOR_EXP
if (rhs == null)
{
throw new RuntimeException("Invalid expression assignment: " + exp);
}
#endif
ClassProperty property = pa.ClassProperty;
ExpressionValue variable = Evaluate(property.Variable, env);
PropertyInfo propertyInfo = variable.GetType().GetProperty(property.PropertyName);
if (propertyInfo != null)
{
propertyInfo.SetValue(variable, GetValueFromExpression(rhs), null);
}
else
{
FieldInfo fieldInfo = variable.GetType().GetField(property.PropertyName);
if (fieldInfo != null)
{
fieldInfo.SetValue(variable, GetValueFromExpression(rhs));
}
else
{
throw new RuntimeException("Invalid expression assignment: " + exp);
}
}
return(rhs);
}
catch (InvalidCastException ex)
{
throw new RuntimeException("Invalid Cast Exception for " + exp + ": " + ex.Message.Replace("PAT.Common.Classes.Expressions.ExpressionClass.", ""));
}
}
case ExpressionType.Let:
LetDefinition definition = exp as LetDefinition;
ExpressionValue rhv = Evaluate(definition.RightHandExpression, env);
env.ExtendDestructive(definition.Variable, rhv);
return(null);
case ExpressionType.NewObjectCreation:
try
{
NewObjectCreation methodCall = (NewObjectCreation)exp;
object[] paras = new object[methodCall.Arguments.Length];
for (int i = 0; i < paras.Length; i++)
{
ExpressionValue x1 = Evaluate(methodCall.Arguments[i], env);
paras[i] = GetValueFromExpression(x1);
}
Type classType;
if (Common.Utility.Utilities.CSharpDataType.TryGetValue(methodCall.ClassName, out classType))
{
object resultv = Activator.CreateInstance(classType, paras);
if (resultv is ExpressionValue)
{
return(resultv as ExpressionValue);
}
//return null;
//the following check is not necessary, since we will only keep bool, int and int[] methods
throw new RuntimeException("Only object of class inheriting from ExpressionValue can be created. Please check your statement: " + methodCall.ToString() + ".");
}
throw new RuntimeException("Invalid Object Creation: " + methodCall + "! Make sure you have defined the class in the library.");
}
catch (Exception ex)
{
throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message);
}
//case ExpressionType.UserDefinedDataType:
// return exp as ;
/* case ExpressionType.Let:
* // Evaluate body with respect to environment extended by binding of leftHand to rightHand
* {
* Valuation newenv = env.GetVariableClone();
* foreach (LetDefinition def in ((Let) exp).Definitions)
* {
* Value rhv = Evaluate(def.RightHandExpression, env);
* //newenv = Extend(newenv, def.Variable, rhv);
* //newenv = newenv.Extend(def.Variable, rhv);
* newenv.ExtendDestructive(def.Variable, rhv);
* }
* return Evaluate(((Let) exp).Body, newenv);
* }
* case ExpressionType.Fun:
* return new FunValue(env, ((Fun) exp).Formals, ((Fun) exp).Body);
* case ExpressionType.RecFun:
* // For recursive functions, we need to place an environment
* // in the function that has a binding of the function variable
* // to the function itself. For this, we obtain a clone of the
* // environment, making sure that a destructive change will
* // not have any effect on the original environment. Then, we
* // place the clone in the function value. After that, we
* // destructively change the environment by a binding of the
* // function variable to the constructed function value.
* {
* Valuation newEnv = env.GetVariableClone(); // (Valuation)env.Clone();
* Value result = new FunValue(newEnv, ((RecFun) exp).Formals, ((RecFun) exp).body);
* //ExtendDestructive(newEnv, ((RecFun)exp).FunVar, result);
* newEnv.ExtendDestructive(((RecFun) exp).FunVar, result);
* return result;
* }
* case ExpressionType.Application:
* // Apply the function value resulting from evaluating the operator
* // (we assume that this is a function value) to
* // the value resulting from evaluating the operand.
* // Note that we do not need to distinguish functions from
* // recursive functions. Both are represented by function values,
* // recursive functions have a binding of their function variable
* // to themselves in their environment.
* {
* FunValue fun = (FunValue) Evaluate(((Application) exp).Operator, env);
* Valuation newenv = (Valuation) fun.Valuation;
*
* List<Expression> ops = ((Application) exp).Operands;
* List<string> fe = fun.Formals;
*
* for (int i = 0; i < ops.Count; i++)
* {
* Value argvalue = Evaluate(ops[i], env);
* //newenv = Extend(newenv, fe[i], argvalue);
* newenv = newenv.Extend((String) fe[i], argvalue);
* }
* return Evaluate(fun.Body, newenv);
* }*/
}
// (exp instanceof NotUsed)
// NotUsed is used as argument2 of PrimitiveApplication.
// We assume the resulting value will not be used,
// thus any value will do, here.
return(new BoolConstant(true));
}
private static ExpressionValue EvalPrimAppl(PrimitiveApplication application, ExpressionValue x1, Expression x2Exp, Valuation env)
{
try
{
ExpressionValue x2;
switch (application.Operator)
{
case "<":
x2 = Evaluate(x2Exp, env);
return(new BoolConstant(((IntConstant)x1).Value < ((IntConstant)x2).Value));
case "<=":
x2 = Evaluate(x2Exp, env);
return(new BoolConstant(((IntConstant)x1).Value <= ((IntConstant)x2).Value));
case ">":
x2 = Evaluate(x2Exp, env);
return(new BoolConstant(((IntConstant)x1).Value > ((IntConstant)x2).Value));
case ">=":
x2 = Evaluate(x2Exp, env);
return(new BoolConstant(((IntConstant)x1).Value >= ((IntConstant)x2).Value));
case "==":
x2 = Evaluate(x2Exp, env);
return(new BoolConstant(x1.ExpressionID == x2.ExpressionID));
case "!=":
x2 = Evaluate(x2Exp, env);
//return new BoolConstant(((IntConstant)x1).Value != ((IntConstant)x2).Value);
return(new BoolConstant(x1.ExpressionID != x2.ExpressionID));
case "&&":
if (((BoolConstant)x1).Value)
{
x2 = Evaluate(x2Exp, env);
return(new BoolConstant(((BoolConstant)x2).Value));
}
else
{
return(new BoolConstant(false));
}
case "||":
if (!((BoolConstant)x1).Value)
{
x2 = Evaluate(x2Exp, env);
return(new BoolConstant(((BoolConstant)x2).Value));
}
else
{
return(new BoolConstant(true));
}
case "xor":
x2 = Evaluate(x2Exp, env);
return(new BoolConstant(((BoolConstant)x1).Value ^ ((BoolConstant)x2).Value));
case "!":
return(new BoolConstant(!((BoolConstant)x1).Value));
case "+":
x2 = Evaluate(x2Exp, env);
return(new IntConstant(((IntConstant)x1).Value + ((IntConstant)x2).Value));
case "-":
x2 = Evaluate(x2Exp, env);
return(new IntConstant(((IntConstant)x1).Value - ((IntConstant)x2).Value));
case "*":
x2 = Evaluate(x2Exp, env);
return(new IntConstant(((IntConstant)x1).Value * ((IntConstant)x2).Value));
case "/":
x2 = Evaluate(x2Exp, env);
if (((IntConstant)x2).Value == 0)
{
throw new ArithmeticException("Divide by Zero on " + application.ToString());
}
else
{
return(new IntConstant(((IntConstant)x1).Value / ((IntConstant)x2).Value));
}
case "mod":
x2 = Evaluate(x2Exp, env);
if (((IntConstant)x2).Value == 0)
{
throw new ArithmeticException("Modulo by Zero on " + application.ToString());
}
else
{
int int_X1 = ((IntConstant)x1).Value;
int int_X2 = ((IntConstant)x2).Value;
int tmp = int_X1 % int_X2;
return(new IntConstant((tmp >= 0) ? tmp : (tmp + int_X2)));
}
//case "empty" :
// return new Value(((RecordValue) x1).Empty);
//case "hasproperty":
// return new Value(((RecordValue)x1).HasProperty(((PropertyValue)x2).PropertyName));
case ".":
RecordValue record = (RecordValue)x1;
x2 = Evaluate(x2Exp, env);
int index = ((IntConstant)x2).Value;
if (index < 0)
{
throw new NegativeArraySizeException("Access negative index " + index + " for variable " + application.Argument1.ToString() + " in expression " + application.ToString());
}
else if (index >= record.Associations.Length)
{
throw new IndexOutOfBoundsException("Index " + index + " is out of range for variable " + application.Argument1.ToString() + " in expression " + application.ToString());
}
return(record.Associations[index]);
case "~":
return(new IntConstant(-((IntConstant)x1).Value));
//Bitwise operators used by NESC module
case "<<": //bitwise left shift
x2 = Evaluate(x2Exp, env);
return(new IntConstant(((IntConstant)x1).Value << ((IntConstant)x2).Value));
case ">>": //bitwise right shift
x2 = Evaluate(x2Exp, env);
return(new IntConstant(((IntConstant)x1).Value >> ((IntConstant)x2).Value));
case "&": //bitwise AND
x2 = Evaluate(x2Exp, env);
return(new IntConstant(((IntConstant)x1).Value & ((IntConstant)x2).Value));
case "^": //bitwise XOR
x2 = Evaluate(x2Exp, env);
return(new IntConstant(((IntConstant)x1).Value ^ ((IntConstant)x2).Value));
case "|": //bitwise OR
x2 = Evaluate(x2Exp, env);
return(new IntConstant(((IntConstant)x1).Value | ((IntConstant)x2).Value));
}
}
catch (InvalidCastException ex)
{
throw new RuntimeException("Invalid Cast Exception for " + application.ToString() + ": " + ex.Message.Replace("PAT.Common.Classes.Expressions.ExpressionClass.", ""));
}
//catch (Exception ex1)
//{
// throw new RuntimeException("Invalid Primitive Operation: " + application.ToString() + "!");
//}
throw new RuntimeException("Invalid Primitive Operation: " + application.ToString() + "!");
}
public SymbolContext(RecordValue globals, ScopeSymbol currentScope, Dictionary <int, IScope> scopeValues)
{
_globals = globals;
_currentScope = currentScope;
_scopeValues = scopeValues;
}
public Expression InitializeGlobalVariables(Valuation valuation)
{
Expression initialVariables = new BoolConstant(true);
//continue build inital state
//default value of global variables
if (valuation.Variables != null)
{
foreach (StringDictionaryEntryWithKey <ExpressionValue> pair in valuation.Variables._entries)
{
if (pair != null)
{
if (!(pair.Value is WildConstant))
{
if (pair.Value is RecordValue)
{
RecordValue array = pair.Value as RecordValue;
for (int i = 0; i < array.Associations.Length; i++)
{
if (!(array.Associations[i] is WildConstant))
{
Expression initialVariable = Expression.EQ(
new Variable(pair.Key + Model.NAME_SEPERATOR + i),
new IntConstant(int.Parse(array.Associations[i].ExpressionID)));
initialVariables = Expression.AND(initialVariables, initialVariable);
}
else
{
string variableName = pair.Key + Model.NAME_SEPERATOR + i;
Expression lowerBound = Expression.GE(new Variable(variableName),
new IntConstant(model.GetVarLowerBound(variableName)));
Expression upperBound = Expression.LE(new Variable(variableName),
new IntConstant(model.GetVarUpperBound(variableName)));
initialVariables = Expression.AND(initialVariables, lowerBound);
initialVariables = Expression.AND(initialVariables, upperBound);
}
}
}
else if (pair.Value is BoolConstant)
{
int value = (pair.Value as BoolConstant).Value ? 1 : 0;
Expression initialVariable = Expression.EQ(new Variable(pair.Key), new IntConstant(value));
initialVariables = Expression.AND(initialVariables, initialVariable);
}
else
{
Expression initialVariable = Expression.EQ(new Variable(pair.Key),
new IntConstant(int.Parse(pair.Value.ExpressionID)));
initialVariables = Expression.AND(initialVariables, initialVariable);
}
}
else
{
Expression lowerBound = Expression.GE(new Variable(pair.Key), new IntConstant(model.GetVarLowerBound(pair.Key)));
Expression upperBound = Expression.LE(new Variable(pair.Key), new IntConstant(model.GetVarUpperBound(pair.Key)));
initialVariables = Expression.AND(initialVariables, lowerBound);
initialVariables = Expression.AND(initialVariables, upperBound);
}
}
}
}
if (valuation.Channels != null)
{
foreach (KeyValuePair <string, ChannelQueue> pair in valuation.Channels)
{
//initialize the top index of channel is 0
Expression initialVariable = Expression.EQ(new Variable(Model.GetTopVarChannel(pair.Key)), new IntConstant(0));
initialVariables = Expression.AND(initialVariables, initialVariable);
//initialize the cound of channel buffer is 0
initialVariable = Expression.EQ(new Variable(Model.GetCountVarChannel(pair.Key)), new IntConstant(0));
initialVariables = Expression.AND(initialVariables, initialVariable);
}
}
return(initialVariables);
}
//for assignment attached with events only
public static Value Evaluate(Expression expression, Environment env)
{
Stack <Expression> workingStack = new Stack <Expression>(16);
Stack <Value> valueStack = new Stack <Value>(16);
workingStack.Push(expression);
bool firstMeet = true;
while (workingStack.Count > 0)
{
Expression expr = workingStack.Pop();
if (expr == null)
{
firstMeet = false;
expr = workingStack.Pop();
}
else
{
firstMeet = true;
}
switch (expr.ExpressionType)
{
case ExpressionType.Variable:
try
{
string varName = ((Variable)expr).VarName;
valueStack.Push(env[varName]);
break;
}
catch (KeyNotFoundException)
{
throw new EvaluatingException("Access the non existing variable: " + (expr as Variable).VarName);
}
catch (Exception ex)
{
throw new EvaluatingException("Variable evaluation exception for variable '" + (expr as Variable).VarName + "':" + ex.Message);
}
case ExpressionType.BoolConstant:
valueStack.Push(new BoolValue(((BoolConstant)expr).BoolValue));
break;
case ExpressionType.IntConstant:
valueStack.Push(new IntValue(((IntConstant)expr).IntValue));
break;
case ExpressionType.Record:
int size = ((Record)expr).Associations.Length;
if (firstMeet)
{
workingStack.Push(expr);
workingStack.Push(null);
Expression[] ass = ((Record)expr).Associations;
for (int i = 0; i < size; i++)
{
workingStack.Push(ass[i]);
}
}
else
{
Value[] values = new Value[size];
for (int i = 0; i < size; i++)
{
values[i] = valueStack.Pop();
}
RecordValue rv = new RecordValue(values);
valueStack.Push(rv);
}
break;
case ExpressionType.PrimitiveApplication:
PrimitiveApplication newexp = ((PrimitiveApplication)expr);
if (firstMeet)
{
workingStack.Push(expr);
workingStack.Push(null);
workingStack.Push(newexp.Argument1);
if (newexp.Argument2 != null)
{
workingStack.Push(newexp.Argument2);
}
}
else
{
Value x1 = valueStack.Pop();
Value x2 = null;
if (newexp.Argument2 != null)
{
x2 = valueStack.Pop();
}
valueStack.Push(EvalPrimAppl(newexp.Operator, x1, x2));
}
break;
case ExpressionType.Assignment:
String lhs = ((Assignment)expr).LeftHandSide;
if (firstMeet)
{
workingStack.Push(expr);
workingStack.Push(null);
workingStack.Push(((Assignment)expr).RightHandSide);
}
else
{
env[lhs] = valueStack.Pop();
}
break;
case ExpressionType.PropertyAssignment:
PropertyAssignment pa = (PropertyAssignment)expr;
if (firstMeet)
{
workingStack.Push(expr);
workingStack.Push(null);
workingStack.Push(pa.RecordExpression);
workingStack.Push(pa.PropertyExpression);
workingStack.Push(pa.RightHandExpression);
}
else
{
RecordValue rec = (RecordValue)valueStack.Pop();
IntValue pro = (IntValue)valueStack.Pop();
Value rhs = valueStack.Pop();
rec.Values[pro.Value] = rhs;
}
break;
case ExpressionType.If:
if (firstMeet)
{
workingStack.Push(expr);
workingStack.Push(null);
workingStack.Push(((If)expr).Condition);
}
else
{
BoolValue cond = valueStack.Pop() as BoolValue;
if (cond.Value)
{
//return Evaluate(((If)expr).ThenPart, env, VariablesToWrite, VariablesToRead);
workingStack.Push(((If)expr).ThenPart);
}
else if (((If)expr).ElsePart != null)
{
//return Evaluate(((If)expr).ElsePart, env, VariablesToWrite, VariablesToRead);
workingStack.Push(((If)expr).ElsePart);
}
}
break;
case ExpressionType.Sequence:
workingStack.Push(((Sequence)expr).FirstPart);
workingStack.Push(((Sequence)expr).SecondPart);
break;
case ExpressionType.While:
if (firstMeet)
{
workingStack.Push(expr);
workingStack.Push(null);
workingStack.Push(((While)expr).Test);
}
else
{
BoolValue cond = valueStack.Pop() as BoolValue;
if (cond.Value)
{
workingStack.Push(expr);
workingStack.Push(((While)expr).Body);
}
}
break;
}
}
if (valueStack.Count > 0)
{
return(valueStack.Pop());
}
else
{
return(null);
}
}
public SymbolContext WithScopeValues(RecordValue scopeValues)
{
return(WithScopeValues(new RecordScope(scopeValues)));
}
public SymbolContext WithGlobals(RecordValue globals)
{
return(new SymbolContext(globals, CurrentScope, ScopeValues));
}
/* todo: xingzc.
*
* Need GlobalVar info to initialze nodeInfoTemplates/nodeInfoNone/nodeInfoCalculatorKind
*
* Need to know if left/right is parameterized system and cutnumber. This affects initialize() and Parser.
* For parameterized system, no need to get a subgraph from a Configuration. A counter vector will be ok.
* Probably we can still obtain a subgraph. But do not need to compare subgraphs. Instead, extract a counter
* vector from the subgraph and use it to represent the state info.
*/
public List <PairUpCandidate> execute(Graph left, Graph right, List <string> vars, bool notMaximalBipartite, SpecificationBase leftSpec, SpecificationBase rightSpec, bool eventDetails, bool matchProcessParameters, bool matchStateStructure, bool matchIfGuardCondition)
{
if (left.UserData != null)
{
this.cutnumber1 = (int)left.UserData;
}
if (right.UserData != null)
{
this.cutnumber2 = (int)right.UserData;
}
this.compareParameterizedSystem = (this.cutnumber1 != -1) && (this.cutnumber2 != -1);
this.compareConfigGraph = compareConfigGraph && !compareParameterizedSystem;
this.notMaximalBipartiteMatch = notMaximalBipartite;
this.matchEventDetails = eventDetails;
//ly; newly added.
this.compareConfigGraph = matchStateStructure;
//todo: matchIfGuardCondition needs to be added.
List <string> primitiveVariables = new List <string>();
Valuation leftValuation = leftSpec.GetEnvironment();
foreach (string varName in vars)
{
if (leftValuation != null && leftValuation.Variables != null)
{
ExpressionValue value = leftValuation.Variables.GetContainsKey(varName);
if (value is RecordValue)
{
RecordValue array = value as RecordValue;
List <string> names = new List <string>();
for (int i = 0; i < array.Associations.Length; i++)
{
names.Add(varName);
}
selectedVariables.Add(names.ToArray());
vectorLength.Add(array.Associations.Length); // array length
}
else if (false)
{
// todo: xingzc. processing other complex data type
}
else // primitive types
{
primitiveVariables.Add(varName);
}
}
/* now assume variables of left/right graphs are the same and variables of all the nodes are the same
* thus, no need to do this
*/
/*if (rightValuation != null && rightValuation.Variables != null)
* {
* ExpressionValue value = rightValuation.Variables.GetContainsKey(varName);
* if (value is RecordValue)
* {
* selectedVariables.Add(new string[] {varName});
* //vectorsLength.Add((value as RecordValue).Associations.Length); // array length
* }
* else if (false)
* {
* // todo: xingzc. processing other complex data type
* }
* else // primitive types
* {
* primitiveVariables.Add(varName);
* }
* }*/
}
if (primitiveVariables.Count > 0)
{
selectedVariables.Add(primitiveVariables.ToArray());
vectorLength.Add(primitiveVariables.Count);
}
initialize();
PAT.GenericDiff.diff.GenericDiff diff = new PAT.GenericDiff.diff.GenericDiff(
diffParameters.compatibleTypes,
diffParameters.mappingWeights,
diffParameters.distanceThresholdVectors,
diffParameters.epsilonEdgesExcluded,
diffParameters.maxIteration,
diffParameters.noPairupIdenticalNodesWithOthers,
diffParameters.stepsOfNeighbors,
diffParameters.stopGreedySearchThreshold,
diffParameters.stopPropagationThreshold,
diffParameters.removeOutliersThreshold,
diffParameters.considerNodeDistance,
diffParameters.considerEdgeDistance,
diffParameters.includeUnmatched,
diffParameters.includeNeighbors,
diffParameters.conductCandidatesSearch,
diffParameters.appendEpsilonPairups,
diffParameters.doGreedySearch,
diffParameters.compareAdditionalInfo,
diffParameters.notMaximalBipartiteMatch,
diffParameters.searchPotentialCandidatesKind,
diffParameters.neighborhoodMatchingStrategyKind,
diffParameters.removeOutliersStrtegyKind,
diffParameters.matchingStrategyKind,
null);
leftSpec.GrabSharedDataLock();
leftSpec.LockSharedData(true);
PATModelFileParser modelParser1 = new PATModelFileParser(left, Side.LHS, compareParameterizedSystem, this.compareConfigGraph, matchProcessParameters, infinity, cutnumber1);
PAT.GenericDiff.graph.Graph graphLeft = createGraph(Side.LHS, modelParser1, leftGraphDataConfigs, "leftgraph");
leftSpec.UnLockSharedData();
rightSpec.GrabSharedDataLock();
rightSpec.LockSharedData(true);
PATModelFileParser modelParser2 = new PATModelFileParser(right, Side.RHS, compareParameterizedSystem, this.compareConfigGraph, matchProcessParameters, infinity, cutnumber2);
PAT.GenericDiff.graph.Graph graphRight = createGraph(Side.RHS, modelParser2, rightGraphDataConfigs, "rightgraph");
rightSpec.UnLockSharedData();
List <PairUpCandidate> matches = diff.compare(graphLeft, graphRight);
return(matches);
}
private List <double[]> extractNodeInfos(Valuation globalVars, PAT.GenericDiff.graph.Graph configGraph, String[][] nodeInfoTemplates)
{
List <double[]> nodeInfos = new List <double[]>(nodeInfoTemplates.Length);
for (int i = 0; i < nodeInfoTemplates.Length; i++)
{
nodeInfos.Add(null);
}
if (globalVars != null)
{
if (globalVars.Variables != null)
{
foreach (StringDictionaryEntryWithKey <ExpressionValue> pair in globalVars.Variables._entries)
{
if (pair != null)
{
string varName = pair.Key;
int i = 0;
int j = 0;
for (; i < nodeInfoTemplates.Length; i++)
{
String[] keys = nodeInfoTemplates[i];
for (j = 0; j < keys.Length; j++)
{
if (keys[j].Equals(varName))
{
break;
}
}
if (j < keys.Length)
{
break;
}
}
if (i < nodeInfoTemplates.Length)
{
double value = Double.NaN;
ExpressionValue varValue = pair.Value;
if (varValue is RecordValue)
{
// todo: xingzc. need to get array length and values in the array
RecordValue array = varValue as RecordValue;
ExpressionValue[] values = array.Associations;
nodeInfos[i] = new double[values.Length];
for (int valueIndex = 0; valueIndex < values.Length; valueIndex++)
{
if (values[valueIndex] is IntConstant)
{
nodeInfos[i][valueIndex] = (values[valueIndex] as IntConstant).Value;
}
else if (values[valueIndex] is BoolConstant)
{
nodeInfos[i][valueIndex] = (values[valueIndex] as BoolConstant).Value ? 1.0 : 0.0;
}
else
{
// todo: xingzc. process other primitive types
}
}
}
else if (false)
{
// todo: xingzc. process other complex data type
}
else
{
if (varValue is IntConstant)
{
value = (varValue as IntConstant).Value;
}
else if (varValue is BoolConstant)
{
value = (varValue as BoolConstant).Value ? 1.0 : 0.0;
}
else
{
// todo: xingzc. process other primitive types
}
if (nodeInfos[i] == null)
{
nodeInfos[i] = new double[nodeInfoTemplates[i].Length];
}
if (!Double.IsNaN(value))
{
nodeInfos[i][j] = value;
}
}
}
}
}
}
}
if (!compareConfigGraph)
{
DictionaryJ <int, int[]> mapLabelindexCount = new DictionaryJ <int, int[]>();
List <String> nodeLabels = configGraph.getNodelabels();
foreach (String nodeLabel in nodeLabels)
{
int index = CSPConfigurationParser.mapLabelIndex.get(nodeLabel);
if (0 != index) // index should not be 0 according to the way to build configGraph
{
int[] count = mapLabelindexCount.get(index);
if (null == count)
{
count = new int[1];
mapLabelindexCount.put(index, count);
}
int[] labelIndexCount = CSPConfigurationParser.mapLabelIndexCount.get(index); // shold never be null
if (labelIndexCount != null)
{
count[0] = count[0] + labelIndexCount[0];
}
else
{
count[0]++;
}
}
}
int infoIndex = 0;
double[] labelindexCount = new double[mapLabelindexCount.Count * 2];
foreach (int labelindex in mapLabelindexCount.Keys)
{
int[] count = mapLabelindexCount.get(labelindex);
if (null != count) // count should not be null
{
labelindexCount[infoIndex] = labelindex;
labelindexCount[infoIndex + 1] = count[0];
}
infoIndex = infoIndex + 2;
}
nodeInfos[nodeInfoTemplates.Length - 1] = labelindexCount;
}
return(nodeInfos);
}
private bool ReadDataFromFlash512KByAddress(byte[] address_buffer, ref Values values)
{
byte[] value_sizes = new byte[] { 4, 4, 4, 2, 1, 4 };
byte[] lengths = new byte[] { 52, 64, 16, 24, 12, 48 };
byte[] begin_address = new byte[] { 0x38, 0x6C, 0xAC, 0xC8, 0xE0, 0x08 };
byte number_value = 1;
for (int i = 0; i < begin_address.Length; i++)
{
address_buffer[3] = begin_address[i];
byte[] answer_bytes = new byte[READVALUES_CMD_ANSWER_SIZE + lengths[i]];
if (ReadValuesFromAddress(TypesCommands.tc512K, lengths[i], address_buffer, answer_bytes))
{
List <double> temp_values = new List <double>();
switch (value_sizes[i])
{
case 1:
for (int n = 0; n < lengths[i] / value_sizes[i]; n++)
{
byte value = answer_bytes[m_header_length + n * value_sizes[i]];
temp_values.Add((double)value / 100f);
}
break;
case 2:
for (int n = 0; n < lengths[i] / value_sizes[i]; n++)
{
byte[] temp_buff = CommonMeters.InverseBytesOrder(answer_bytes, Convert.ToUInt32(m_header_length + n * value_sizes[i] + 1), value_sizes[i]);
ushort integer_part = BitConverter.ToUInt16(temp_buff, 0);
temp_values.Add((double)integer_part / 100f);
}
break;
case 4:
for (int n = 0; n < lengths[i] / value_sizes[i]; n++)
{
byte[] temp_buff = CommonMeters.InverseBytesOrder(answer_bytes, Convert.ToUInt32(m_header_length + n * value_sizes[i] + 3), value_sizes[i]);
temp_values.Add((double)(begin_address[i] == 0x08 ? BitConverter.ToSingle(temp_buff, 0) : BitConverter.ToUInt32(temp_buff, 0)));
}
break;
}
if (begin_address[i] == 0x08)
{
for (byte k = 0; k < temp_values.Count; k++)
{
int index = values.listRV.FindIndex(x => x.type == (k + 1));
if (index >= 0)
{
RecordValue rv = values.listRV[index];
rv.value += temp_values[k];
values.listRV[index] = rv;
WriteToLog("temp_values type=" + k.ToString() + "; value = " + temp_values[k].ToString());
}
}
}
else
{
for (int j = 0; j < temp_values.Count; j++)
{
if (m_listTypesForRead.Contains(number_value))
{
RecordValue rv;
rv.fine_state = true;
rv.type = number_value;
rv.value = temp_values[j];
values.listRV.Add(rv);
WriteToLog("value type=" + rv.type.ToString() + "; value = " + rv.value.ToString());
}
number_value++;
}
}
}
else
{
values.listRV.Clear();
break;
}
}
WriteToLog("values.listRV.Count=" + values.listRV.Count.ToString() + "; m_listTypesForRead.Count=" + m_listTypesForRead.Count.ToString());
return((values.listRV.Count == m_listTypesForRead.Count) ? true : false);
}
public bool ReadCurrentValues(ref Values values)
{
byte[] value_sizes = new byte[] { 4, 4, 4, 2, 1, 4 };
byte[] lengths = new byte[] { 52, 64, 16, 24, 12, 48 };
byte[] begin_address = new byte[] { 0x38, 0x6C, 0xAC, 0xC8, 0xE0, 0x08 };
byte[] answer_bytes;
byte number_value = 1;
try
{
for (int i = 0; i < lengths.Length & i < begin_address.Length & i < value_sizes.Length; i++)
{
answer_bytes = new byte[READVALUES_CMD_ANSWER_SIZE + lengths[i]];
if (ReadValuesFromAddress(TypesCommands.tc2K, lengths[i], begin_address, answer_bytes, i))
{
List <double> temp_values = new List <double>();
switch (value_sizes[i])
{
case 1:
for (int n = 0; n < lengths[i] / value_sizes[i]; n++)
{
byte value = answer_bytes[m_header_length + n * value_sizes[i]];
temp_values.Add((double)value / 100f);
}
break;
case 2:
for (int n = 0; n < lengths[i] / value_sizes[i]; n++)
{
byte[] temp_buff = CommonMeters.InverseBytesOrder(answer_bytes, Convert.ToUInt32(m_header_length + n * value_sizes[i] + 1), value_sizes[i]);
ushort integer_part = BitConverter.ToUInt16(temp_buff, 0);
temp_values.Add((double)integer_part / 100f);
}
break;
case 4:
for (int n = 0; n < lengths[i] / value_sizes[i]; n++)
{
byte[] temp_buff = CommonMeters.InverseBytesOrder(answer_bytes, Convert.ToUInt32(m_header_length + n * value_sizes[i] + 3), value_sizes[i]);
temp_values.Add((double)(begin_address[i] == 0x08 ? BitConverter.ToSingle(temp_buff, 0) : BitConverter.ToUInt32(temp_buff, 0)));
}
break;
}
if (begin_address[i] == 0x08)
{
for (byte k = 0; k < temp_values.Count; k++)
{
int index = values.listRV.FindIndex(x => x.type == (k + 1));
if (index >= 0)
{
// WriteToLog(temp_values[k].ToString());
RecordValue rv = values.listRV[index];
rv.value += temp_values[k];
values.listRV[index] = rv;
}
}
}
else
{
for (int j = 0; j < temp_values.Count; j++)
{
// WriteToLog(temp_values[j].ToString());
if (m_listTypesForRead.Contains(number_value))
{
RecordValue rv;
rv.fine_state = true;
rv.type = number_value;
rv.value = temp_values[j];
values.listRV.Add(rv);
}
number_value++;
}
}
}
else
{
number_value += (byte)(lengths[i] / value_sizes[i]);
}
}
}
catch (Exception ex)
{
WriteToLog("ReadCurrentValues: " + ex.Message);
}
return((values.listRV.Count == m_listTypesForRead.Count) ? true : false);
}
/// <summary>
/// Return Valuation in Configuration of given BDD configuration in the column form
/// [ REFS: '', DEREFS: '']
/// </summary>
/// <param name="currentStateDD">current BDD configuration</param>
/// <param name="initialValuation">based on Initial Valuation to get the global variables</param>
/// <returns>Corresponding Valuation of the BDD configuration</returns>
public Valuation GetValuationFromBDD(CUDDNode currentStateDD, Valuation initialValuation)
{
Valuation currentValuation = initialValuation.GetClone();
if (currentValuation.Variables != null && currentValuation.Variables.Count > 0)
{
foreach (StringDictionaryEntryWithKey <ExpressionValue> pair in currentValuation.Variables._entries)
{
if (pair != null)
{
if (pair.Value is RecordValue)
{
RecordValue array = pair.Value as RecordValue;
ExpressionValue[] arrayValue = new ExpressionValue[array.Associations.Length];
for (int i = 0; i < array.Associations.Length; i++)
{
string variableName = pair.Key + Model.NAME_SEPERATOR + i.ToString();
int value = model.GetColVarValue(currentStateDD, variableName);
arrayValue[i] = new IntConstant(value);
}
pair.Value = new RecordValue(arrayValue);
}
else if (pair.Value is BoolConstant)
{
string variableName = pair.Key;
int value = model.GetColVarValue(currentStateDD, variableName);
pair.Value = new BoolConstant(value == 1);
}
else
{
string variableName = pair.Key;
int value = model.GetColVarValue(currentStateDD, variableName);
pair.Value = new IntConstant(value);
}
}
}
}
if (currentValuation.Channels != null && currentValuation.Channels.Count > 0)
{
List <string> channelNames = new List <string>(currentValuation.Channels.Keys);
foreach (string channelName in channelNames)
{
int count = model.GetColVarValue(currentStateDD, Model.GetCountVarChannel(channelName));
int top = model.GetColVarValue(currentStateDD, Model.GetTopVarChannel(channelName));
ChannelQueue currentQueue = new ChannelQueue(count);
int firstElement = 0;
if (top >= count)
{
firstElement = top - count;
}
else
{
firstElement = top - count + model.mapChannelToSize[channelName];
}
for (int i = 0; i < count; i++)
{
int elementSize = model.GetColVarValue(currentStateDD, Model.GetArrayOfSizeElementChannel(channelName) + Model.NAME_SEPERATOR + firstElement);
ExpressionValue[] elementValues = new ExpressionValue[elementSize];
//Find values in the message
for (int j = 0; j < elementSize; j++)
{
int subElementIndex = firstElement * Model.MAX_MESSAGE_LENGTH + j;
int value = model.GetColVarValue(currentStateDD, channelName + Model.NAME_SEPERATOR + subElementIndex.ToString());
elementValues[j] = new IntConstant(value);
}
//Add element to queue
currentQueue.Enqueue(elementValues);
//update to the next element
firstElement = (firstElement + 1) % model.mapChannelToSize[channelName];
}
currentValuation.Channels[channelName] = currentQueue;
}
}
return(currentValuation);
}
private static string RecordValueToString(RecordValue singleValue)
{
if (singleValue.asciiStringValue != null)
return singleValue.asciiStringValue.value;
if (singleValue.intValue != null)
return singleValue.intValue.value.ToString();
if (singleValue.binaryDataValue != null)
return "<binaryBlob>";
if (singleValue.booleanValue != null)
return singleValue.booleanValue.value.ToString();
if (singleValue.byteValue != null)
return singleValue.byteValue.value.ToString();
if (singleValue.dateAndTimeValue != null)
return singleValue.dateAndTimeValue.value.ToString();
if (singleValue.floatValue != null)
return singleValue.shortValue.value.ToString();
if (singleValue.shortValue != null)
return singleValue.shortValue.value.ToString();
if (singleValue.unicodeStringValue != null)
return singleValue.unicodeStringValue.value;
return "<empty>";
}
