public void CreateSimpleVariableExpression()
{
Variable variable = new Variable("X");
VariableExpression expression = new VariableExpression(variable);
Assert.AreEqual(variable, expression.Variable);
}
public void EvaluateUndefinedVariableExpression()
{
Variable variable = new Variable("X");
Context context = new Context();
VariableExpression expression = new VariableExpression(variable);
Assert.AreEqual(variable, expression.Evaluate(context, true));
}
/// <summary>
/// Visits an element of type <see cref="VariableExpression" />.
/// </summary>
/// <param name="expression">The <see cref="VariableExpression" /> instance that should be visited.</param>
protected internal override BoundNode VisitVariableExpression(VariableExpression expression)
{
Expression replacement;
if (_replacedVariables.TryGetValue(expression.Variable, out replacement))
return replacement;
return expression;
}
protected override Expression VisitVariable(VariableExpression vex)
{
Expression sub;
if (this.map.TryGetValue(vex.Name, out sub)) {
return sub;
}
return vex;
}
public void EvaluateVariableExpression()
{
Variable variable = new Variable("X");
Context context = new Context();
context.SetValue("X", 1);
VariableExpression expression = new VariableExpression(variable);
Assert.AreEqual(1, expression.Evaluate(context));
}
public void RaiseIfEvaluateUndefinedVariableExpression()
{
Variable variable = new Variable("X");
Context context = new Context();
VariableExpression expression = new VariableExpression(variable);
try
{
expression.Evaluate(context, false);
Assert.Fail();
}
catch (Exception ex)
{
Assert.AreEqual("variable 'X' is unbound", ex.Message);
}
}
public void TestGetModificationsMultiIndexed()
{
// variable1[variable2][variable3] = 1
var variable = new VariableExpression("variable1");
var index1 = new VariableExpression("variable2");
var index2 = new VariableExpression("variable3");
var indexed1 = new IndexedVariableExpression(variable, index1);
var indexed2 = new IndexedVariableExpression(indexed1, index2);
var value = new IntegerConstantExpression(1);
var expr = new AssignmentExpression(indexed2, value);
var modifications = new HashSet <string>();
((INestedExpressions)expr).GetModifications(modifications);
Assert.That(modifications.Count, Is.EqualTo(1));
Assert.That(modifications.Contains("variable1")); // variable1 is updated
Assert.That(modifications.Contains("variable2"), Is.False); // index variable is not updated
Assert.That(modifications.Contains("variable3"), Is.False); // index variable is not updated
}
public void TestGetDependenciesNestedIndexed()
{
// variable1[variable2[variable3]] = 1
var variable1 = new VariableExpression("variable1");
var variable2 = new VariableExpression("variable2");
var variable3 = new VariableExpression("variable3");
var indexed1 = new IndexedVariableExpression(variable2, variable3);
var indexed2 = new IndexedVariableExpression(variable1, indexed1);
var value = new IntegerConstantExpression(1);
var expr = new AssignmentExpression(indexed2, value);
var dependencies = new HashSet <string>();
((INestedExpressions)expr).GetDependencies(dependencies);
Assert.That(dependencies.Count, Is.EqualTo(2));
Assert.That(dependencies.Contains("variable1"), Is.False); // variable1 is updated
Assert.That(dependencies.Contains("variable2")); // variable2 is needed to get the index
Assert.That(dependencies.Contains("variable3")); // variable3 is needed to get the index
}
public void CreateAndEvaluateCompositeExpressionWithTwoVariables()
{
IExpression expr1 = new VariableExpression(new Variable("X"));
IExpression expr2 = new VariableExpression(new Variable("Y"));
Context context = new Context();
context.SetValue("X", 1);
context.SetValue("Y", 2);
CompositeExpression expr = new CompositeExpression(new IExpression[] { expr1, expr2 });
Assert.IsTrue(expr.HasVariable());
Assert.IsNotNull(expr.Expressions);
Assert.AreEqual(2, expr.Expressions.Count);
Assert.AreSame(expr1, expr.Expressions[0]);
Assert.AreSame(expr2, expr.Expressions[1]);
var result = expr.Evaluate(context);
Assert.AreEqual(2, result);
}
public void TestReplaceVariablesArrayIndexString()
{
var variable = new VariableExpression("variable");
var index = new StringConstantExpression("str");
var value = new IntegerConstantExpression(99);
var array = new ArrayExpression();
array.Entries.Add(value);
var expr = new IndexedVariableExpression(variable, index);
var scope = new InterpreterScope();
scope.AssignVariable(variable, array);
ExpressionBase result;
Assert.That(expr.ReplaceVariables(scope, out result), Is.False);
Assert.That(result, Is.InstanceOf <ParseErrorExpression>());
Assert.That(((ParseErrorExpression)result).Message, Is.EqualTo("Index does not evaluate to an integer constant"));
}
public void Clone_VariableExpression()
{
//Arrange
var expression = new VariableExpression("x", 2);
expression.Count = new Complex(3, 2);
expression.DimensionKey.Set("y", 3);
//Act
var clone = (VariableExpression)expression.Clone();
//Assert
Assert.AreEqual(expression.Symbol, clone.Symbol);
Assert.IsFalse(Object.ReferenceEquals(expression.Symbol, clone.Symbol));
Assert.IsTrue(DimensionKey.Compare(expression.DimensionKey, clone.DimensionKey));
Assert.AreEqual(expression.Count.Re.Numerator, clone.Count.Re.Numerator);
Assert.AreEqual(expression.Count.Re.Denominator, clone.Count.Re.Denominator);
Assert.AreEqual(expression.Count.Im.Numerator, clone.Count.Im.Numerator);
Assert.AreEqual(expression.Count.Im.Denominator, clone.Count.Im.Denominator);
}
public static Func <T, T, T> CreateTwoParametricFunction <T>(Expression <T> expression, string firstVarName, string secondVarName)
{
VariableExpression <T> variable1 = expression.FindVariable(firstVarName);
if (variable1 == null)
{
throw new ArgumentException(String.Format(Properties.Resources.EXC_VARIABLE_NOT_FOUND, firstVarName));
}
VariableExpression <T> variable2 = expression.FindVariable(secondVarName);
if (variable2 == null)
{
throw new ArgumentException(String.Format(Properties.Resources.EXC_VARIABLE_NOT_FOUND, secondVarName));
}
TwoParametricFunctionCreator <T> creator = new TwoParametricFunctionCreator <T>(expression, variable1, variable2);
return(creator.Evaluate);
}
public ResolvedVariable ResolveVariable(VariableExpression variable, CType[]?argTypes)
{
var name = variable.VariableName;
var r = TryResolveVariable(name, argTypes);
if (r != null)
{
return(r);
}
r = MachineInfo.GetUnresolvedVariable(name, argTypes, this);
if (r != null)
{
return(r);
}
Report.ErrorCode(103, variable.Location, variable.EndLocation, name);
return(new ResolvedVariable(VariableScope.Global, 0, CBasicType.SignedInt));
}
Expression ParsePrimaryExpr(Scope c)
{
//Console.WriteLine(tok.Peek().Type + " " + tok.Peek().Data);
if (tok.ConsumeSymbol('('))
{
Expression ex = ParseExpr(c);
if (!tok.ConsumeSymbol(')'))
{
error("')' expected");
}
// save the information about parenthesized expressions somewhere
ex.ParenCount = ex.ParenCount + 1;
return(ex);
}
else if (tok.Is(TokenType.Ident))
{
Token id = tok.Get();
VariableExpression v = new VariableExpression();
Variable var = c.GetLocal(id.Data);
if (var == null)
{
v.IsGlobal = true;
v.Var = new Variable {
Name = id.Data
};
}
else
{
v.Var = var;
}
return(v);
}
else
{
error("primary expression expected");
}
return(null); // satisfy the C# compiler, but this will never happen
}
public void visit(CallCommand that)
{
Console.Write("{0}(", that.Identifier);
foreach (Expression argument in that.Arguments)
{
argument.visit(this);
if (argument != that.Arguments[that.Arguments.Length - 1])
{
Console.Write(", ");
}
}
Console.WriteLine(");");
#if false
switch (that.Identifier)
{
case "getint":
// To get the parameters ??
// getint( xx )
if (that.Arguments.Length != 1)
{
throw new CoderError(that.Position, "Incorrect number of parameters in function call");
}
VariableExpression argument = that.Arguments[0] as VariableExpression;
if (argument == null)
{
throw new CoderError("Variable expected");
}
Console.WriteLine("Arg = {0}", argument.Name);
break;
case "putint":
break;
}
foreach (Expression argument in that.Arguments)
{
argument.visit(this);
}
#endif
}
private void GraphScene(bool legacy)
{
var exp = Parse(y.Text, Settings.Y, Settings.YReg);
var width = CanvasWidth;
var height = CanvasHeight;
var offsetX = -XMin;
var offsetY = YMax;
var graphToCanvasX = width / (XMax - XMin);
var graphToCanvasY = height / (YMax - YMin);
var points = new PointCollection();
for (var x = XMin; x < XMax; x += 1 / graphToCanvasX)
{
VariableExpression.Define("x", x);
// Translate the origin based on the max/min parameters (y axis is flipped), then scale to canvas.
var xCanvas = (x + offsetX) * graphToCanvasX;
var yCanvas = (offsetY - exp.Evaluate()) * graphToCanvasY;
points.Add(ClampedPoint(xCanvas, yCanvas));
}
VariableExpression.Undefine("x");
screenCanvas.Children.Clear();
_axisHelper = new DrawAxisHelper(screenCanvas, CanvasSize);
_axisHelper.DrawAxes(XMin, XMax, YMin, YMax);
var graphLine = new Polyline
{
Stroke = Brushes.Black,
StrokeThickness = 1,
Points = points
};
screenCanvas.Children.Add(graphLine);
ShowScreenCanvas();
}
public void IfTest1()
{
VariableExpression vaexp = new VariableExpression();
vaexp.Name = "VAR1";
ConstExpression cst = new ConstExpression();
cst.SetValue(true);
ConstExpression cst2 = new ConstExpression();
cst2.SetValue(10);
ConstExpression cst3 = new ConstExpression();
cst3.SetValue(5);
IfBlock ifblk = new IfBlock();
SetVarBlock setvar1 = new SetVarBlock();
SetVarBlock setvar2 = new SetVarBlock();
setvar1.VarName = "VAR1";
setvar1.ValueExp = cst2;
setvar1.NextBlock = ifblk;
ifblk.Condition = cst;
ifblk.InnerBlock = setvar2;
setvar2.VarName = "VAR1";
setvar2.ValueExp = cst3;
setvar1.Execute();
Assert.AreEqual(vaexp.Value, 5);
cst.SetValue(false);
setvar1.Execute();
Assert.AreEqual(vaexp.Value, 10);
}
public override string Eval(List <Expression> expList, Dictionary <string, TYPEDEF> typedefTable, Dictionary <string, VARDECL> symbolTable)
{
if (expList.Count < 2)
{
throw new SemanticException("TREATAS Operator requires a SUM name, a field, and one expression (TREATAS <product name> <field> <exp> ).");
}
string sumname = expList[0].Eval(typedefTable, symbolTable);
if (!typedefTable.ContainsKey(sumname))
{
throw new SemanticException("A SUM of type " + sumname + " was never defined, please add a TYPEDEF " + sumname + " PRODUCT ... above.");
}
if (typedefTable[sumname].Type != "SUM")
{
throw new SemanticException("Expression " + expList[0] + " evaluates to type " + typedefTable[sumname].Type + " but expected type SUM.");
}
SUM sum = typedefTable[sumname] as SUM;
if (null == sum)
{
throw new SemanticException("First param to TREATAS is not actually a SUM.");
}
VariableExpression varexp = (expList[1] as VariableExpression); // fieldname
if (null == varexp)
{
throw new SemanticException("Second param to TREATAS is not actually a field value, but an expression of some sort.");
}
if (!sum.ArgPairs.ContainsKey(varexp.Variable))
{
throw new SemanticException("The SUM " + sum.Name + " does not have a field with name " + varexp.Variable + ".");
}
return(sum.ArgPairs[varexp.Variable]);
}
private Expression Assign(VariableExpression lhs, Expression value, ParserRuleContext context)
{
if (lhs == null || value == null)
{
return(null);
}
if (lhs.Type != value.Type)
{
this.AddSyntaxError($"Cannot assign a '{value.Type}' to the variable '{lhs.Name}'({lhs.Type.Name}). Consider casting the value.", context);
return(null);
}
if (!lhs.Type.Nullable && value.Type.Nullable)
{
this.AddSyntaxError($"Cannot assign a nullable value to the non-nullable variable '{lhs.Name}'.", context);
return(null);
}
if (lhs == value)
{
this.AddSyntaxError($"Cannot assign '{lhs.Name}' to itself.", context);
return(null);
}
if (!lhs.Mutable)
{
this.AddSyntaxError($"The variable '{lhs.Name}' is not mutable and can therefore not be the target of an assignment.", context);
return(null);
}
if (!lhs.Type.Nullable)
{
if (value == ConstantExpression.NullExpression)
{
this.AddSyntaxError($"Cannot assign null to the non-nullable variable '{lhs.Name}'.", context);
}
}
return(new BinaryAssignExpression(lhs, value, context));
}
public void CreateAndEvaluateCompositeExpressionWithTwoVariables()
{
IExpression expr1 = new VariableExpression(new Variable("X"));
IExpression expr2 = new VariableExpression(new Variable("Y"));
Context context = new Context();
context.SetValue("X", 1);
context.SetValue("Y", 2);
CompositeExpression expr = new CompositeExpression(new IExpression[] { expr1, expr2 });
Assert.IsTrue(expr.HasVariable());
Assert.IsNotNull(expr.Expressions);
Assert.AreEqual(2, expr.Expressions.Count);
Assert.AreSame(expr1, expr.Expressions[0]);
Assert.AreSame(expr2, expr.Expressions[1]);
var result = expr.Evaluate(context);
Assert.AreEqual(2, result);
}
public void TestReplaceVariables()
{
var variable1 = new VariableExpression("variable1");
var variable2 = new VariableExpression("variable2");
var value1 = new IntegerConstantExpression(98);
var value2 = new IntegerConstantExpression(99);
var expr = new ConditionalExpression(variable1, ConditionalOperation.And, variable2);
var scope = new InterpreterScope();
scope.AssignVariable(variable1, value1);
scope.AssignVariable(variable2, value2);
ExpressionBase result;
Assert.That(expr.ReplaceVariables(scope, out result), Is.True);
Assert.That(result, Is.InstanceOf <ConditionalExpression>());
Assert.That(((ConditionalExpression)result).Left, Is.EqualTo(value1));
Assert.That(((ConditionalExpression)result).Operation, Is.EqualTo(expr.Operation));
Assert.That(((ConditionalExpression)result).Right, Is.EqualTo(value2));
}
public void TestGetModifications()
{
var variable1 = new VariableExpression("variable1");
var variable2 = new VariableExpression("variable2");
var value1 = new IntegerConstantExpression(98);
var value2 = new IntegerConstantExpression(99);
var value3 = new IntegerConstantExpression(1);
var expr = new ArrayExpression();
expr.Entries.Add(variable1);
expr.Entries.Add(value1);
expr.Entries.Add(variable2);
expr.Entries.Add(value2);
expr.Entries.Add(value3);
var modifications = new HashSet <string>();
((INestedExpressions)expr).GetModifications(modifications);
Assert.That(modifications.Count, Is.EqualTo(0));
}
public void TestAssignVariableIndexedUpdate()
{
var variable = new VariableExpression("test");
var value = new IntegerConstantExpression(99);
var value2 = new IntegerConstantExpression(98);
var dict = new DictionaryExpression();
var key = new IntegerConstantExpression(6);
dict.Entries.Add(new DictionaryExpression.DictionaryEntry {
Key = key, Value = value
});
var scope = new InterpreterScope();
scope.AssignVariable(variable, dict);
var index = new IndexedVariableExpression(variable, key);
scope.AssignVariable(index, value2);
Assert.That(dict.Entries[0].Value, Is.SameAs(value2));
}
public void TestReplaceVariablesIndexMathematical()
{
var variable = new VariableExpression("variable");
var key = new IntegerConstantExpression(6);
var index = new MathematicExpression(new IntegerConstantExpression(2), MathematicOperation.Add, new IntegerConstantExpression(4));
var value = new IntegerConstantExpression(99);
var dict = new DictionaryExpression();
dict.Add(key, value);
var expr = new IndexedVariableExpression(variable, index);
var scope = new InterpreterScope();
scope.AssignVariable(variable, dict);
ExpressionBase result;
Assert.That(expr.ReplaceVariables(scope, out result), Is.True);
Assert.That(result, Is.InstanceOf <IntegerConstantExpression>());
Assert.That(((IntegerConstantExpression)result).Value, Is.EqualTo(99));
}
private static bool CanRenameVariable(ILuaIntellisenseDocument document, out VariableExpression expression, out List <LuatValue.IReference> definitions)
{
expression = null;
definitions = null;
if (!CanGoto(document))
{
return(false);
}
if (document.SyntaxEditorControl == null)
{
return(false);
}
var se = (ActiproSoftware.SyntaxEditor.SyntaxEditor)document.SyntaxEditorControl;
if ((se.SelectedView == null) || (se.SelectedView.Selection == null))
{
return(false);
}
expression = GetExpressionAt(se.Document, se.SelectedView.Selection.StartOffset) as VariableExpression;
if (expression == null)
{
return(false);
}
definitions = new List <LuatValue.IReference>();
foreach (LuatValue value in expression.ResolvedValues.Values)
{
var variable = value.As <LuatVariable>();
if (variable != null)
{
definitions.Merge(variable.References.ToArray());
}
}
return(definitions.Count > 0);
}
private void GraphScene(bool legacy)
{
IExpression exp = Parse(y.Text, Settings.y, Settings.yReg);
double width = CanvasWidth;
double height = CanvasHeight;
double offsetX = -XMin;
double offsetY = YMax;
double graphToCanvasX = width / (XMax - XMin);
double graphToCanvasY = height / (YMax - YMin);
PointCollection points = new PointCollection();
for (double x = XMin; x < XMax; x += 1 / graphToCanvasX)
{
VariableExpression.Define("x", x);
// Translate the origin based on the max/min parameters (y axis is flipped), then scale to canvas.
double xCanvas = (x + offsetX) * graphToCanvasX;
double yCanvas = (offsetY - exp.Evaluate()) * graphToCanvasY;
points.Add(ClampedPoint(xCanvas, yCanvas));
}
VariableExpression.Undefine("x");
screenCanvas.Children.Clear();
axisHelper = new DrawAxisHelper(screenCanvas, CanvasSize);
axisHelper.DrawAxes(XMin, XMax, YMin, YMax);
Polyline graphLine = new Polyline();
graphLine.Stroke = System.Windows.Media.Brushes.Black;
graphLine.StrokeThickness = 1;
graphLine.Points = points;
screenCanvas.Children.Add(graphLine);
ShowScreenCanvas();
}
public override bool Evaluate(InterpreterScope scope, out ExpressionBase result)
{
var arrayExpression = GetReferenceParameter(scope, "array", out result);
if (arrayExpression == null)
{
return(false);
}
var array = arrayExpression.Expression as ArrayExpression;
if (array == null)
{
result = new ParseErrorExpression("array did not evaluate to an array", arrayExpression);
return(false);
}
var value = GetParameter(scope, "value", out result);
if (value == null)
{
return(false);
}
var variableExpression = new VariableExpression("array_push(" + arrayExpression.Variable.Name + ")");
var assignScope = new InterpreterScope(scope)
{
Context = new AssignmentExpression(variableExpression, value)
};
if (!value.ReplaceVariables(assignScope, out result))
{
return(false);
}
array.Entries.Add(result);
result = null;
return(true);
}
public void TestReplaceVariablesArray()
{
var variable = new VariableExpression("variable");
var index = new IntegerConstantExpression(0);
var indexVariable = new VariableExpression("index");
var value = new IntegerConstantExpression(99);
var array = new ArrayExpression();
array.Entries.Add(value);
var expr = new IndexedVariableExpression(variable, indexVariable);
var scope = new InterpreterScope();
scope.AssignVariable(variable, array);
scope.AssignVariable(indexVariable, index);
ExpressionBase result;
Assert.That(expr.ReplaceVariables(scope, out result), Is.True);
Assert.That(result, Is.InstanceOf <IntegerConstantExpression>());
Assert.That(((IntegerConstantExpression)result).Value, Is.EqualTo(99));
}
internal static dynamic ConditionalAssign(VariableExpression @var, dynamic value, KumaExpressionType conditionalAssignmentType, bool isConst,
object rawScope)
{
var scope = rawScope as KumaScope;
var v = Resolve(CompilerServices.CompileExpression(@var.Name, scope), scope);
if (Boolean(v))
{
if (conditionalAssignmentType == KumaExpressionType.IfNotNullAssign)
{
return(Assign(@var, value, E.Assign, isConst, scope));
}
}
else
{
if (conditionalAssignmentType == KumaExpressionType.IfNullAssign)
{
return(Assign(@var, value, E.Assign, isConst, scope));
}
}
return(v);
}
private void CheckVariableExpression(VariableExpression e, TypeCheckingContext context)
{
LambdaVariable variable = context.LambdaContext.GetVariable(e.VariableName);
if (variable != null)
{
e.Type = context.LambdaContext.GetVariable(variable.Name).Type;
}
else if (context.VariableContext.HasVariable(e.VariableName))
{
e.Type = context.VariableContext.GetType(e.VariableName);
}
else if (context.CreateVariableOnAssign && context.RightOperandType != null)
{
context.VariableContext.Set(e.VariableName, context.CreateAutoCreatedVariableValue(context.RightOperandType));
e.Type = context.VariableContext.GetType(e.VariableName);
}
else
{
context.ErrorProvider.ThrowException(string.Format("{0} not defined.", e.VariableName), e);
}
}
void ITreeWalker.Visit(VariableExpression expression)
{
var name = expression.Name;
expression.Validate(this);
if (_assigning)
{
if (_declaring)
{
InsertDefVariable(name);
}
else
{
InsertSetVariable(name);
}
}
else
{
InsertGetVariable(name);
}
}
public void TestReplaceVariables()
{
var variable = new VariableExpression("variable");
var key = new StringConstantExpression("key");
var value = new IntegerConstantExpression(99);
var dict = new DictionaryExpression();
dict.Entries.Add(new DictionaryExpression.DictionaryEntry {
Key = key, Value = value
});
var expr = new IndexedVariableExpression(variable, key);
var scope = new InterpreterScope();
scope.AssignVariable(variable, dict);
ExpressionBase result;
Assert.That(expr.ReplaceVariables(scope, out result), Is.True);
Assert.That(result, Is.InstanceOf <IntegerConstantExpression>());
Assert.That(((IntegerConstantExpression)result).Value, Is.EqualTo(99));
}
void ITreeWalker.Visit(VariableExpression expression)
{
var name = expression.Name;
expression.Validate(this);
if (_assigning)
{
if (_declaring)
{
_operations.Add(new DefOperation(name));
}
else
{
_operations.Add(new SetsOperation(name));
}
}
else
{
_operations.Add(new GetsOperation(name));
}
}
private void Show2D(Canvas c, String input)
{
IExpression exp = FunctionParser.Parse(input);
double width = CanvasWidth;
double height = CanvasHeight;
double offsetX = -XMin;
double offsetY = YMax;
double graphToCanvasX = width / (XMax - XMin);
double graphToCanvasY = height / (YMax - YMin);
PointCollection points = new PointCollection();
for (double x = XMin; x < XMax; x += 1 / graphToCanvasX)
{
VariableExpression.Define("x", x);
// Translate the origin based on the max/min parameters (y axis is flipped), then scale to canvas.
double xCanvas = (x + offsetX) * graphToCanvasX;
double yCanvas = (offsetY - exp.Evaluate()) * graphToCanvasY;
points.Add(ClampedPoint(xCanvas, yCanvas));
}
VariableExpression.Undefine("x");
c.Children.Clear();
DrawAxisHelper axisHelper = new DrawAxisHelper(c, new Size(c.Width, c.Height));
axisHelper.DrawAxes(XMin, XMax, YMin, YMax);
Polyline graphLine = new Polyline();
graphLine.Stroke = Brushes.Black;
graphLine.StrokeThickness = 1;
graphLine.Points = points;
c.Children.Add(graphLine);
}
protected override DeclarationCommand GetGeneratedIdCommand(MappingEntity entity, List <MemberInfo> members, Dictionary <MemberInfo, Expression> map)
{
var columns = new List <ColumnDeclaration>();
var decls = new List <VariableDeclaration>();
var alias = new TableAlias();
var orderBy = new List <OrderExpression> {
new OrderExpression(OrderType.Ascending, Expression.Constant(1))
};
foreach (var member in members)
{
var genId = Translator.Linguist.Language.GetGeneratedIdExpression(member);
var colType = GetColumnType(entity, member);
columns.Add(new ColumnDeclaration(member.Name, genId, colType));
decls.Add(new VariableDeclaration(member.Name, colType, new ColumnExpression(genId.Type, colType, alias, member.Name)));
if (map != null)
{
var vex = new VariableExpression(member.Name, TypeHelper.GetMemberType(member), colType);
map.Add(member, vex);
}
}
var attributeMapping = entity as VfpAttributeMapping.AttributeMappingEntity;
var tableId = entity.TableId;
if (attributeMapping != null)
{
tableId = attributeMapping.TableName;
}
var from = new TableExpression(alias, entity, tableId);
Expression take = Expression.Constant(1);
var select = new SelectExpression(alias, columns, from, null, new ReadOnlyCollection <OrderExpression>(orderBy), null, false, null, take, false);
return(new DeclarationCommand(decls, select));
}
// Identifier := [$a-zA-Z] [a-zA-Z0-9]* S
private State DoParseIdentifierRule(State _state, List <Result> _outResults)
{
State _start = _state;
List <Result> results = new List <Result>();
_state = DoSequence(_state, results,
delegate(State s, List <Result> r) { return(DoParseRange(s, r, false, "$", "azAZ", null, "[$a-zA-Z]")); },
delegate(State s, List <Result> r) { return(DoRepetition(s, r, 0, 2147483647,
delegate(State s2, List <Result> r2) { return DoParseRange(s2, r2, false, string.Empty, "azAZ09", null, "[a-zA-Z0-9]"); })); },
delegate(State s, List <Result> r) { return(DoParse(s, r, "S")); });
if (_state.Parsed)
{
Expression value = results.Count > 0 ? results[0].Value : default(Expression);
string text = m_input.Substring(_start.Index, _state.Index - _start.Index);
value = new VariableExpression(text.Trim());
if (text != null)
{
_outResults.Add(new Result(this, _start.Index, _state.Index - _start.Index, m_input, value));
}
}
else
{
string expected = null;
expected = "variable";
if (expected != null)
{
_state = new State(_start.Index, false, ErrorSet.Combine(_start.Errors, new ErrorSet(_state.Errors.Index, expected)));
}
}
return(_state);
}
internal DeclarationCommand GetGeneratedIdCommand(IEntityMapping mapping, List <IMemberMapping> members, Dictionary <MemberInfo, Expression> map)
{
var columns = new List <ColumnDeclaration>();
var decls = new List <VariableDeclaration>();
var alias = new TableAlias();
foreach (var member in members)
{
Expression genId = this.GetGeneratedIdExpression(member);
var name = member.Member.Name;
var colType = member.SqlType;
columns.Add(new ColumnDeclaration(name, genId, colType));
decls.Add(new VariableDeclaration(name, colType, new ColumnExpression(genId.Type, colType, alias, name)));
if (map != null)
{
var vex = new VariableExpression(name, member.MemberType, colType);
map.Add(member.Member, vex);
}
}
var select = new SelectExpression(alias, columns, null, null);
return(new DeclarationCommand(decls, select));
}
protected virtual Expression VisitVariable(VariableExpression vex)
{
return vex;
}
protected virtual Expression VisitVariable(VariableExpression vex)
{
this.Write(this.FormatQuery(vex));
return vex;
}
protected virtual DeclarationCommand GetGeneratedIdCommand(MappingEntity entity, List<MemberInfo> members, Dictionary<MemberInfo, Expression> map)
{
var columns = new List<ColumnDeclaration>();
var decls = new List<VariableDeclaration>();
var alias = new TableAlias();
foreach (var member in members)
{
Expression genId = this.translator.Linguist.Language.GetGeneratedIdExpression(member);
var name = member.Name;
var colType = this.GetColumnType(entity, member);
columns.Add(new ColumnDeclaration(member.Name, genId, colType));
decls.Add(new VariableDeclaration(member.Name, colType, new ColumnExpression(genId.Type, colType, alias, member.Name)));
if (map != null)
{
var vex = new VariableExpression(member.Name, TypeHelper.GetMemberType(member), colType);
map.Add(member, vex);
}
}
var select = new SelectExpression(alias, columns, null, null);
return new DeclarationCommand(decls, select);
}
protected override void When()
{
_expression = Variable.Expression(_variable);
}
protected override void Given()
{
_variable = new Variable("TestNamespace", "Test", typeof(int));
_expression = Variable.Expression(_variable);
}
CatchClause(VariableExpression variable, BlockStatement body) {
this.Variable = variable;
this.Body = body;
}
/// <summary>
/// Visits an element of type <see cref="VariableExpression" />.
/// </summary>
/// <param name="expression">The <see cref="VariableExpression" /> instance that should be visited.</param>
protected internal override void VisitVariableExpression(VariableExpression expression)
{
if (expression.Variable != _variable)
return;
if (_writeContext > 0)
_operations |= VariableOperations.Write;
else
_operations |= VariableOperations.Read;
}
void PrintExpression(VariableExpression e, int d)
{
SayLn("VariableExpression(");
PrintVariable(e.Var, d + 1);
Say(")");
}
protected internal override void VisitVariableExpression(VariableExpression expression)
{
_writer.Append("{0}", expression.Variable.Name);
}
protected internal override void VisitVariableExpression(VariableExpression expression)
{
if (expression.Variable.IsParameter)
_expr = Ssm.Expr.NewVarExpr(Ssm.Var.NewLocal(expression.Variable.Name, Transform(expression.Variable.Type)));
else
_expr = Ssm.Expr.NewVarExpr(Ssm.Var.NewArg(expression.Variable.Name, Transform(expression.Variable.Type)));
}
private Expression GetGetVariableValueCall(VariableExpression variableNode)
{
return Expression.Call(_runtimeParameter, _getVariableValueMethod, Expression.Constant(variableNode.Variable));
}
public void MathExpression_Can_Evaluate_Variable_Expression()
{
var expression = new VariableExpression("x");
var visitor = new EvaluationVisitor();
var context = new MathExpressionContext();
context.Define("x", 42D);
Assert.AreEqual(42, visitor.Evaluate(expression, context));
}
internal DeclarationCommand GetGeneratedIdCommand(IEntityMapping mapping, List<IMemberMapping> members, Dictionary<MemberInfo, Expression> map)
{
var columns = new List<ColumnDeclaration>();
var decls = new List<VariableDeclaration>();
var alias = new TableAlias();
foreach (var member in members)
{
Expression genId = this.GetGeneratedIdExpression(member);
var name = member.Member.Name;
var colType = member.SqlType;
columns.Add(new ColumnDeclaration(name, genId, colType));
decls.Add(new VariableDeclaration(name, colType, new ColumnExpression(genId.Type, colType, alias, name)));
if (map != null)
{
var vex = new VariableExpression(name, member.MemberType, colType);
map.Add(member.Member, vex);
}
}
var select = new SelectExpression(alias, columns, null, null);
return new DeclarationCommand(decls, select);
}
Expression ParseAtom()
{
string id;
Expression x = null;
FunctionDefinition fnDef = null;
switch (_token.Type)
{
// literals
case TKTYPE.LITERAL:
x = new Expression(_token);
break;
// identifiers
case TKTYPE.IDENTIFIER:
// get identifier
id = (string)_token.Value;
// look for functions
if (_fnTbl.TryGetValue(id, out fnDef))
{
var p = GetParameters();
var pCnt = p == null ? 0 : p.Count;
if (fnDef.ParmMin != -1 && pCnt < fnDef.ParmMin)
{
Throw("Too few parameters.");
}
if (fnDef.ParmMax != -1 && pCnt > fnDef.ParmMax)
{
Throw("Too many parameters.");
}
x = new FunctionExpression(fnDef, p);
break;
}
// look for simple variables (much faster than binding!)
if (_vars.ContainsKey(id))
{
x = new VariableExpression(_vars, id);
break;
}
// look for external objects
var xObj = GetExternalObject(id);
if (xObj != null)
{
x = new XObjectExpression(xObj);
break;
}
// look for bindings
if (DataContext != null)
{
var list = new List<BindingInfo>();
for (var t = _token; t != null; t = GetMember())
{
list.Add(new BindingInfo((string)t.Value, GetParameters()));
}
x = new BindingExpression(this, list, _ci);
break;
}
Throw("Unexpected identifier");
break;
// sub-expressions
case TKTYPE.GROUP:
// anything other than opening parenthesis is illegal here
if (_token.ID != TKID.OPEN)
{
Throw("Expression expected.");
}
// get expression
GetToken();
x = ParseCompare();
// check that the parenthesis was closed
if (_token.ID != TKID.CLOSE)
{
Throw("Unbalanced parenthesis.");
}
break;
}
// make sure we got something...
if (x == null)
{
Throw();
}
// done
GetToken();
return x;
}
protected override Expression VisitVariable(VariableExpression node)
{
_variables.Add(node.Variable);
return node;
}
/// <summary>
/// Gets the resulting expression.
/// </summary>
/// <param name="variableExpression">The variable expression.</param>
/// <returns>An <see cref="Expression"/>.</returns>
public Expression GetResultingExpression(VariableExpression variableExpression)
{
return this.GetResultingExpression(variableExpression.VariableName);
}
private IExpression ParseTerm()
{
Token token = this.NextToken();
IExpression expression = null;
if (token == null)
return null;
if (token.Type == TokenType.Variable)
{
expression = new VariableExpression(new Variable(token.Value));
if (this.TryParseToken(TokenType.Separator, "("))
{
var list = this.ParseExpressionList();
this.ParseToken(TokenType.Separator, ")");
expression = new CallExpression(expression, list);
}
}
else if (token.Type == TokenType.Atom)
{
if (token.Value == "false")
return new ConstantExpression(false);
if (token.Value == "true")
return new ConstantExpression(true);
if (token.Value == "fun")
return this.ParseFunExpression();
if (token.Value == "receive")
return this.ParseReceiveExpression();
expression = new AtomExpression(new Atom(token.Value));
if (this.TryParseToken(TokenType.Separator, "("))
{
var list = this.ParseExpressionList();
this.ParseToken(TokenType.Separator, ")");
expression = new CallExpression(expression, list);
}
else if (this.TryParseToken(TokenType.Separator, ":"))
{
var nexpression = new AtomExpression(new Atom(this.ParseAtom()));
this.ParseToken(TokenType.Separator, "(");
var list = this.ParseExpressionList();
this.ParseToken(TokenType.Separator, ")");
expression = new QualifiedCallExpression(expression, nexpression, list);
}
}
else if (token.Type == TokenType.Integer)
expression = new ConstantExpression(int.Parse(token.Value, CultureInfo.InvariantCulture));
else if (token.Type == TokenType.Real)
expression = new ConstantExpression(double.Parse(token.Value, CultureInfo.InvariantCulture));
else if (token.Type == TokenType.String)
expression = new ConstantExpression(token.Value);
else if (token.Type == TokenType.Separator && token.Value == "(")
{
expression = this.ParseSimpleExpression();
this.ParseToken(TokenType.Separator, ")");
}
else if (token.Type == TokenType.Separator && token.Value == "{")
{
var expressions = this.ParseExpressionList();
this.ParseToken(TokenType.Separator, "}");
expression = new TupleExpression(expressions);
}
else if (token.Type == TokenType.Separator && token.Value == "[")
{
var expressions = this.ParseExpressionList();
IExpression tailexpression = null;
if (this.TryParseToken(TokenType.Separator, "|"))
tailexpression = this.ParseSimpleExpression();
this.ParseToken(TokenType.Separator, "]");
expression = new ListExpression(expressions, tailexpression);
}
else
this.PushToken(token);
return expression;
}
protected override Expression VisitVariable(VariableExpression node)
{
return Expression.Convert(GetGetVariableValueCall(node), node.Variable.Type);
}
ForeachStatement(VariableExpression variable, Expression expression, Statement body)
: super(StatementKind.Foreach) {
/// <summary>
/// Visits an element of type <see cref="VariableExpression" />.
/// </summary>
/// <param name="expression">The <see cref="VariableExpression" /> instance that should be visited.</param>
protected internal virtual void VisitVariableExpression(VariableExpression expression)
{
DefaultVisit(expression);
}
/// <summary>
/// Adds the specified variable expression.
/// </summary>
/// <param name="variableExpression">The variable expression.</param>
/// <param name="exponent">The exponent.</param>
public void Add(VariableExpression variableExpression, double exponent)
{
if (this.variableFlatIdentifierRepresentations == null)
{
this.variableFlatIdentifierRepresentations =
new Dictionary<string, VariableFlatIdentifierRepresentation>();
}
var variableName = variableExpression.VariableName;
VariableFlatIdentifierRepresentation flatExpressionRepresentation;
if (this.variableFlatIdentifierRepresentations.TryGetValue(variableName, out flatExpressionRepresentation))
{
exponent += flatExpressionRepresentation.Exponent;
}
else
{
this.additionalCount++;
}
this.variableFlatIdentifierRepresentations[variableName] =
new VariableFlatIdentifierRepresentation(variableExpression, exponent);
}
protected override Expression VisitVariable(VariableExpression vex)
{
this.WriteVariableName(vex.Name);
return vex;
}
protected virtual Expression VisitVariable(VariableExpression node)
{
return node;
}
