/// <summary>
/// Checks an expression associated to a model element
/// </summary>
/// <param name="model">The model element on which the expression is defined</param>
/// <param name="expression">The expression to check</param>
/// <returns>the expression parse tree</returns>
private Interpreter.Expression checkExpression(ModelElement model, string expression)
{
Interpreter.Expression retVal = null;
Interpreter.Parser parser = model.EFSSystem.Parser;
try
{
retVal = parser.Expression(model, expression);
if (retVal != null)
{
retVal.checkExpression();
Types.Type type = retVal.GetExpressionType();
if (type == null)
{
model.AddError("Cannot determine expression type (5) for " + retVal.ToString());
}
}
else
{
model.AddError("Cannot parse expression");
}
}
catch (Exception exception)
{
model.AddException(exception);
}
return(retVal);
}
public void TestApplyStatement()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Structure s1 = CreateStructure(n1, "S1");
StructureElement el1 = CreateStructureElement(s1, "E1", "Boolean");
Structure s2 = CreateStructure(n1, "S2");
StructureElement el2 = CreateStructureElement(s2, "E2", "S1");
Function function = CreateFunction(n1, "f", "S1");
Collection collection = CreateCollection(n1, "Col", "S1", 10);
Variable v = CreateVariable(n1, "V", "Col");
Compiler.Compile_Synchronous(true, true);
RuleCondition rc = CreateRuleAndCondition(n1, "Rule1");
Parser parser = new Parser();
{
ApplyStatement statement = parser.Statement(rc, "APPLY X <- X", true, true) as ApplyStatement;
Assert.IsNotNull(statement);
}
{
ApplyStatement statement = parser.Statement(rc, "APPLY X <- X ON V | X.", true, true) as ApplyStatement;
Assert.IsNotNull(statement);
DerefExpression deref = statement.ConditionExpression as DerefExpression;
Assert.IsNotNull(deref);
ITypedElement element = deref.Arguments[0].Ref as ITypedElement;
Assert.IsNotNull(element);
Assert.AreEqual(element.Type, s1);
}
}
public void TestFunctionCall()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Structure s1 = CreateStructure(n1, "S1");
StructureElement el1 = CreateStructureElement(s1, "E1", "Boolean");
Structure s2 = CreateStructure(n1, "S2");
StructureElement el2 = CreateStructureElement(s2, "E2", "S1");
Variable v = CreateVariable(n1, "V", "S1");
v.setDefaultValue("N1.S1 { E1 => True }");
Function function = CreateFunction(n1, "f", "S1");
Compiler.Compile_Synchronous(true, true);
RuleCondition rc = CreateRuleAndCondition(n1, "Rule1");
Parser parser = new Parser();
{
// 0 1
// 012345678901
const string text = "V <- f().S";
VariableUpdateStatement statement = parser.Statement(rc, text, true, true) as VariableUpdateStatement;
ContextGrabber grabber = new ContextGrabber();
Assert.AreEqual(v, grabber.GetContext(0, statement));
Assert.AreEqual(v, grabber.GetContext(1, statement));
Assert.IsNull(grabber.GetContext(2, statement));
Assert.IsNull(grabber.GetContext(3, statement));
Assert.IsNull(grabber.GetContext(4, statement));
Assert.AreEqual(function, grabber.GetContext(5, statement));
Assert.AreEqual(function, grabber.GetContext(6, statement));
Assert.AreEqual(function, grabber.GetContext(7, statement));
Assert.AreEqual(s1, grabber.GetContext(8, statement));
Assert.IsNull(grabber.GetContext(9, statement));
Assert.IsNull(grabber.GetContext(10, statement));
}
{
// 0
// 0123456789
const string text = "V <- f().";
VariableUpdateStatement statement = parser.Statement(rc, text, true, true) as VariableUpdateStatement;
ContextGrabber grabber = new ContextGrabber();
Assert.AreEqual(v, grabber.GetContext(0, statement));
Assert.AreEqual(v, grabber.GetContext(1, statement));
Assert.IsNull(grabber.GetContext(2, statement));
Assert.IsNull(grabber.GetContext(3, statement));
Assert.IsNull(grabber.GetContext(4, statement));
Assert.AreEqual(function, grabber.GetContext(5, statement));
Assert.AreEqual(function, grabber.GetContext(6, statement));
Assert.AreEqual(function, grabber.GetContext(7, statement));
Assert.AreEqual(s1, grabber.GetContext(8, statement));
Assert.IsNull(grabber.GetContext(9, statement));
}
}
/// <summary>
/// Ensures that the string provided is a type
/// </summary>
/// <param name="text"></param>
/// <param name="instance"></param>
/// <returns></returns>
public override bool AdditionalCheck(string text, ModelElement instance)
{
bool retVal = base.AdditionalCheck(text, instance);
if (retVal && instance != null)
{
Expression expression = new Parser().Expression(instance, text, IsType.INSTANCE, true, null,
true);
retVal = (expression != null && expression.Ref != null) && !(expression.Ref is Function);
}
return retVal;
}
public void TestApplyStatement()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Structure s1 = CreateStructure(n1, "S1");
StructureElement el1 = CreateStructureElement(s1, "E1", "Boolean");
Structure s2 = CreateStructure(n1, "S2");
StructureElement el2 = CreateStructureElement(s2, "E2", "S1");
Function function = CreateFunction(n1, "f", "S1");
Collection collection = CreateCollection(n1, "Col", "S1", 10);
Variable v = CreateVariable(n1, "V", "Col");
Compiler.Compile_Synchronous(true, true);
RuleCondition rc = CreateRuleAndCondition(n1, "Rule1");
Parser parser = new Parser();
{
// 0 1 2
// 012345678901234567890123
const string text = "APPLY X <- X ON V | X.";
ApplyStatement statement = parser.Statement(rc, text, true, true) as ApplyStatement;
Assert.IsNotNull(statement);
ContextGrabber grabber = new ContextGrabber();
Assert.IsNull(grabber.GetContext(0, statement));
Assert.IsNull(grabber.GetContext(1, statement));
Assert.IsNull(grabber.GetContext(2, statement));
Assert.IsNull(grabber.GetContext(3, statement));
Assert.IsNull(grabber.GetContext(4, statement));
Assert.IsNull(grabber.GetContext(5, statement));
Assert.AreEqual(statement.IteratorVariable, grabber.GetContext(6, statement));
Assert.AreEqual(statement.IteratorVariable, grabber.GetContext(7, statement));
Assert.IsNull(grabber.GetContext(8, statement));
Assert.IsNull(grabber.GetContext(9, statement));
Assert.IsNull(grabber.GetContext(10, statement));
Assert.AreEqual(statement.IteratorVariable, grabber.GetContext(11, statement));
Assert.AreEqual(statement.IteratorVariable, grabber.GetContext(12, statement));
Assert.IsNull(grabber.GetContext(13, statement));
Assert.IsNull(grabber.GetContext(14, statement));
Assert.IsNull(grabber.GetContext(15, statement));
Assert.AreEqual(v, grabber.GetContext(16, statement));
Assert.AreEqual(v, grabber.GetContext(17, statement));
Assert.IsNull(grabber.GetContext(18, statement));
Assert.IsNull(grabber.GetContext(19, statement));
Assert.AreEqual(statement.IteratorVariable, grabber.GetContext(20, statement));
Assert.AreEqual(statement.IteratorVariable, grabber.GetContext(21, statement));
Assert.IsNull(grabber.GetContext(22, statement));
}
}
/// <summary>
/// Checks a statement associated to a model element
/// </summary>
/// <param name="model">The model element on which the expression is defined</param>
/// <param name="expression">The expression to check</param>
/// <returns>the expression parse tree</returns>
private Interpreter.Statement.Statement checkStatement(ModelElement model, string expression)
{
Interpreter.Statement.Statement retVal = null;
Interpreter.Parser parser = model.EFSSystem.Parser;
try
{
retVal = parser.Statement(model, expression);
retVal.CheckStatement();
}
catch (Exception exception)
{
model.AddException(exception);
}
return(retVal);
}
public void TestUncacheFunctionBasedOnInnerFunctionCall()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Collection c = CreateCollection(n1, "C", "Integer", 10);
Variable a = CreateVariable(n1, "a", "C");
a.setDefaultValue("[1]");
Variable b = CreateVariable(n1, "b", "C");
b.setDefaultValue("[10]");
Function f = CreateFunction(n1, "f", "C");
Case always_f = CreateCase(f, "Always", "g() + h()");
Function g = CreateFunction(n1, "g", "C");
Case always_g = CreateCase(g, "Always", "a");
Function h = CreateFunction(n1, "h", "C");
Case always_h = CreateCase(h, "Always", "b");
RuleCondition updateGlobalVariables = CreateRuleAndCondition(n1, "Update Global variables");
Action act1 = CreateAction(updateGlobalVariables, "a <- a + [2]");
Action act2 = CreateAction(updateGlobalVariables, "b <- b + [20]");
Compiler.Compile_Synchronous(true);
Expression expression = new Parser().Expression(test, "N1.f()");
ListValue value = expression.GetExpressionValue(new InterpretationContext(), null) as ListValue;
Assert.IsNotNull(value);
Assert.AreEqual(2, value.Val.Count);
// ReSharper disable once UseObjectOrCollectionInitializer
Runner runner = new Runner(false);
runner.CheckForCompatibleChanges = true;
runner.Cycle();
value = expression.GetExpressionValue(new InterpretationContext(), null) as ListValue;
Assert.IsNotNull(value);
Assert.AreEqual(4, value.Val.Count);
}
public void TestUpdateRule()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "NameSpace");
Variable var = CreateVariable(nameSpace, "TheVariable", "Integer");
var.setDefaultValue("0");
RuleCondition condition1 = CreateRuleAndCondition(nameSpace, "Rule1");
Rule rule = condition1.EnclosingRule;
Action action = CreateAction(condition1, "TheVariable <- 1");
Compiler.Compile_Synchronous(true);
System.Runner = new Runner(false);
Expression expression = new Parser().Expression(dictionary, "NameSpace.TheVariable");
IValue value = expression.GetExpressionValue(new InterpretationContext(), null);
Assert.AreEqual(value.LiteralName, "0");
System.Runner.Cycle();
value = expression.GetExpressionValue(new InterpretationContext(), null);
Assert.AreEqual(value.LiteralName, "1");
Dictionary update = CreateDictionary("TestUpdate");
update.setUpdates(dictionary.Guid);
NameSpace updNameSpace = CreateNameSpace(update, "NameSpace");
updNameSpace.setUpdates(nameSpace.Guid);
RuleCondition updCondition = CreateRuleAndCondition(updNameSpace, "Rule1");
Rule updRule = updCondition.EnclosingRule;
Action updAction = CreateAction(updCondition, "TheVariable <- 2");
updRule.setUpdates(rule.Guid);
System.Runner.Cycle();
value = expression.GetExpressionValue(new InterpretationContext(), null);
Assert.AreEqual(value.LiteralName, "2");
}
public void TestParameterTypeInDefaultNameSpace()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace defaultNameSpace = CreateNameSpace(dictionary, "Default");
NameSpace nameSpace = CreateNameSpace(dictionary, "N1");
Enum enumeration = CreateEnum(defaultNameSpace, "Enum");
EnumValue value1 = CreateEnumValue(enumeration, "First");
EnumValue value2 = CreateEnumValue(enumeration, "Second");
Function function = CreateFunction(nameSpace, "F1", "Boolean");
Parameter param = new Parameter();
param.setTypeName("Enum");
param.setName("Value");
function.appendParameters(param);
Case cas1 = CreateCase(function, "Case 1", "True", "Value == Enum.First");
Case cas2 = CreateCase(function, "Case 2", "False");
Dictionary dictionary2 = CreateDictionary("TestUpdate");
dictionary2.setUpdates(dictionary.Guid);
Function updatedFunction = function.CreateFunctionUpdate(dictionary2);
Case cas3 = (Case) updatedFunction.Cases[0];
PreCondition preCondition = (PreCondition) cas3.PreConditions[0];
preCondition.ExpressionText = "Value == Enum.Second";
Compiler.Compile_Synchronous(true);
RuleCheckerVisitor ruleChecker = new RuleCheckerVisitor(dictionary2);
ruleChecker.visit(updatedFunction);
Assert.IsNull(ErrorMessage(updatedFunction));
Expression expression = new Parser().Expression(dictionary, "N1.F1(Enum.Second)");
IValue value = expression.GetExpressionValue(new InterpretationContext(), null);
Assert.AreEqual(System.BoolType.True, value);
}
public void TestFunctionCall()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Structure s1 = CreateStructure(n1, "S1");
StructureElement el1 = CreateStructureElement(s1, "E1", "Boolean");
Structure s2 = CreateStructure(n1, "S2");
StructureElement el2 = CreateStructureElement(s2, "E2", "S1");
Variable v = CreateVariable(n1, "V", "S1");
v.setDefaultValue("N1.S1 { E1 => True }");
Function function = CreateFunction(n1, "f", "S1");
Compiler.Compile_Synchronous(true, true);
RuleCondition rc = CreateRuleAndCondition(n1, "Rule1");
Parser parser = new Parser();
{
VariableUpdateStatement statement =
parser.Statement(rc, "V <- f().S", true, true) as VariableUpdateStatement;
Assert.IsNotNull(statement);
Assert.AreEqual(statement.VariableIdentification.Ref, v);
DerefExpression deref = statement.Expression as DerefExpression;
Assert.IsNotNull(deref);
Assert.AreEqual(deref.Arguments[0].Ref, s1);
}
{
VariableUpdateStatement statement = parser.Statement(rc, "V <- f().", true, true) as VariableUpdateStatement;
Assert.IsNotNull(statement);
Assert.AreEqual(statement.VariableIdentification.Ref, v);
DerefExpression deref = statement.Expression as DerefExpression;
Assert.IsNotNull(deref);
Assert.AreEqual(deref.Arguments[0].Ref, s1);
}
}
/// <summary>
/// Indicates that the expression is valid for this IExpressionable
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
public bool checkValidExpression(string expression)
{
bool retVal = false;
Statement tree = new Parser().Statement(this, expression, true);
retVal = tree != null;
return retVal;
}
/// <summary>
/// Indicates that the expression is valid for this IExpressionable
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
public bool checkValidExpression(string expression)
{
// ReSharper disable once JoinDeclarationAndInitializer
bool retVal;
Expression tree = new Parser().Expression(this, expression, null, false, null, true);
retVal = tree != null;
return retVal;
}
public void TestVariableAndTypeWithSameName()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "NameSpace");
Structure structure = CreateStructure(nameSpace, "ModelElement");
StructureElement structElem = CreateStructureElement(structure, "Value", "Boolean");
structElem.setDefault("True");
Variable variable = CreateVariable(nameSpace, "ModelElement", "ModelElement");
variable.SubVariables["Value"].Value = System.BoolType.False;
Expression expression = new Parser().Expression(dictionary, "NameSpace.ModelElement.Value");
IValue value = expression.GetExpressionValue(new InterpretationContext(), null);
Assert.AreEqual(value, variable.SubVariables["Value"].Value);
}
/// <summary>
/// Gets a value based on its image
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public override IValue getValue(string image)
{
IValue retVal = null;
if (Char.IsLetter(image[0]) || image[0] == '_')
{
int lastDotPosition = image.LastIndexOf('.');
if (lastDotPosition > 0)
{
string prefix = image.Substring(0, lastDotPosition);
Expression typeExpression = new Parser().Expression(this, prefix,
IsType.INSTANCE, true, null, true);
if (typeExpression != null && typeExpression.Ref == this)
{
image = image.Substring(lastDotPosition + 1);
}
}
List<INamable> tmp = new List<INamable>();
ISubDeclaratorUtils.Find(this, image, tmp);
if (tmp.Count == 1)
{
retVal = tmp[0] as IValue;
}
if (retVal == null)
{
throw new Exception("Cannot find boolean from " + image);
}
}
return retVal;
}
public void TestUpdateMultipleFunctions()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "N1");
Function function = CreateFunction(nameSpace, "f", "Bool");
Case cas1 = CreateCase(function, "Case 1", "q()");
Function function2 = CreateFunction(nameSpace, "q", "Bool");
Case cas2 = CreateCase(function2, "Case 1", "True");
Dictionary dictionary2 = CreateDictionary("TestUpdate");
dictionary2.setUpdates(dictionary.Guid);
Function updatedFunction = function.CreateFunctionUpdate(dictionary2);
Case cas3 = (Case) updatedFunction.Cases[0];
cas3.ExpressionText = "NOT q(param => 3)";
Function updatedFunction2 = function2.CreateFunctionUpdate(dictionary2);
Parameter intParameter = CreateParameter(updatedFunction2, "param", "Integer");
Case cas4 = (Case) updatedFunction2.Cases[0];
cas4.ExpressionText = "False";
Compiler.Compile_Synchronous(true);
Expression expression = new Parser().Expression(dictionary, "N1.f()");
IValue value = expression.GetExpressionValue(new InterpretationContext(), null);
Assert.AreEqual(System.BoolType.True, value);
}
/// <summary>
/// Edits a value expression and provides the edited expression after user has performed his changes
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
private Expression EditExpression(Expression expression)
{
Expression retVal = expression;
if (expression != null)
{
ModelElement.DontRaiseError(() =>
{
InterpretationContext context = new InterpretationContext(Model) {UseDefaultValue = false};
IValue value = expression.GetExpressionValue(context, null);
if (value != null)
{
StructureEditor.Window window = new StructureEditor.Window();
window.SetModel(value);
window.ShowDialog();
string newExpression = value.ToExpressionWithDefault();
const bool doSemanticalAnalysis = true;
const bool silent = true;
retVal = new Parser().Expression(expression.Root, newExpression,
AllMatches.INSTANCE, doSemanticalAnalysis, null, silent);
}
});
}
return retVal;
}
public void TestParameterTypeReference()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "N1");
Enum enumeration = CreateEnum(nameSpace, "Enum");
EnumValue value1 = CreateEnumValue(enumeration, "First");
Function function = CreateFunction(nameSpace, "f", "Bool");
Parameter param = new Parameter();
param.setTypeName("N1.Enum");
param.setName("Value");
function.appendParameters(param);
Case cas1 = CreateCase(function, "Case 1", "True", "Value == Enum.First");
Dictionary dictionary2 = CreateDictionary("TestUpdate");
dictionary2.setUpdates(dictionary.Guid);
Function updatedFunction = function.CreateFunctionUpdate(dictionary2);
Case cas3 = (Case) updatedFunction.Cases[0];
cas3.ExpressionText = "False";
Compiler.Compile_Synchronous(true);
Expression expression = new Parser().Expression(dictionary, "N1.f(N1.Enum.First)");
IValue value = expression.GetExpressionValue(new InterpretationContext(), null);
Assert.AreEqual(System.BoolType.False, value);
}
public string format_default_message(string expression)
{
string retVal = "<not a structure type>";
int index = expression.IndexOf("<-");
if (index > 0)
{
string variableText = expression.Substring(0, index).Trim();
Expression expressionTree = new Parser().Expression(Dictionary, variableText);
if (expressionTree != null)
{
Structure structureType = expressionTree.GetExpressionType() as Structure;
retVal = structureType.DefaultValue.LiteralName;
}
}
return retVal;
}
public void TestListExpression()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Structure s1 = CreateStructure(n1, "S1");
StructureElement el1 = CreateStructureElement(s1, "E1", "Boolean");
Structure s2 = CreateStructure(n1, "S2");
StructureElement el2 = CreateStructureElement(s2, "E2", "S1");
Function function = CreateFunction(n1, "f", "S1");
Collection collection = CreateCollection(n1, "Col", "S1", 10);
Variable v = CreateVariable(n1, "V", "Col");
Compiler.Compile_Synchronous(true, true);
RuleCondition rc = CreateRuleAndCondition(n1, "Rule1");
Parser parser = new Parser();
{
VariableUpdateStatement statement = parser.Statement(rc, "V <- [S1 { E1 => Tr", true, true) as VariableUpdateStatement;
Assert.IsNotNull(statement);
UnaryExpression unaryExpression = statement.Expression as UnaryExpression;
Assert.IsNotNull(unaryExpression);
ListExpression listExpression = unaryExpression.Term.LiteralValue as ListExpression;
Assert.IsNotNull(listExpression);
Assert.AreEqual(listExpression.ListElements.Count, 1);
StructExpression structExpression = listExpression.ListElements[0] as StructExpression;
Assert.IsNotNull(structExpression);
}
}
/// <summary>
/// Handles a drop event
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void TimeLineControl_DragDrop(object sender, DragEventArgs e)
{
if (e.Data.GetDataPresent("WindowsForms10PersistentObject", false))
{
BaseTreeNode sourceNode = e.Data.GetData("WindowsForms10PersistentObject") as BaseTreeNode;
if (sourceNode != null)
{
VariableTreeNode variableNode = sourceNode as VariableTreeNode;
if (variableNode != null)
{
SubStep subStep = SubStepRelatedToMousePosition();
if (subStep != null)
{
// Create the default value
IValue value = null;
Expression expression = null;
string defaultValue = variableNode.Item.Default;
if (defaultValue != null)
{
const bool doSemanticalAnalysis = true;
const bool silent = true;
expression = new Parser().Expression(variableNode.Item, defaultValue,
AllMatches.INSTANCE, doSemanticalAnalysis, null, silent);
}
if (expression != null)
{
InterpretationContext context = new InterpretationContext {UseDefaultValue = false};
value = expression.GetExpressionValue(context, null);
}
if (value == null || value is EmptyValue)
{
Structure structureType = variableNode.Item.Type as Structure;
if (structureType != null)
{
const bool setDefaultValue = false;
value = new StructureValue(structureType, setDefaultValue);
}
}
// Create the action or the expectation according to the keyboard modifier keys
if (value != null)
{
if ((e.KeyState & Ctrl) != 0)
{
Expectation expectation = (Expectation) acceptor.getFactory().createExpectation();
expectation.ExpressionText = variableNode.Item.FullName + " == " + value.FullName;
subStep.appendExpectations(expectation);
}
else
{
Action action = (Action) acceptor.getFactory().createAction();
action.ExpressionText = variableNode.Item.FullName + " <- " + value.FullName;
subStep.appendActions(action);
}
}
else
{
MessageBox.Show(
Resources
.StaticTimeLineControl_TimeLineControl_DragDrop_Cannot_evaluate_variable_default_value,
Resources.StaticTimeLineControl_TimeLineControl_DragDrop_Cannot_create_event,
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
}
}
}
}
}
public void TestMapExpression()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Structure s1 = CreateStructure(n1, "S1");
StructureElement el1 = CreateStructureElement(s1, "E1", "Boolean");
Structure s2 = CreateStructure(n1, "S2");
StructureElement el2 = CreateStructureElement(s2, "E2", "S1");
Function function = CreateFunction(n1, "f", "S1");
Collection collection = CreateCollection(n1, "Col", "S1", 10);
Variable v = CreateVariable(n1, "V", "Col");
Compiler.Compile_Synchronous(true, true);
RuleCondition rc = CreateRuleAndCondition(n1, "Rule1");
Parser parser = new Parser();
{
MapExpression expression = parser.Expression(rc, "MAP V | X. USING X IN X.E2", null, true, null, true, true) as MapExpression;
Assert.IsNotNull(expression);
DerefExpression deref = expression.Condition as DerefExpression;
Assert.IsNotNull(deref);
ITypedElement element = deref.Arguments[0].Ref as ITypedElement;
Assert.IsNotNull(element);
Assert.AreEqual(element.Type, s1);
}
}
/// <summary>
/// Indicates that the expression is valid for this IExpressionable
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
public bool checkValidExpression(string expression)
{
// ReSharper disable once RedundantAssignment
bool retVal = false;
Statement tree = new Parser().Statement(this, expression, true);
retVal = tree != null;
return retVal;
}
public void TestMapExpression()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Structure s1 = CreateStructure(n1, "S1");
StructureElement el1 = CreateStructureElement(s1, "E1", "Boolean");
Structure s2 = CreateStructure(n1, "S2");
StructureElement el2 = CreateStructureElement(s2, "E2", "S1");
Function function = CreateFunction(n1, "f", "S1");
Collection collection = CreateCollection(n1, "Col", "S1", 10);
Variable v = CreateVariable(n1, "V", "Col");
Compiler.Compile_Synchronous(true, true);
RuleCondition rc = CreateRuleAndCondition(n1, "Rule1");
Parser parser = new Parser();
{
// 0 1 2
// 012345678901234567890123456
const string text = "MAP V | X. USING X IN X.E1";
MapExpression expression = parser.Expression(rc, text, null, true, null, true, true) as MapExpression;
Assert.IsNotNull(expression);
ContextGrabber grabber = new ContextGrabber();
Assert.IsNull(grabber.GetContext(0, expression));
Assert.IsNull(grabber.GetContext(1, expression));
Assert.IsNull(grabber.GetContext(2, expression));
Assert.IsNull(grabber.GetContext(3, expression));
Assert.AreEqual(v, grabber.GetContext(4, expression));
Assert.AreEqual(v, grabber.GetContext(5, expression));
Assert.IsNull(grabber.GetContext(6, expression));
Assert.IsNull(grabber.GetContext(7, expression));
Assert.AreEqual(expression.IteratorVariable, grabber.GetContext(8, expression));
Assert.AreEqual(expression.IteratorVariable, grabber.GetContext(9, expression));
Assert.IsNull(grabber.GetContext(10, expression));
Assert.IsNull(grabber.GetContext(11, expression));
Assert.IsNull(grabber.GetContext(12, expression));
Assert.IsNull(grabber.GetContext(13, expression));
Assert.IsNull(grabber.GetContext(14, expression));
Assert.IsNull(grabber.GetContext(15, expression));
Assert.IsNull(grabber.GetContext(16, expression));
Assert.IsNull(grabber.GetContext(17, expression));
Assert.IsNull(grabber.GetContext(18, expression));
Assert.IsNull(grabber.GetContext(19, expression));
Assert.IsNull(grabber.GetContext(20, expression));
Assert.IsNull(grabber.GetContext(21, expression));
Assert.AreEqual(expression.IteratorVariable, grabber.GetContext(22, expression));
Assert.AreEqual(expression.IteratorVariable, grabber.GetContext(23, expression));
Assert.AreEqual(el1, grabber.GetContext(24, expression));
Assert.AreEqual(el1, grabber.GetContext(25, expression));
Assert.AreEqual(el1, grabber.GetContext(26, expression));
Assert.IsNull(grabber.GetContext(27, expression));
}
}
public void TestStructureDereference()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "N1");
Structure structure = CreateStructure (nameSpace, "Struct");
StructureElement el1 = CreateStructureElement (structure, "e1", "Boolean");
Function f = CreateFunction (nameSpace, "f", "Struct");
Variable v = CreateVariable (nameSpace, "v", "Struct");
Variable v2 = CreateVariable(nameSpace, "v2", "Boolean");
Parser parser = new Parser ();
{
DerefExpression expression = parser.Expression (nameSpace, "N1.v.e1") as DerefExpression;
Assert.IsNotNull (expression);
Assert.AreEqual(3, expression.Arguments.Count);
Assert.AreEqual(v, expression.Arguments[1].Ref);
Assert.AreEqual (el1, expression.Arguments [2].Ref);
}
{
DerefExpression expression = parser.Expression (nameSpace, "N1.f().e1") as DerefExpression;
Assert.IsNotNull (expression);
Assert.AreEqual (2, expression.Arguments.Count);
Assert.AreEqual (structure, expression.Arguments [0].Ref);
Assert.AreEqual (el1, expression.Arguments [1].Ref);
}
{
DerefExpression expression = parser.Expression(nameSpace, "N1.Struct.e1") as DerefExpression;
Assert.IsNotNull(expression);
Assert.AreEqual(3, expression.Arguments.Count);
Assert.AreEqual(structure, expression.Arguments[1].Ref);
Assert.AreEqual(el1, expression.Arguments[2].Ref);
}
RuleCondition condition = CreateRuleAndCondition (nameSpace, "Test");
Action action1 = CreateAction (condition, "Struct.e1 <- True");
Action action2 = CreateAction(condition, "v2 <- Struct.e1");
Action action3 = CreateAction(condition, "f().e1 <- True");
Action action4 = CreateAction(condition, "v2 <- f().e1");
Collection collection = CreateCollection (nameSpace, "Col", "Struct", 10);
Variable v3 = CreateVariable (nameSpace, "v3", "Col");
Action action5 = CreateAction (condition, "(FIRST X IN v3).e1 <- True");
RuleCondition ruleCondition2 = CreateRuleAndCondition(structure, "Rule");
Action action6 = CreateAction (ruleCondition2, "THIS.e1 <- True");
Action action7 = CreateAction(ruleCondition2, "v2 <- THIS.e1");
RuleCheckerVisitor visitor = new RuleCheckerVisitor(dictionary);
visitor.visit(nameSpace);
Assert.True(HasMessagePart(action1, "structure should not be used to reference an instance"));
Assert.True(HasMessagePart(action2, "structure should not be used to reference an instance"));
Assert.False(HasMessagePart(action3, "structure should not be used to reference an instance"));
Assert.False(HasMessagePart(action4, "structure should not be used to reference an instance"));
Assert.False(HasMessagePart(action5, "structure should not be used to reference an instance"));
Assert.False(HasMessagePart(action6, "structure should not be used to reference an instance"));
Assert.False(HasMessagePart(action7, "structure should not be used to reference an instance"));
}
/// <summary>
/// Parses the current statement or expression and returns the interpreter tree node
/// </summary>
/// <param name="text">The text to parse</param>
/// <returns></returns>
private InterpreterTreeNode Parse(string text)
{
InterpreterTreeNode retVal = null;
if (!String.IsNullOrEmpty(text))
{
Parser parser = new Parser();
retVal = parser.Statement(Instance as ModelElement, EditionTextBox.Text, true, true);
if (retVal == null)
{
retVal = parser.Expression(Instance as ModelElement, text, AllMatches.INSTANCE, true, null, true, true);
}
}
return retVal;
}
public void TestUpdateRemoved()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "N1");
Function function = CreateFunction(nameSpace, "f", "Bool");
Case cas1 = CreateCase(function, "Case 1", "q()");
Function function2 = CreateFunction(nameSpace, "q", "Bool");
Case cas2 = CreateCase(function2, "Case 1", "True");
Dictionary dictionary2 = CreateDictionary("TestUpdate");
dictionary2.setUpdates(dictionary.Guid);
Function updatedFunction = function.CreateFunctionUpdate(dictionary2);
updatedFunction.setIsRemoved(true);
Compiler.Compile_Synchronous(true);
Expression expression = new Parser().Expression(dictionary, "N1.f()");
Assert.AreEqual(Utils.ModelElement.Errors.Count, 1);
}
/// <summary>
/// Applies this step activation be registering it in the activation cache
/// </summary>
/// <param name="runner"></param>
public override void Apply(Runner runner)
{
base.Apply(runner);
TimeLine.SubStepActivationCache[SubStep] = this;
foreach (VariableUpdate update in Updates)
{
TimeLine.AddModelEvent(update, runner, true);
}
// Store the step corresponding expectations
foreach (Expectation expectation in subStep.Expectations)
{
bool addExpectation = true;
if (expectation.getKind() == acceptor.ExpectationKind.aInstantaneous)
{
if (!String.IsNullOrEmpty(expectation.getCondition()))
{
Expression expression = new Parser().Expression(expectation,
expectation.getCondition());
BoolValue value =
expression.GetExpressionValue(new InterpretationContext(expectation), null) as BoolValue;
if (value != null)
{
addExpectation = value.Val;
}
else
{
throw new Exception("Cannot evaluate " + expectation.getCondition() + " as a boolean value");
}
}
}
if (addExpectation)
{
TimeLine.AddModelEvent(new Expect(expectation, runner.CurrentPriority), runner, true);
}
}
}
/// <summary>
/// Parses the image and provides the corresponding value
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public override IValue getValue(string image)
{
IValue retVal = null;
Expression expression = new Parser().Expression(this, image);
if (expression != null)
{
retVal = expression.GetExpressionValue(new InterpretationContext(this), null);
}
return retVal;
}
/// <summary>
/// Allows to refresh the view, when the value of a model changed
/// </summary>
/// <param name="modelElement"></param>
/// <param name="changeKind"></param>
/// <returns>True if the view should be refreshed</returns>
public override bool HandleValueChange(IModelElement modelElement, Context.ChangeKind changeKind)
{
bool retVal = base.HandleValueChange(modelElement, changeKind);
if (retVal)
{
if (Variable != null)
{
Expression expression = new Parser().Expression(
EnclosingFinder<Dictionary>.find(Variable), Variable.FullName);
IVariable variable = expression.GetVariable(new InterpretationContext());
if (variable != Variable)
{
SetVariable(variable);
}
else
{
structureTreeListView.RefreshObject(Variable);
structureTreeListView.Refresh();
}
}
}
return retVal;
}
/// <summary>
/// Parses the image and provides the corresponding value
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public override IValue getValue(string image)
{
IValue retVal = null;
if (image.Length > 0 && (Char.IsLetter(image[0]) || image[0] == '_'))
{
int lastDotPosition = image.LastIndexOf('.');
if (lastDotPosition > 0)
{
string prefix = image.Substring(0, lastDotPosition);
Expression typeExpression = new Parser().Expression(this, prefix,
IsType.INSTANCE, true, null, true);
if (typeExpression != null && typeExpression.Ref == this)
{
image = image.Substring(lastDotPosition + 1);
}
}
retVal = findEnumValue(image);
if (retVal == null)
{
AddError("Cannot create range value from " + image);
}
}
else
{
try
{
switch (getPrecision())
{
case acceptor.PrecisionEnum.aIntegerPrecision:
{
Decimal val = Decimal.Parse(image);
Decimal min = MinValueAsLong;
Decimal max = MaxValueAsLong;
if (val >= min && val <= max)
{
retVal = new IntValue(this, val);
}
}
break;
case acceptor.PrecisionEnum.aDoublePrecision:
{
double val = getDouble(image);
double min = MinValueAsDouble;
double max = MaxValueAsDouble;
if (val >= min && val <= max)
{
retVal = new DoubleValue(this, val);
}
break;
}
}
}
catch (Exception exception)
{
AddException(exception);
}
}
return retVal;
}
private void openStructureEditorToolStripMenuItem_Click(object sender, EventArgs e)
{
bool dialogShown = false;
ExplanationPart part = Instance as ExplanationPart;
if (part != null)
{
IValue value = part.RightPart as IValue;
if (value != null)
{
StructureEditor.Window window = new StructureEditor.Window();
window.SetModel(value);
window.ShowDialog();
dialogShown = true;
}
Action action = part.Element as Action;
if (!dialogShown && action != null)
{
VisitStatement(action.Statement);
dialogShown = true;
}
Expectation expectation = part.Element as Expectation;
if (!dialogShown && expectation != null)
{
VisitExpression(expectation.Expression);
dialogShown = true;
}
}
if (!dialogShown)
{
const bool doSemanticalAnalysis = true;
const bool silent = true;
ModelElement root = Instance as ModelElement;
if (root == null)
{
root = EfsSystem.Instance.Dictionaries[0];
}
string text = EditionTextBox.Text;
Expression expression = new Parser().Expression(root, text, AllMatches.INSTANCE,
doSemanticalAnalysis, null, silent);
if (expression != null)
{
expression = VisitExpression(expression);
EditionTextBox.Text = expression.ToString();
}
Statement statement = new Parser().Statement(root, text, silent);
if (statement != null)
{
statement = VisitStatement(statement);
EditionTextBox.Text = statement.ToString();
}
}
}
/// <summary>
/// Indicates that the expression is valid for this IExpressionable
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
public bool checkValidExpression(string expression)
{
bool retVal = false;
Expression tree = new Parser().Expression(this, expression, null, false, null, true);
retVal = tree != null;
return retVal;
}