public IntegerLiteralExpression CreateIntegerLiteral(long value) { IntegerLiteralExpression integer = new IntegerLiteralExpression(value); integer.ExpressionType = _tss.LongType; return(integer); }
public void FunctionCallFunction_UsingLocalReference_PassesCorrectFunctionNodeToFunctionFunction() { IntegerLiteralExpression functionLit = new IntegerLiteralExpression("1.0", 1, 1); List <ExpressionNode> funcParams = new List <ExpressionNode> { functionLit }; FunctionCallExpression funcCallExpr = new FunctionCallExpression("test", funcParams, 1, 1); funcCallExpr.LocalReference = 0; funcCallExpr.GlobalReferences = new List <int>(); IInterpreterGeneric parent = Substitute.For <IInterpreterGeneric>(); parent.Dispatch(funcParams[0], Arg.Any <List <object> >(), TypeEnum.Function).Returns((Object)1); GenericHelper functionHelper = SetUpHelper(parent); List <TypeNode> typeNodes = new List <TypeNode> { new TypeNode(TypeEnum.Function, 1, 1) }; FunctionTypeNode funcTypeNode = new FunctionTypeNode(null, typeNodes, 1, 1); FunctionNode funcNode = new FunctionNode("", null, null, funcTypeNode, 1, 1); AST ast = new AST(new List <FunctionNode> { funcNode }, null, 1, 1); functionHelper.SetASTRoot(ast); FunctionNode res = null; parent.Function <Function>(Arg.Do <FunctionNode>(x => res = x), Arg.Any <List <object> >()); functionHelper.FunctionCall <Function>(funcCallExpr, new List <object> { new Function(0) }); res.Should().BeEquivalentTo(funcNode); }
public TypeNode Dispatch(ExpressionNode node, List <TypeNode> parameterTypes) { return(node switch { IBinaryNumberOperator n => _numberHelper.VisitBinaryNumOp(n, parameterTypes), IBinaryBooleanOperator n => _booleanHelper.VisitBinaryBoolOp(n, parameterTypes), IBinarySetOperator n => _setHelper.VisitBinarySetOp(n, parameterTypes), SubsetExpression n => _setHelper.VisitSubset(n, parameterTypes), SetExpression n => _setHelper.VisitSet(n, parameterTypes), NotExpression n => _booleanHelper.VisitNot(n, parameterTypes), FunctionCallExpression n => _declarationHelper.VisitFunctionCall(n, parameterTypes), IdentifierExpression n => _declarationHelper.VisitIdentifier(n, parameterTypes), IntegerLiteralExpression _ => _declarationHelper.VisitIntegerLiteral(), RealLiteralExpression _ => _declarationHelper.VisitRealLiteral(), BooleanLiteralExpression _ => _declarationHelper.VisitBooleanLiteral(), StringLiteralExpression _ => _declarationHelper.VisitStringLiteral(), EmptySetLiteralExpression _ => _declarationHelper.VisitEmptySetLiteral(), AdditionExpression n => _commonOperatorHelper.VisitAddition(n, parameterTypes), SubtractionExpression n => _commonOperatorHelper.VisitSubtraction(n, parameterTypes), AbsoluteValueExpression n => _commonOperatorHelper.VisitAbsoluteValue(n, parameterTypes), IRelationOperator n => _commonOperatorHelper.VisitRelationalOperator(n, parameterTypes), IEquivalenceOperator n => _commonOperatorHelper.VisitEquivalenceOperator(n, parameterTypes), NegativeExpression n => _numberHelper.VisitNegative(n, parameterTypes), ElementExpression n => _commonOperatorHelper.VisitElement(n, parameterTypes), ISetGraphField n => _commonOperatorHelper.VisitISetGraphField(n, parameterTypes), IFunctionGraphField n => _commonOperatorHelper.VisitIFunctionGraphField(n, parameterTypes), GraphExpression n => _commonOperatorHelper.VisitGraph(n, parameterTypes), AnonymousFunctionExpression n => _declarationHelper.VisitAnonymousFunction(n, parameterTypes), _ => throw new UnimplementedTypeCheckerException(node, "Dispatch"), });
public void TestGlobalStmts1() { Boo.Lang.Ast.Module module = BooTestCaseUtil.ParseTestCase("global_stmts_1.boo"); Block g = module.Globals; Assert.AreEqual(1, g.Statements.Count); ExpressionStatement es = (ExpressionStatement)g.Statements[0]; MethodInvocationExpression mce = (MethodInvocationExpression)es.Expression; Assert.AreEqual(1, mce.Arguments.Count); BinaryExpression be = (BinaryExpression)mce.Arguments[0]; Assert.AreEqual(BinaryOperatorType.Add, be.Operator); mce = (MethodInvocationExpression)be.Left; IntegerLiteralExpression ile = (IntegerLiteralExpression)mce.Arguments[0]; Assert.AreEqual("3", ile.Value); mce = (MethodInvocationExpression)be.Right; ile = (IntegerLiteralExpression)mce.Arguments[0]; Assert.AreEqual("5", ile.Value); }
public static IExpression ParseExpression(ConsideredTokens consideredTokens, Action tweakTokens, out ParseError error) { error = null; switch (consideredTokens.Current.Type) { case TokenType.INT: { if (consideredTokens.Next.Type == TokenType.SEMICOLON) { var expression = new IntegerLiteralExpression(consideredTokens.Current); tweakTokens(); tweakTokens(); return(expression); } if (consideredTokens.Next.Type == TokenType.PLUS) { return(ParseOperatorExpression(consideredTokens, tweakTokens, out error)); } } break; default: throw new NotImplementedException(); } throw new NotImplementedException(); }
internal static IInterpreterElement GetIntepreterElementWithParamsOut(IntegerLiteralExpression child, int id, Action <List <object> > action) { var res = Substitute.For <IInterpreterElement>(); res.DispatchInt(child, Arg.Do <List <object> >(x => action(x))).Returns(id); return(res); }
override public void OnIntegerLiteralExpression(IntegerLiteralExpression e) { Write(e.Value.ToString()); if (e.IsLong) { Write("L"); } }
public override void Switch(IAstTransformer transformer, out Node resultingNode) { IntegerLiteralExpression thisNode = (IntegerLiteralExpression)this; Expression resultingTypedNode = thisNode; transformer.OnIntegerLiteralExpression(thisNode, ref resultingTypedNode); resultingNode = resultingTypedNode; }
public static FunctionNode GetFunctionNode(string id) { IntegerLiteralExpression intLitExpr = new IntegerLiteralExpression(0, 0, 0); ConditionNode conditionNode = GetConditionNode(intLitExpr); FunctionTypeNode functionTypeNode = GetFunctionTypeNode(); List <string> paramIDs = new List <string>(); return(new FunctionNode(id, conditionNode, paramIDs, functionTypeNode, 0, 0)); }
public override Expression Parse(Parser parser, Token token) { var integerLiteralExpression = new IntegerLiteralExpression { Value = int.Parse(token.Value) }; parser.Consume(); return(integerLiteralExpression); }
public void Export_2Doubles2Ints_2ndLastNode_Value() { string input = "export 5.5 + 33.3 + 2 + 1 {\"\"}"; AST ast = new LexParser(new ASTBuilder(new ExpressionHelper())).Run(input, false); IntegerLiteralExpression node = (IntegerLiteralExpression)ast.Exports[0].ExportValue.Children[0].Children[1]; Assert.AreEqual(2, node.Value); }
public override void OnIntegerLiteralExpression(IntegerLiteralExpression node) { if (node.IsLong || node.Value < int.MinValue || node.Value > int.MaxValue) { _expression = new CodePrimitiveExpression(node.Value); } else { _expression = new CodePrimitiveExpression((int)node.Value); } }
public override void OnIntegerLiteralExpression(IntegerLiteralExpression node) { if (node.IsLong) { MakeLiteralResult("System.Int64"); } else { MakeResult(projectContent.SystemTypes.Int32); } }
public void LiteralInteger_GivenInteger_ReturnsIntegerLiteral(int input, int expected) { IntegerLiteralExpression intLit = new IntegerLiteralExpression(input.ToString(), 1, 1); IInterpreterInteger parent = Substitute.For <IInterpreterInteger>(); parent.DispatchInt(intLit, Arg.Any <List <object> >()).Returns(input); IntegerHelper integerHelper = SetUpHelper(parent); int res = integerHelper.LiteralInteger(intLit, new List <object>()); Assert.AreEqual(expected, res); }
private List <BoundNode> GetBounds() { ExpressionNode smallest = new IntegerLiteralExpression("0", 0, 0); ExpressionNode largest = new IntegerLiteralExpression("5", 0, 0); BoundNode node1 = new BoundNode("i", smallest, largest, 0, 0); List <BoundNode> bounds = new List <BoundNode>() { node1 }; return(bounds); }
void ExpandComplexArraySlicing(SlicingExpression node) { if (node.Indices.Count > 1) { MethodInvocationExpression mie = null; var computeEnd = new ArrayLiteralExpression(); var collapse = new ArrayLiteralExpression(); var ranges = new ArrayLiteralExpression(); for (int i = 0; i < node.Indices.Count; i++) { ranges.Items.Add(node.Indices[i].Begin); if (node.Indices[i].End == null) { var end = new BinaryExpression(BinaryOperatorType.Addition, node.Indices[i].Begin, new IntegerLiteralExpression(1)); ranges.Items.Add(end); BindExpressionType(end, GetExpressionType(node.Indices[i].Begin)); computeEnd.Items.Add(new BoolLiteralExpression(false)); collapse.Items.Add(new BoolLiteralExpression(true)); } else if (node.Indices[i].End == OmittedExpression.Default) { var end = new IntegerLiteralExpression(0); ranges.Items.Add(end); BindExpressionType(end, GetExpressionType(node.Indices[i].Begin)); computeEnd.Items.Add(new BoolLiteralExpression(true)); collapse.Items.Add(new BoolLiteralExpression(false)); } else { ranges.Items.Add(node.Indices[i].End); computeEnd.Items.Add(new BoolLiteralExpression(false)); collapse.Items.Add(new BoolLiteralExpression(false)); } } mie = CodeBuilder.CreateMethodInvocation(MethodCache.RuntimeServices_GetMultiDimensionalRange1, node.Target, ranges); mie.Arguments.Add(computeEnd); mie.Arguments.Add(collapse); BindExpressionType(ranges, TypeSystemServices.Map(typeof(int[]))); BindExpressionType(computeEnd, TypeSystemServices.Map(typeof(bool[]))); BindExpressionType(collapse, TypeSystemServices.Map(typeof(bool[]))); node.ParentNode.Replace(node, mie); } else { var slice = node.Indices[0]; var mie = IsNullOrOmitted(slice.End) ? CodeBuilder.CreateMethodInvocation(MethodCache.RuntimeServices_GetRange1, node.Target, slice.Begin) : CodeBuilder.CreateMethodInvocation(MethodCache.RuntimeServices_GetRange2, node.Target, slice.Begin, slice.End); node.ParentNode.Replace(node, mie); } }
public void PowerInteger_TwoIntsButNegativeExponent_ThrowsException(int input1, int input2) { IntegerLiteralExpression realLit1 = new IntegerLiteralExpression(input1, 1, 1); IntegerLiteralExpression realLit2 = new IntegerLiteralExpression(input2, 2, 2); PowerExpression powExpr = new PowerExpression(realLit1, realLit2, 1, 1); IInterpreterInteger parent = Substitute.For <IInterpreterInteger>(); parent.DispatchInt(realLit1, Arg.Any <List <object> >()).Returns(input1); parent.DispatchInt(realLit2, Arg.Any <List <object> >()).Returns(input2); IntegerHelper realHelper = SetUpHelper(parent); int res = realHelper.PowerInteger(powExpr, new List <object>()); }
public void UnaryMinus() { string arg_58_0 = "-42"; UnaryExpression unaryExpression = new UnaryExpression(LexicalInfo.Empty); UnaryOperatorType unaryOperatorType = unaryExpression.Operator = UnaryOperatorType.UnaryNegation; UnaryExpression arg_4F_0 = unaryExpression; IntegerLiteralExpression integerLiteralExpression = new IntegerLiteralExpression(LexicalInfo.Empty); long num = integerLiteralExpression.Value = 42L; bool flag = integerLiteralExpression.IsLong = false; Expression expression = arg_4F_0.Operand = integerLiteralExpression; CSharpAssertModule.AssertCSharpCode(arg_58_0, unaryExpression); }
override public void LeaveUnaryExpression(UnaryExpression node) { if (UnaryOperatorType.UnaryNegation == node.Operator) { if (NodeType.IntegerLiteralExpression == node.Operand.NodeType) { IntegerLiteralExpression integer = (IntegerLiteralExpression)node.Operand; integer.Value *= -1; integer.LexicalInfo = node.LexicalInfo; ReplaceCurrentNode(integer); } } }
public override void OnExpressionStatement(ExpressionStatement node) { base.OnExpressionStatement(node); IntegerLiteralExpression literal = node.Expression as IntegerLiteralExpression; if (null == literal) { return; } AssertLiteralInRange(literal, GetExpressionType(literal)); }
public void AbsoluteInteger_Integer_ReturnsAbsoluteValue(int input, int expected) { IntegerLiteralExpression intLit = new IntegerLiteralExpression(input.ToString(), 1, 1); AbsoluteValueExpression absExpr = new AbsoluteValueExpression(intLit, 1, 1); absExpr.Type = TypeEnum.Integer; IInterpreterInteger parent = Substitute.For <IInterpreterInteger>(); parent.DispatchInt(intLit, Arg.Any <List <object> >()).Returns(input); IntegerHelper integerHelper = SetUpHelper(parent); int res = integerHelper.AbsoluteInteger(absExpr, new List <object>()); Assert.AreEqual(expected, res); }
public void MultiplicationInteger_TwoIntegers_ReturnsCorrectResultOfMultiplication(int input1, int input2, int expected) { IntegerLiteralExpression intLit1 = new IntegerLiteralExpression(input1.ToString(), 1, 1); IntegerLiteralExpression intLit2 = new IntegerLiteralExpression(input2.ToString(), 2, 2); MultiplicationExpression multExpr = new MultiplicationExpression(intLit1, intLit2, 1, 1); IInterpreterInteger parent = Substitute.For <IInterpreterInteger>(); parent.DispatchInt(intLit1, Arg.Any <List <object> >()).Returns(input1); parent.DispatchInt(intLit2, Arg.Any <List <object> >()).Returns(input2); IntegerHelper integerHelper = SetUpHelper(parent); int res = integerHelper.MultiplicationInteger(multExpr, new List <object>()); Assert.AreEqual(expected, res); }
public void PowerInteger_TwoInts_ReturnsCorrectResult(int input1, int input2, int expected) { IntegerLiteralExpression realLit1 = new IntegerLiteralExpression(input1, 1, 1); IntegerLiteralExpression realLit2 = new IntegerLiteralExpression(input2, 2, 2); PowerExpression powExpr = new PowerExpression(realLit1, realLit2, 1, 1); IInterpreterInteger parent = Substitute.For <IInterpreterInteger>(); parent.DispatchInt(realLit1, Arg.Any <List <object> >()).Returns(input1); parent.DispatchInt(realLit2, Arg.Any <List <object> >()).Returns(input2); IntegerHelper realHelper = SetUpHelper(parent); int res = realHelper.PowerInteger(powExpr, new List <object>()); Assert.AreEqual(expected, res); }
private List <BoundNode> GetBounds(IInterpreterSet parent, List <int> minValues, List <int> maxValues) { List <BoundNode> bounds = new List <BoundNode>(); for (int i = 0; i < minValues.Count; i++) { IntegerLiteralExpression min = new IntegerLiteralExpression(minValues[i], 0, 0); IntegerLiteralExpression max = new IntegerLiteralExpression(maxValues[i], 0, 0); bounds.Add(new BoundNode(null, min, max, 0, 0)); parent.DispatchInt(min, Arg.Any <List <object> >()).Returns(minValues[i]); parent.DispatchInt(max, Arg.Any <List <object> >()).Returns(maxValues[i]); } return(bounds); }
public void Dispatch_IntegerLiteralAndObjectListAndIntegerType_CorrectListPassed() { List <Object> expected = new List <Object>() { 23, 2.334, null }; IntegerLiteralExpression input1 = new IntegerLiteralExpression("", 0, 0); IIntegerHelper ihelper = Substitute.For <IIntegerHelper>(); Interpreter interpreter = Utilities.GetIntepreterOnlyWith(ihelper); List <Object> res = null; ihelper.LiteralInteger(Arg.Any <IntegerLiteralExpression>(), Arg.Do <List <Object> >(x => res = x)); interpreter.Dispatch(input1, expected, TypeEnum.Integer); res.Should().BeEquivalentTo(expected); }
public void Dispatch_IntegerLiteralAndObjectListAndIntegerType_CorrectValueReturned() { int expected = 17; IntegerLiteralExpression input1 = new IntegerLiteralExpression("", 0, 0); List <Object> input2 = new List <Object>() { 23, 2.334, null }; IIntegerHelper ihelper = Substitute.For <IIntegerHelper>(); Interpreter interpreter = Utilities.GetIntepreterOnlyWith(ihelper); ihelper.LiteralInteger(Arg.Any <IntegerLiteralExpression>(), Arg.Any <List <Object> >()).Returns(expected); int res = (int)interpreter.Dispatch(input1, input2, TypeEnum.Integer); Assert.AreEqual(expected, res); }
public void NegativeInteger_Integer_CorrectNegativeValue(int input, int expected) { IntegerLiteralExpression intLitExpr = new IntegerLiteralExpression(input, 0, 0); NegativeExpression negExpr = new NegativeExpression(new List <ExpressionNode>() { intLitExpr }, 0, 0); IInterpreterInteger parent = Substitute.For <IInterpreterInteger>(); parent.DispatchInt(intLitExpr, Arg.Any <List <object> >()).Returns(input); IntegerHelper integerHelper = SetUpHelper(parent); double res = integerHelper.NegativeInteger(negExpr, new List <object>()); Assert.AreEqual(expected, res); }
public void DispatchInteger_IntegerLiteralAndObjectList_CorrectIntegerLiteralExprPassed() { IntegerLiteralExpression expected = new IntegerLiteralExpression("", 0, 0); IntegerLiteralExpression input1 = expected; List <Object> input2 = new List <Object>() { 23, 2.334, null }; IIntegerHelper ihelper = Substitute.For <IIntegerHelper>(); Interpreter interpreter = Utilities.GetIntepreterOnlyWith(ihelper); IntegerLiteralExpression res = null; ihelper.LiteralInteger(Arg.Do <IntegerLiteralExpression>(x => res = x), Arg.Any <List <Object> >()); interpreter.DispatchInt(input1, input2); res.Should().BeEquivalentTo(expected); }
void AssertLiteralInRange(IntegerLiteralExpression literal, IType type) { bool ok = true; if (type == TypeSystemServices.ByteType) { ok = (literal.Value >= byte.MinValue && literal.Value <= byte.MaxValue); } else if (type == TypeSystemServices.SByteType) { ok = (literal.Value >= sbyte.MinValue && literal.Value <= sbyte.MaxValue); } else if (type == TypeSystemServices.ShortType) { ok = (literal.Value >= short.MinValue && literal.Value <= short.MaxValue); } else if (type == TypeSystemServices.UShortType) { ok = (literal.Value >= ushort.MinValue && literal.Value <= ushort.MaxValue); } else if (type == TypeSystemServices.IntType) { ok = (literal.Value >= int.MinValue && literal.Value <= int.MaxValue); } else if (type == TypeSystemServices.UIntType) { ok = (literal.Value >= uint.MinValue && literal.Value <= uint.MaxValue); } else if (type == TypeSystemServices.LongType) { ok = (literal.Value >= long.MinValue && literal.Value <= long.MaxValue); } if (!ok) { Error(CompilerErrorFactory.ConstantCannotBeConverted(literal, type)); } }
protected internal override void VisitIntegerLiteralExpression(IntegerLiteralExpression expression) { _writer.Append("{0}", expression.Value.ToString(CultureInfo.InvariantCulture)); }
public EnumMember(LexicalInfo token, IntegerLiteralExpression initializer) : base(token) { this.Initializer = initializer; }
protected internal override void VisitIntegerLiteralExpression(IntegerLiteralExpression expression) { _expr = Ssm.Expr.NewIntExpr(expression.Value); }
public virtual void Visit(IntegerLiteralExpression node) { DefaultVisit(node); }
/// <summary> /// Visits an element of type <see cref="IntegerLiteralExpression" />. /// </summary> /// <param name="expression">The <see cref="IntegerLiteralExpression" /> instance that should be visited.</param> protected internal virtual void VisitIntegerLiteralExpression(IntegerLiteralExpression expression) { DefaultVisit(expression); }
public virtual void Visit(IntegerLiteralExpression node) { }
public override void OnIntegerLiteralExpression(IntegerLiteralExpression e) { Write(e.Value.ToString()); }
public EnumMember(IntegerLiteralExpression initializer) { this.Initializer = initializer; }
/// <summary> /// Parses a simple expression (no function calls on top-level expression. /// </summary> public static bool AcceptAtom(string Text, int Start, out Expression Expression, out int LastChar) { // Procedure if (AcceptString(Text, Start, "{", out LastChar)) { ProcedureExpression procedure; AcceptWhitespace(Text, LastChar, out LastChar); AcceptProcedure(Text, LastChar, out procedure, out LastChar); AcceptWhitespace(Text, LastChar, out LastChar); if (AcceptString(Text, LastChar, "}", out LastChar)) { Expression = procedure; return true; } } // Variable Operator op; string varname; if (AcceptWord(Text, Start, out varname, out LastChar) && ValidVariable(varname) && !LookupOperator(varname, out op)) { Expression = new VariableExpression(varname); return true; } // Parentheses if (AcceptString(Text, Start, "(", out LastChar)) { // Operator int nc = LastChar; if (AcceptWord(Text, nc, out varname, out LastChar) && LookupOperator(varname, out op)) { if (AcceptString(Text, LastChar, ")", out LastChar)) { Expression = new VariableExpression(varname); return true; } } Expression exp; AcceptWhitespace(Text, nc, out LastChar); if (AcceptExpression(Text, LastChar, out exp, out LastChar)) { AcceptWhitespace(Text, LastChar, out LastChar); if (AcceptString(Text, LastChar, ")", out LastChar)) { Expression = exp; return true; } } } // Integer literal long val; if (AcceptIntegerLiteral(Text, Start, out val, out LastChar)) { Expression = new IntegerLiteralExpression(val); return true; } // Alternate lambda syntax if (AcceptString(Text, Start, "function", out LastChar)) { AcceptWhitespace(Text, LastChar, out LastChar); if (AcceptString(Text, LastChar, "(", out LastChar)) { AcceptWhitespace(Text, LastChar, out LastChar); List<KeyValuePair<Expression, string>> arglist; AcceptArgumentList(Text, LastChar, out arglist, out LastChar); AcceptWhitespace(Text, LastChar, out LastChar); if (AcceptString(Text, LastChar, ")", out LastChar)) { AcceptWhitespace(Text, LastChar, out LastChar); if (AcceptString(Text, LastChar, "{", out LastChar)) { ProcedureExpression procedure; AcceptWhitespace(Text, LastChar, out LastChar); AcceptProcedure(Text, LastChar, out procedure, out LastChar); AcceptWhitespace(Text, LastChar, out LastChar); if (AcceptString(Text, LastChar, "}", out LastChar)) { Expression = new FunctionDefineExpression(arglist, procedure); return true; } } } } } // Function type if (AcceptString(Text, Start, "<", out LastChar)) { AcceptWhitespace(Text, LastChar, out LastChar); List<KeyValuePair<Expression, string>> argtypelist; AcceptArgumentList(Text, LastChar, out argtypelist, out LastChar); AcceptWhitespace(Text, LastChar, out LastChar); if (AcceptString(Text, LastChar, ">", out LastChar)) { AcceptWhitespace(Text, LastChar, out LastChar); Expression returntype; if (AcceptTightExpression(Text, LastChar, out returntype, out LastChar)) { Expression = new FunctionTypeExpression(argtypelist, returntype); return true; } } } Expression = null; return false; }