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;
}
