public void SimpleLambda() { var boundVar = new BoundVariable(Token.NoToken, new TypedIdent(Token.NoToken, "foo", Microsoft.Boogie.Type.Bool)); var id = new IdentifierExpr(Token.NoToken, boundVar); // This is basically an Identity Map var lambdaExpr = new LambdaExpr(Token.NoToken, new List <TypeVariable>(), new List <Variable>() { boundVar }, null, id); var id2 = new IdentifierExpr(Token.NoToken, boundVar); var lambdaExpr2 = new LambdaExpr(Token.NoToken, new List <TypeVariable>(), new List <Variable>() { boundVar }, null, id2); Assert.AreNotSame(lambdaExpr, lambdaExpr2); // These are different references Assert.IsTrue(lambdaExpr.Equals(lambdaExpr2)); // These are "structurally equal" Assert.AreEqual(lambdaExpr.GetHashCode(), lambdaExpr2.GetHashCode()); // If the .Equals() is true then hash codes must be the same }
public override Expr VisitLambdaExpr(LambdaExpr node) { var attributes = _lambdaAttrs == null ? null : VisitQKeyValue(_lambdaAttrs); var body = VisitExpr(node.Body); return(new LambdaExpr(node.tok, node.TypeParameters, node.Dummies, attributes, body)); }
public Expr OnParseLambda() { var tokenIt = this._parser.TokenIt; var initiatorToken = tokenIt.NextToken; // <codeLambda> // Check for lambda or function declare. var next = tokenIt.Peek(); if (next.Token != Tokens.LeftParenthesis) { return(OnParseFunctionDeclare()); } // This a lambda. var expr = new LambdaExpr(); var funcExp = new FunctionExpr(); expr.Expr = funcExp; expr.Expr.Meta = new FunctionMetaData(); this._parser.SetupContext(funcExp, initiatorToken); var name = "anon_" + initiatorToken.Line + "_" + initiatorToken.LineCharPos; tokenIt.Advance(); tokenIt.Expect(Tokens.LeftParenthesis); var argnames = _parser.ParseNames(); funcExp.Meta.Init(name, argnames); tokenIt.Expect(Tokens.RightParenthesis); this.OnParseLambdaBlock(funcExp); // </codeLambda> this._parser.SetupContext(expr, initiatorToken); return(expr); }
private static bool ShallowEq(LambdaExpr expr1, LambdaExpr expr2) { #if THROW_UNSUPPORTED_COMPARISONS Contract.Assume(false); // This kind of expression never appears in a trigger throw new NotImplementedException(); #else return(false); #endif }
public virtual bool VisitLambdaExpr(LambdaExpr stmt) { if (!VisitExpr(stmt)) { return(false); } return(true); }
public void CachedHashCodeLambdaExpr() { var x = new BoundVariable(Token.NoToken, new TypedIdent(Token.NoToken, "x", BasicType.Int)); var y = new BoundVariable(Token.NoToken, new TypedIdent(Token.NoToken, "x", BasicType.Int)); var body = Expr.Gt(new IdentifierExpr(Token.NoToken, x, /*immutable=*/true), new IdentifierExpr(Token.NoToken, y, /*immutable=*/true)); var lambda = new LambdaExpr(Token.NoToken, new List<TypeVariable>(), new List<Variable>() {x, y}, null, body, /*immutable=*/true); Assert.AreEqual(lambda.ComputeHashCode(), lambda.GetHashCode()); }
public object VisitLambda(LambdaExpr expr) { var funcType = new LFunctionType(); funcType.Name = expr.Expr.Meta.Name; funcType.FullName = funcType.Name; var func = new LFunction(expr.Expr); func.Type = funcType; return(func); }
public void ProtectedLambdaExprBody() { var x = new BoundVariable(Token.NoToken, new TypedIdent(Token.NoToken, "x", BasicType.Int)); var y = new BoundVariable(Token.NoToken, new TypedIdent(Token.NoToken, "x", BasicType.Int)); var xId = new IdentifierExpr(Token.NoToken, x, /*immutable=*/true); var yId = new IdentifierExpr(Token.NoToken, y, /*immutable=*/true); var body = Expr.Gt(xId, yId); var lambda = new LambdaExpr(Token.NoToken, new List<TypeVariable>(), new List<Variable>() {x, y}, null, body, /*immutable=*/true); // Changing the body of an immutable LambdaExpr should fail Assert.Throws(typeof(InvalidOperationException), () => lambda.Body = Expr.Lt(xId, yId)); }
public void ProtectedLambdaExprBody() { var x = new BoundVariable(Token.NoToken, new TypedIdent(Token.NoToken, "x", BasicType.Int)); var y = new BoundVariable(Token.NoToken, new TypedIdent(Token.NoToken, "x", BasicType.Int)); var xId = new IdentifierExpr(Token.NoToken, x, /*immutable=*/ true); var yId = new IdentifierExpr(Token.NoToken, y, /*immutable=*/ true); var body = Expr.Gt(xId, yId); var lambda = new LambdaExpr(Token.NoToken, new List <TypeVariable>(), new List <Variable>() { x, y }, null, body, /*immutable=*/ true); lambda.Body = Expr.Lt(xId, yId); // Changing the body of an immutable ExistsExpr should fail }
public MaxHolesLambdaLifter( LambdaExpr lambda, Dictionary <Expr, FunctionCall> liftedLambdas, string freshFnName, List <Function> lambdaFunctions, List <Axiom> lambdaAxioms, int freshVarCount = 0 ) { _lambda = lambda; _liftedLambdas = liftedLambdas; _freshFnName = freshFnName; _lambdaFunctions = lambdaFunctions; _lambdaAxioms = lambdaAxioms; _freshVarCount = freshVarCount; }
private object Evaluate(Expr expression) { return(expression switch { BinaryExpr binaryExpr => Evaluate(binaryExpr), BlockExpr blockExpr => Evaluate(blockExpr), BreakExpr breakExpr => Evaluate(breakExpr), CallExpr callExpr => Evaluate(callExpr), ContinueExpr continueExpr => Evaluate(continueExpr), Identifier identifier => Evaluate(identifier), IfExpr ifExpr => Evaluate(ifExpr), LambdaExpr lambdaExpr => Evaluate(lambdaExpr), Literal literal => Evaluate(literal), ReturnExpr returnExpr => Evaluate(returnExpr), UnaryExpr unaryExpr => Evaluate(unaryExpr), _ => throw new ArgumentOutOfRangeException(nameof(expression)) });
public Expr Parse(ParserContext context) { // Create a lambda expression. LambdaExpr lambda = new LambdaExpr(); // Parse the formal arguments. FormalArgs args = new FormalArgsParser().Parse(context); // Assign the parsed arguments to the lambda. lambda.Args = args; // Create the type buffer, defaulting to void. ITypeEmitter type = PrimitiveTypeFactory.Void(); // Return type is explicitly specified, parse and use it instead of the default. if (context.Stream.Current.Type == TokenType.SymbolColon) { // Ensure current type is symbol colon. context.Stream.EnsureCurrent(TokenType.SymbolColon); // Skip symbol colon token. context.Stream.Skip(); // Parse the return type. type = new TypeParser().Parse(context); } // Assign the parsed type to the return type. lambda.ReturnType = type; // Ensure current token is symbol arrow. context.Stream.EnsureCurrent(TokenType.SymbolArrow); // Skip arrow symbol token. context.Stream.Skip(); // Parse the body block. Block body = new BlockParser().Parse(context); // Assign the block to the lambda. lambda.Body = body; // Return the resulting expression. return(lambda); }
private void Resolve(LambdaExpr lambda) { var enclosingLambda = _currentLambda; _currentLambda = true; BeginScope(); foreach (var parameter in lambda.Parameters) { Define(parameter); } Resolve(lambda.Body); EndScope(); _currentLambda = enclosingLambda; }
/// <summary> /// return value; /// </summary> /// <returns></returns> public override Expr Parse() { var token = _tokenIt.NextToken; var exp = new FunctionExpr(); _parser.SetupContext(exp, token); var name = "anon_" + token.Line + "_" + token.LineCharPos; _tokenIt.Advance(); _tokenIt.Expect(Tokens.LeftParenthesis); var argnames = _parser.ParseNames(); exp.Meta.Init(name, argnames); _tokenIt.Expect(Tokens.RightParenthesis); ParseBlock(exp); var lambdaExp = new LambdaExpr(); lambdaExp.Expr = exp; return(lambdaExp); }
public bool VisitLambdaExpr(LambdaExpr stmt) { throw new NotImplementedException(); }
public object VisitLambda(LambdaExpr expr) { return(null); }
public Expr VisitLambdaExpr(LambdaExpr e) { throw new NotImplementedException(); }
//do not support maps public override Expr VisitLambdaExpr(LambdaExpr node) { problematicNode = node; return(node); }
public override Expr VisitLambdaExpr(LambdaExpr node) { throw new NotImplementedException(); }
EXPR ParseExpr(bool isArithExpr) { EXPR e = null; if (tokens[i].type == TokenType.byte_lit) { e = new bytelit() { value = (byte)tokens[i].val }; i++; } else if (tokens[i].type == TokenType.int_lit) { e = new intlit() { value = (int)tokens[i].val }; i++; } else if (tokens[i].type == TokenType.string_lit) { e = new stringlit() { value = tokens[i].val as string }; i++; } else if (tokens[i].type == TokenType.symbol && (char)tokens[i].val == '<') { i++; List<string> fargs = new List<string>(); while (i < tokens.Length && !(tokens[i].type == TokenType.symbol && (char)tokens[i].val == '>')) { if (tokens[i].type == TokenType.word) { fargs.Add(tokens[i].val as string); } i++; } i++; bool lnfc = infnc; infnc = true; STMT[] body = ParseBody(); infnc = lnfc; e = new LambdaExpr() { args = fargs.ToArray(), body = body }; } else if (tokens[i].type == TokenType.word && tokens[i].val as string == "array" && tokens[i + 1].type == TokenType.symbol && (char)tokens[i + 1].val == '[') { i += 2; EXPR count = ParseExpr(isArithExpr); i++; e = new ArrayInitializer() { count = count }; } else if (tokens[i].type == TokenType.word && tokens[i + 1].type == TokenType.symbol && (char)tokens[i + 1].val == '[') { string varname = tokens[i].val as string; i += 2; EXPR index = ParseExpr(isArithExpr); i++; if (tokens[i].type == TokenType.symbol && (char)tokens[i].val == '=') { i++; EXPR val = ParseExpr(isArithExpr); e = new ArrayStrElem() { varname = varname, index = index, value = val }; } else { e = new ArrayGetElem() { varname = varname, index = index }; } } else if (i + 1 < tokens.Length && tokens[i + 1].type == TokenType.symbol && (char)tokens[i + 1].val == '(') { string fname = tokens[i].val as string; i += 2; List<EXPR> args = new List<EXPR>(); while (!(tokens[i].type == TokenType.symbol && (char)tokens[i].val == ')')) { EXPR ex = ParseExpr(isArithExpr); if (ex != null) { args.Add(ex); } else { i++; } } i++; e = new fcall() { fname = fname, args = args.ToArray() }; } else if (tokens[i].type == TokenType.word && tokens[i].val as string == "asm") { i++; string asm = tokens[i].val as string; i++; return new asm() { asmtxt = asm }; } else if (tokens[i].type == TokenType.word) { string vname = tokens[i].val as string; if (vname.StartsWith("@")) { e = new getvarptr() { varname = vname.Substring(1) }; } else { e = new getvar() { varname = vname }; } i++; } if (tokens[i].IsArithOp() && !isArithExpr) { List<EXPR> finalexpr = new List<EXPR>(); Stack<Token> stk = new Stack<Token>(); finalexpr.Add(e); bool lastwasop = false; int parentCount = 0; while (true) { if (tokens[i].type == TokenType.symbol && (char)tokens[i].val == ')' && parentCount > 0) { while (stk.Count > 0 && (char)stk.Peek().val != '(') { finalexpr.Add(stk.Pop().ToArith()); } stk.Pop(); i++; parentCount--; } else if (tokens[i].IsArithOp()) { if (stk.Count > 0 && tokens[i].ArithOpPriority() < stk.Peek().ArithOpPriority()) { if ((char)stk.Peek().val != '(') finalexpr.Add(stk.Pop().ToArith()); else parentCount++; } stk.Push(tokens[i]); lastwasop = true; i++; } else { if (lastwasop) { finalexpr.Add(ParseExpr(true)); lastwasop = false; } else { break; } } } while (stk.Count > 0) { finalexpr.Add(stk.Pop().ToArith()); } e = new arith_expr() { exprs = finalexpr.ToArray() }; } return e; }