public ParameterVar AssignParameterVar(List <Element> actions, ScopeGroup scopeGroup, bool isGlobal, string name, Range range)
{
ParameterVar var = new ParameterVar(actions, scopeGroup, name, isGlobal, UseVar, Assign(isGlobal), range);
AllVars.Add(var);
return(var);
}
public Var AssignVar(string name, bool isGlobal)
{
Var var = new Var("INTERNAL : " + name, isGlobal, UseVar, Assign(isGlobal));
AllVars.Add(var);
return(var);
}
public DefinedVar AssignDefinedVar(ScopeGroup scopeGroup, bool isGlobal, string name, Range range)
{
DefinedVar var = new DefinedVar(scopeGroup, name, isGlobal, UseVar, Assign(isGlobal), range);
AllVars.Add(var);
return(var);
}
/// <summary>
/// Adds a variable to the collection of variables of the given type
/// </summary>
/// <typeparam name="T">The type matching the target collection of variables</typeparam>
/// <param name="v">The variable to add to the collection of matching type</param>
/// <returns>Returns true if the variable was successfully added</returns>
public bool AddVariable <T>(T v)
{
Type varType = typeof(T);
if (varType == typeof(IndependentVariable))
{
IndependentVariable iv = (IndependentVariable)Convert.ChangeType(v, typeof(IndependentVariable));
if (!IndVars.ContainsKey(iv.Name))
{
IndVars.Add(iv.Name, iv);
}
if (!AllVars.ContainsKey(iv.Name))
{
AllVars.Add(iv.Name, iv);
}
}
else
{
DependentVariable dv = (DependentVariable)Convert.ChangeType(v, typeof(DependentVariable));
if (!DepVars.ContainsKey(dv.Name))
{
DepVars.Add(dv.Name, dv);
}
if (!AllVars.ContainsKey(dv.Name))
{
AllVars.Add(dv.Name, dv);
}
}
return(true);
}
/// <summary>
/// Fetches a variable from the collection of variables matching the given type
/// </summary>
/// <typeparam name="T">The type of the collection of variables to search</typeparam>
/// <param name="name">The string representation of the given variable to search for</param>
/// <returns>Returns the variable if it was found, else returns null</returns>
public Variable TryGetVariable <T>(string name) where T : Variable
{
Type varType = typeof(T);
if (varType == typeof(IndependentVariable))
{
if (IndVars.ContainsKey(name))
{
return(IndVars[name]);
}
}
else if (varType == typeof(DependentVariable))
{
if (DepVars.ContainsKey(name))
{
return(DepVars[name]);
}
}
else if (varType == typeof(Variable))
{
if (AllVars.ContainsKey(name))
{
return(AllVars[name]);
}
}
return(null);
}
public string Replace(string line)
{
if (line.Contains('{') && line.Contains('}'))
{
if (line.IndexOf('{') > line.IndexOf('}'))
{
p.ExceptionHandler(7, LineN, Line);
}
else
{
do
{
string var = line.Remove(line.IndexOf('}'));
var = var.Substring(var.IndexOf('{') + 1);
if (AllVars.ContainsKey(var))
{
if (AllVars[var] == null)
{
p.ExceptionHandler(9, LineN, Line);
}
else
{
line = line.Replace($"{{{var}}}", AllVars[var][var]);
}
}
else
{
break;
}
}while (line.Contains('{'));
}
}
return(line);
}
public void Pog(string output)
{
if (output.Contains('{') && output.Contains('}'))
{
if (output.IndexOf('{') > output.IndexOf('}'))
{
p.ExceptionHandler(7, LineN, Line);
}
else
{
string var = output.Remove(output.IndexOf('}'));
var = var.Substring(var.IndexOf('{') + 1);
if (AllVars.ContainsKey(var))
{
if (AllVars[var] == null)
{
p.ExceptionHandler(9, LineN, Line);
}
else
{
output = output.Replace($"{{{var}}}", AllVars[var][var]);
}
}
}
}
try
{
Console.Write(output.Trim());
}
catch
{
p.ExceptionHandler(8, LineN, Line);
}
}
public void WeirdChamp(string varName, string type)
{
bool contains = false;
Dictionary <string, string> table = new Dictionary <string, string>();
if (Variables.ContainsKey(varName) || VariablesInt.ContainsKey(varName) || VariablesFloat.ContainsKey(varName))
{
contains = true;
}
switch (type)
{
case "string":
table = Variables;
break;
case "int":
table = VariablesInt;
break;
case "float":
table = VariablesFloat;
break;
default:
p.ExceptionHandler(11, LineN, Line);
break;
}
if (contains)
{
if (!table.ContainsKey(varName))
{
p.ExceptionHandler(6, LineN, Line);
}
else
{
try
{
table[varName] = Console.ReadLine();
}
catch
{
p.ExceptionHandler(10, LineN, Line);
}
}
}
else
{
try
{
table.Add(varName, Console.ReadLine());
AllVars.Add(varName, table);
}
catch
{
p.ExceptionHandler(10, LineN, Line);
}
}
}
/// <summary>
/// Converts an independent variable to a dependent variable.
/// </summary>
/// <param name="name">Variable to convert</param>
public void MakeDependent(string name)
{
// Get the value of the variable
bool value = IndVars[name].Value;
// Remove variable from independent variables dictionary
IndVars.Remove(name);
// Remove variable from variables dictionary
AllVars.Remove(name);
// Add new dependent variable to the dictionaries
AddVariable(new DependentVariable(name, value));
}
public void PogU(string varName, string type, string value)
{
bool contains = false;
Dictionary <string, string> table = new Dictionary <string, string>();
if (Variables.ContainsKey(varName) || VariablesInt.ContainsKey(varName) || VariablesFloat.ContainsKey(varName))
{
contains = true;
}
switch (type)
{
case "string":
table = Variables;
break;
case "int":
table = VariablesInt;
break;
case "float":
table = VariablesFloat;
break;
case "default":
p.ExceptionHandler(11, LineN, Line);
break;
}
if (contains)
{
if (!table.ContainsKey(varName))
{
p.ExceptionHandler(6, LineN, Line);
}
else
{
table[varName] = value;
}
}
else
{
table.Add(varName, value);
AllVars.Add(varName, table);
}
}
public static void Reset()
{
AllVars.Clear();
AllInequalities.Clear();
}
public override IEnumerable <ProofState> EvalInit(Statement statement, ProofState state)
{
Contract.Assume(statement != null);
Contract.Assume(statement is TacticForallStmt);
_stmt = statement as TacticForallStmt;
Contract.Assert(_stmt != null);
// do basic simplification
// maybe do a check and throw an error instead?
// fixme: error returns null!
//var e = (ForallExpr) SimpTacticExpr.SimpTacExpr(state0, _stmt.Spec);
var e = (ForallExpr)SimpExpr.SimpTacticExpr(state, _stmt.Spec);
// var e = _stmt.Spec as ForallExpr;
// to rename expressions
RenameVar rn = new RenameVar();
// to rename in the body of statement
RenameVar rnBody = new RenameVar();
List <String> usedVars = state.GetAllDafnyVars().Keys.ToList();
usedVars.AddRange(state.GetAllTVars().Keys.ToList());
//List<String> tmp = new List<string>();
AllVars.DeclaredVars(_stmt.Body.Body[0], ref usedVars);
if (_stmt.Attributes != null && _stmt.Attributes.Name.Equals("vars"))
{
var attrs = _stmt.Attributes.Args;
for (int i = 0; i < attrs.Count; i++)
{
// todo: should really report an errors if first condition does not hold
var segment = attrs[i] as NameSegment;
if (segment != null && i < e.BoundVars.Count)
{
NameSegment ns = segment;
String fv;
if (GenFreeVar(ns.Name, usedVars, out fv))
{
rnBody.AddRename(ns.Name, fv);
}
rn.AddRename(e.BoundVars[i].Name, fv);
} // else we should have an error
_vars = new List <BoundVar>();
foreach (BoundVar bv in e.BoundVars)
{
_vars.Add(rn.CloneBoundVar(bv));
}
}
}
else
{
_vars = e.BoundVars;
}
foreach (var tmp in _vars)
{
state.AddDafnyVar(tmp.Name, new ProofState.VariableData {
Variable = tmp, Type = tmp.Type
});
}
// we could even break _ens into a set of all conjunctions?
// what about forall x (forall y) x
var expr = e.Term as BinaryExpr;
if (expr != null && (expr.Op.Equals(BinaryExpr.Opcode.Imp)))
{
var be = expr;
_range = rn.CloneExpr(be.E0);
var t = new MaybeFreeExpression(rn.CloneExpr(be.E1));
var l = new List <MaybeFreeExpression> {
t
};
_ens = l;
}
else
{
_range = new LiteralExpr(_stmt.Tok, true);
var t = new MaybeFreeExpression(rn.CloneExpr(e.Term));
var l = new List <MaybeFreeExpression> {
t
};
_ens = l;
}
// Note that we do not need to rename variables in the body (unless the variables in vars is changed)
InitBasicFrameCtrl(new List <Statement>(), state.IsCurFramePartial(), null, VerifyN);
state.AddNewFrame(this);
var bodyFrame = new DefaultTacticFrameCtrl();
var newBody = rnBody.CloneBlockStmt(_stmt.Body);
bodyFrame.InitBasicFrameCtrl(newBody.Body, state.IsCurFramePartial(), null, VerifyN);
bodyFrame.IsPartial = IsPartial;
state.AddNewFrame(bodyFrame);
yield return(state);
}
