protected override void TrStringLiteral(StringLiteralExpr str, TextWriter wr)
{
var s = (string)str.Value;
var n = s.Length;
wr.Write("\"");
for (int i = 0; i < n; i++)
{
if (s[i] == '\\' && s[i + 1] == '0')
{
wr.Write("\\u0000");
i++;
}
else if (s[i] == '\n') // may appear in a verbatim string
{
wr.Write("\\n");
}
else if (s[i] == '\r') // may appear in a verbatim string
{
wr.Write("\\r");
}
else
{
wr.Write(s[i]);
}
}
wr.Write("\"");
}
/// <summary>
/// Resolve all variables in expression to either literal values
/// or to orignal declared nameSegments
/// </summary>
/// <param name="guard"></param>
/// <param name="state"></param>
/// <returns></returns>
public static IEnumerable <ExpressionTree> ResolveExpression(ExpressionTree guard, ProofState state)
{
Contract.Requires <ArgumentNullException>(guard != null, "guard");
Contract.Requires <ArgumentNullException>(state != null, "state");
if (guard.IsLeaf())
{
if (!(guard.Data is NameSegment))
{
yield return(guard.Copy());
}
var newGuard = guard.Copy();
var result = EvaluateLeaf(newGuard, state);
foreach (var item in result)
{
Contract.Assert(result != null);
Expression newNs = null; // potential encapsulation problems
if (item is MemberDecl)
{
var md = item as MemberDecl;
newNs = new StringLiteralExpr(new Token(), md.Name, true);
}
else if (item is Formal)
{
var tmp = item as Formal;
newNs = new NameSegment(tmp.tok, tmp.Name, null);
}
else if (item is NameSegment)
{
newNs = item as NameSegment;
}
else
{
newNs = item as Expression; // Dafny.LiteralExpr;
}
newGuard.Data = newNs;
yield return(newGuard);
}
}
else
{
foreach (var lChild in ResolveExpression(guard.LChild, state))
{
if (guard.RChild != null)
{
foreach (var rChild in ResolveExpression(guard.RChild, state))
{
yield return(new ExpressionTree(guard.Data, null, lChild, rChild));
}
}
else
{
yield return(new ExpressionTree(guard.Data, null, lChild, null));
}
}
}
}
/// <summary>
/// Process the declaration's "dllimport" attribute, if any, by emitting the corresponding .NET custom attribute.
/// Returns "true" if the declaration has an active "dllimport" attribute; "false", otherwise.
/// </summary>
public bool ProcessDllImport(MemberDecl decl, TextWriter wr)
{
Contract.Requires(decl != null);
Contract.Requires(wr != null);
var dllimportsArgs = Attributes.FindExpressions(decl.Attributes, "dllimport");
if (!DafnyOptions.O.DisallowExterns && dllimportsArgs != null)
{
StringLiteralExpr libName = null;
StringLiteralExpr entryPoint = null;
if (dllimportsArgs.Count == 2)
{
libName = dllimportsArgs[0] as StringLiteralExpr;
entryPoint = dllimportsArgs[1] as StringLiteralExpr;
}
else if (dllimportsArgs.Count == 1)
{
libName = dllimportsArgs[0] as StringLiteralExpr;
// use the given name, not the .CompileName (if user needs something else, the user can supply it as a second argument to :dllimport)
entryPoint = new StringLiteralExpr(decl.tok, decl.Name, false);
}
if (libName == null || entryPoint == null)
{
Error(decl.tok, "Expected arguments are {{:dllimport dllName}} or {{:dllimport dllName, entryPoint}} where dllName and entryPoint are strings: {0}", wr, decl.FullName);
}
else if ((decl is Method m && m.Body != null) || (decl is Function f && f.Body != null))
{
Error(decl.tok, "A {0} declared with :dllimport is not allowed a body: {1}", wr, decl.WhatKind, decl.FullName);
}
else if (!decl.IsStatic)
{
Error(decl.tok, "A {0} declared with :dllimport must be static: {1}", wr, decl.WhatKind, decl.FullName);
}
else
{
wr.Write("[System.Runtime.InteropServices.DllImport(");
TrStringLiteral(libName, wr);
wr.Write(", EntryPoint=");
TrStringLiteral(entryPoint, wr);
wr.WriteLine(")]");
}
return(true);
}
private static bool ShallowEq(StringLiteralExpr expr1, StringLiteralExpr expr2)
{
return(true);
}
public static StringLiteralExpr CopyStringLiteralExpr(StringLiteralExpr expr) {
return new StringLiteralExpr(expr.tok, expr.AsStringLiteral(), expr.IsVerbatim);
}
void ConstAtomExpression(out Expression e, bool allowSemi, bool allowLambda)
{
Contract.Ensures(Contract.ValueAtReturn(out e) != null);
IToken/*!*/ x; BigInteger n; Basetypes.BigDec d;
e = dummyExpr; Type toType = null;
switch (la.kind) {
case 131: {
Get();
e = new LiteralExpr(t, false);
break;
}
case 132: {
Get();
e = new LiteralExpr(t, true);
break;
}
case 133: {
Get();
e = new LiteralExpr(t);
break;
}
case 2: case 3: {
Nat(out n);
e = new LiteralExpr(t, n);
break;
}
case 4: {
Dec(out d);
e = new LiteralExpr(t, d);
break;
}
case 19: {
Get();
e = new CharLiteralExpr(t, t.val.Substring(1, t.val.Length - 2));
break;
}
case 20: {
Get();
bool isVerbatimString;
string s = Util.RemoveParsedStringQuotes(t.val, out isVerbatimString);
e = new StringLiteralExpr(t, s, isVerbatimString);
break;
}
case 134: {
Get();
e = new ThisExpr(t);
break;
}
case 135: {
Get();
x = t;
Expect(50);
Expression(out e, true, true);
Expect(51);
e = new UnaryOpExpr(x, UnaryOpExpr.Opcode.Fresh, e);
break;
}
case 136: {
Get();
x = t;
Expect(50);
Expression(out e, true, true);
Expect(51);
e = new OldExpr(x, e);
break;
}
case 23: {
Get();
x = t;
Expression(out e, true, true);
e = new UnaryOpExpr(x, UnaryOpExpr.Opcode.Cardinality, e);
Expect(23);
break;
}
case 8: case 10: {
if (la.kind == 8) {
Get();
x = t; toType = new IntType();
} else {
Get();
x = t; toType = new RealType();
}
Expect(50);
Expression(out e, true, true);
Expect(51);
e = new ConversionExpr(x, e, toType);
break;
}
case 50: {
ParensExpression(out e, allowSemi, allowLambda);
break;
}
default: SynErr(234); break;
}
}
private void AddVariant(Statement st, ref List <Solution> solution_list)
{
List <Expression> call_arguments = null;
List <Expression> dec_list = null;
Expression input = null;
InitArgs(st, out call_arguments);
Contract.Assert(tcce.OfSize(call_arguments, 1), Util.Error.MkErr(st, 0, 1, call_arguments.Count));
StringLiteralExpr wildCard = call_arguments[0] as StringLiteralExpr;
if (wildCard != null)
{
if (wildCard.Value.Equals("*"))
{
input = new WildcardExpr(wildCard.tok);
}
}
else
{
// hack
/*
* TODO:
* Implement propper variable replacement
*/
object tmp;
ProcessArg(call_arguments[0], out tmp);
Contract.Assert(tmp != null);
IVariable form = tmp as IVariable;
if (form != null)
{
input = new NameSegment(form.Tok, form.Name, null);
}
else if (tmp is BinaryExpr)
{
input = tmp as BinaryExpr;
}
else if (tmp is NameSegment)
{
input = tmp as NameSegment;
}
}
WhileStmt ws = FindWhileStmt(globalContext.tac_call, globalContext.md);
if (ws != null)
{
WhileStmt nws = null;
dec_list = new List <Expression>(ws.Decreases.Expressions.ToArray());
dec_list.Add(input);
Specification <Expression> decreases = new Specification <Expression>(dec_list, ws.Attributes);
nws = new WhileStmt(ws.Tok, ws.EndTok, ws.Guard, ws.Invariants, decreases, ws.Mod, ws.Body);
AddUpdated(ws, nws);
}
else
{
Method target = Program.FindMember(globalContext.program.ParseProgram(), localContext.md.Name) as Method;
if (GetNewTarget() != null && GetNewTarget().Name == target.Name)
{
target = GetNewTarget();
}
Contract.Assert(target != null, Util.Error.MkErr(st, 3));
dec_list = target.Decreases.Expressions;
// insert new variants at the end of the existing variants list
Contract.Assert(input != null);
dec_list.Add(input);
Specification <Expression> decreases = new Specification <Expression>(dec_list, target.Decreases.Attributes);
Method result = null;
dynamic lemma = null;
if ((lemma = target as Lemma) != null)
{
result = new Lemma(lemma.tok, lemma.Name, lemma.HasStaticKeyword, lemma.TypeArgs, lemma.Ins, lemma.Outs,
lemma.Req, lemma.Mod, lemma.Ens, decreases, lemma.Body, lemma.Attributes, lemma.SignatureEllipsis);
}
else if ((lemma = target as CoLemma) != null)
{
result = new CoLemma(lemma.tok, lemma.Name, lemma.HasStaticKeyword, lemma.TypeArgs, lemma.Ins, lemma.Outs,
lemma.Req, lemma.Mod, lemma.Ens, decreases, lemma.Body, lemma.Attributes, lemma.SignatureEllipsis);
}
else
{
result = new Method(target.tok, target.Name, target.HasStaticKeyword, target.IsGhost, target.TypeArgs,
target.Ins, target.Outs, target.Req, target.Mod, target.Ens, decreases, target.Body, target.Attributes,
target.SignatureEllipsis);
}
// register new method
this.localContext.new_target = result;
globalContext.program.IncTotalBranchCount(globalContext.program.currentDebug);
}
solution_list.Add(new Solution(this.Copy()));
}
/// <summary>
/// Encode an 'extern' declaration modifier as an {:extern name} attribute.
///
/// We also include an {:axiom} attribute since the specification of an
/// external entity is assumed to hold, but only for methods or functions.
///</summary>
static void EncodeExternAsAttribute(DeclModifierData dmod, ref Attributes attrs, IToken/*!*/ id, bool needAxiom) {
if (dmod.IsExtern) {
StringLiteralExpr name = dmod.ExternName;
if (name == null) {
bool isVerbatimString = false;
name = new StringLiteralExpr(id, id.val, isVerbatimString);
}
var args = new List<Expression>();
args.Add(name);
attrs = new Attributes("extern", args, attrs);
// Also 'extern' implies 'axiom' for methods or functions.
if (needAxiom) {
attrs = new Attributes("axiom", new List<Expression>(), attrs);
}
}
}
private Expression ParseFactor()
{
if (Accept(Token.Types.IntLiteral))
{
IntLiteralExpr exp = new IntLiteralExpr(AcceptedToken.Line, AcceptedToken.Column);
exp.ExprValue = int.Parse(AcceptedToken.Content);
return exp;
}
else if (Accept(Token.Types.StringLiteral))
{
StringLiteralExpr expr = new StringLiteralExpr(AcceptedToken.Line, AcceptedToken.Column);
expr.ExprValue = AcceptedToken.Content;
return expr;
}
else if (Accept(Token.Types.Identifier))
{
IdentifierExpr node = new IdentifierExpr(AcceptedToken.Line, AcceptedToken.Column, AcceptedToken.Content);
return node;
}
else if (Accept(Token.Types.LParen))
{
Expression exp = ParseExpression();
Match(Token.Types.RParen);
return exp;
}
else throw new ParserException(String.Format("Expected literal or identifier, got {0} instead at line {1} column {2}.",
CurrentToken.Type, CurrentToken.Line, CurrentToken.Column));
}
public void Visit(StringLiteralExpr stringLiteralExpr)
{
PrintNode("String " + stringLiteralExpr.ExprValue, true);
}
public static StringLiteralExpr CopyStringLiteralExpr(StringLiteralExpr expr)
{
return(new StringLiteralExpr(expr.tok, expr.AsStringLiteral(), expr.IsVerbatim));
}
void ConstAtomExpression(out Expression e, bool allowSemi, bool allowLambda)
{
Contract.Ensures(Contract.ValueAtReturn(out e) != null);
IToken/*!*/ x; BigInteger n; Basetypes.BigDec d;
e = dummyExpr; Type toType = null;
switch (la.kind) {
case 138: {
Get();
e = new LiteralExpr(t, false);
break;
}
case 139: {
Get();
e = new LiteralExpr(t, true);
break;
}
case 140: {
Get();
e = new LiteralExpr(t);
break;
}
case 2: case 3: {
Nat(out n);
e = new LiteralExpr(t, n);
break;
}
case 4: {
Dec(out d);
e = new LiteralExpr(t, d);
break;
}
case 20: {
Get();
e = new CharLiteralExpr(t, t.val.Substring(1, t.val.Length - 2));
break;
}
case 21: {
Get();
bool isVerbatimString;
string s = Util.RemoveParsedStringQuotes(t.val, out isVerbatimString);
e = new StringLiteralExpr(t, s, isVerbatimString);
break;
}
case 141: {
Get();
e = new ThisExpr(t);
break;
}
case 142: {
Get();
x = t;
Expect(54);
Expression(out e, true, true);
Expect(55);
e = new UnaryOpExpr(x, UnaryOpExpr.Opcode.Fresh, e);
break;
}
case 143: {
Get();
x = t;
Expect(54);
Expression(out e, true, true);
Expect(55);
e = new UnaryOpExpr(x, UnaryOpExpr.Opcode.Allocated, e);
break;
}
case 144: {
Get();
x = t; FrameExpression fe; var mod = new List<FrameExpression>();
Expect(54);
FrameExpression(out fe, false, false);
mod.Add(fe);
while (la.kind == 23) {
Get();
FrameExpression(out fe, false, false);
mod.Add(fe);
}
Expect(55);
e = new UnchangedExpr(x, mod);
break;
}
case 145: {
Get();
x = t;
Expect(54);
Expression(out e, true, true);
Expect(55);
e = new OldExpr(x, e);
break;
}
case 24: {
Get();
x = t;
Expression(out e, true, true, false);
e = new UnaryOpExpr(x, UnaryOpExpr.Opcode.Cardinality, e);
Expect(24);
break;
}
case 9: case 11: {
if (la.kind == 9) {
Get();
x = t; toType = new IntType();
} else {
Get();
x = t; toType = new RealType();
}
errors.Deprecated(t, string.Format("the syntax \"{0}(expr)\" for type conversions has been deprecated; the new syntax is \"expr as {0}\"", x.val));
Expect(54);
Expression(out e, true, true);
Expect(55);
e = new ConversionExpr(x, e, toType);
break;
}
case 54: {
ParensExpression(out e, allowSemi, allowLambda);
break;
}
default: SynErr(262); break;
}
}
/// <summary>
/// Resolve all variables in expression to either literal values
/// or to orignal declared nameSegments
/// </summary>
/// <param name="guard"></param>
/// <param name="state"></param>
/// <returns></returns>
public static IEnumerable<ExpressionTree> ResolveExpression(ExpressionTree guard, ProofState state) {
Contract.Requires<ArgumentNullException>(guard != null, "guard");
Contract.Requires<ArgumentNullException>(state != null, "state");
if (guard.IsLeaf()) {
if (!(guard.Data is NameSegment)) {
yield return guard.Copy();
}
var newGuard = guard.Copy();
var result = EvaluateLeaf(newGuard, state);
foreach (var item in result) {
Contract.Assert(result != null);
Expression newNs = null; // potential encapsulation problems
if (item is MemberDecl) {
var md = item as MemberDecl;
newNs = new StringLiteralExpr(new Token(), md.Name, true);
} else if (item is Formal) {
var tmp = item as Formal;
newNs = new NameSegment(tmp.tok, tmp.Name, null);
} else if (item is NameSegment) {
newNs = item as NameSegment;
} else {
newNs = item as Expression; // Dafny.LiteralExpr;
}
newGuard.Data = newNs;
yield return newGuard;
}
} else {
foreach (var lChild in ResolveExpression(guard.LChild, state)) {
if (guard.RChild != null) {
foreach (var rChild in ResolveExpression(guard.RChild, state)) {
yield return new ExpressionTree(guard.Data, null, lChild, rChild);
}
} else {
yield return new ExpressionTree(guard.Data, null, lChild, null);
}
}
}
}
