public VariableNode(StateNode par, string realName, Model.Element elt, string shortName)
: base(par, realName, elt)
{
this.realName = realName;
name = new EdgeName(vm.GetUserVariableName(realName));
ShortName = shortName;
}
public bool MatchesWords(string[] words, Model.Element[] elts, Model.Element eq, int stateId)
{
var node = displayNodes[stateId];
if (node == null)
{
return(false);
}
var s1 = LongName(stateId).ToLower();
var s2 = node.Value.ToLower();
if (eq != null && node.Element != eq)
{
return(false);
}
foreach (var w in words)
{
if (!s1.Contains(w) && !s2.Contains(w))
{
return(false);
}
}
foreach (var e in elts)
{
if (!node.References.Contains(e))
{
return(false);
}
}
return(true);
}
protected override void onElementValueChanged(Model.Element element, bool hasValue, int newValue)
{
if (NewStep != null)
{
NewStep(this, new SudokuNewStepEventArgs(
new SudokuSolveStep(element, hasValue ? newValue : default(int?))));
}
}
public FieldNode(StateNode par, EdgeName realName, Model.Element elt)
: base(par, realName, elt)
{
/*
* var idx = realName.LastIndexOf('.');
* if (idx > 0)
* name = realName.Substring(idx + 1);
*/
}
public virtual void RegisterLocalValue(string name, Model.Element elt)
{
string curr;
if (localValue.TryGetValue(elt, out curr) && CompareFieldNames(name, curr) >= 0)
{
return;
}
localValue[elt] = name;
}
public Model.Element Image(Model.Element elt, Model.Func f)
{
var r = f.AppWithResult(elt);
if (r != null)
{
return(r.Args[0]);
}
return(null);
}
private object ToValue(Model.Element elem)
{
if (elem is Model.Integer)
{
return(Microsoft.BaseTypes.BigNum.FromInt((elem as Model.Integer).AsInt()));
}
if (elem is Model.Boolean)
{
return((elem as Model.Boolean).Value);
}
throw new NotImplementedException("Cannot yet handle this Model.Element type");
}
public FieldName(Model.Element elt, DafnyModel dm)
{
Field = elt;
NameArgs = new Model.Element[Dims];
var tpl = dm.f_dim.AppWithArg(0, elt);
if (tpl != null)
{
Dims = tpl.Result.AsInt();
NameArgs = new Model.Element[Dims];
for (int i = Dims; 0 <= --i;)
{
if (i == 0)
{
tpl = dm.f_index_field.AppWithResult(elt);
NameArgs[i] = tpl.Args[0];
}
else
{
tpl = dm.f_multi_index_field.AppWithResult(elt);
NameArgs[i] = tpl.Args[1];
elt = tpl.Args[0];
}
}
}
// now for the name
if (Dims == 0)
{
NameFormat = Field.ToString();
foreach (var n in Field.Names)
{
NameFormat = n.Func.Name;
int dot = NameFormat.LastIndexOf('.');
if (0 <= dot)
{
NameFormat = NameFormat.Substring(dot + 1);
}
break;
}
}
else
{
NameFormat = "[";
string sep = "";
for (int i = 0; i < Dims; i++)
{
NameFormat += sep + "%" + i;
sep = ",";
}
NameFormat += "]";
}
}
Model.Element Unbox(Model.Element elt)
{
var unboxed = f_box.AppWithResult(elt);
if (unboxed != null)
{
return(unboxed.Args[0]);
}
else
{
return(elt);
}
}
private IEnumerable <SkeletonItem> NamesFor(Model.Element elt)
{
var words = new string[0];
var elts = new Model.Element[0];
foreach (var s in allItems)
{
if (s.isPrimary[CurrentState] && s.MatchesWords(words, elts, elt, CurrentState))
{
yield return(s);
}
}
}
public virtual string CanonicalName(Model.Element elt)
{
string res;
if (elt == null)
{
return("?");
}
if (canonicalName.TryGetValue(elt, out res))
{
return(res);
}
NameSeqSuffix suff;
var baseName = CanonicalBaseName(elt, out suff);
if (baseName == "")
{
suff = NameSeqSuffix.Always;
}
if (viewOpts.DebugMode && !(elt is Model.Boolean) && !(elt is Model.Number))
{
baseName += string.Format("({0})", elt);
suff = NameSeqSuffix.WhenNonZero;
}
int cnt;
if (!baseNameUse.TryGetValue(baseName, out cnt))
{
cnt = -1;
}
cnt++;
if (suff == NameSeqSuffix.Always || (cnt > 0 && suff == NameSeqSuffix.WhenNonZero))
{
res = AppendSuffix(baseName, cnt);
}
else
{
res = baseName;
}
baseNameUse[baseName] = cnt;
canonicalName.Add(elt, res);
invCanonicalName[res.Replace(" ", "")] = elt;
return(res);
}
private static string ExtractValueFromModelElement(Model.Element Element)
{
if (Element is Model.BitVector)
{
return(((Model.BitVector)Element).Numeral);
}
else if (Element is Model.Uninterpreted)
{
return("<irrelevant>");
}
else if (Element == null)
{
return("<null>");
}
return(Element.ToString()); //"<unknown>";
}
public DafnyModel(Model m, ViewOptions opts)
: base(m, opts)
{
f_heap_select = m.MkFunc("[3]", 3);
f_set_select = m.MkFunc("[2]", 2);
f_seq_length = m.MkFunc("Seq#Length", 1);
f_seq_index = m.MkFunc("Seq#Index", 2);
f_box = m.MkFunc("$Box", 1);
f_dim = m.MkFunc("FDim", 1);
f_index_field = m.MkFunc("IndexField", 1);
f_multi_index_field = m.MkFunc("MultiIndexField", 2);
f_dtype = m.MkFunc("dtype", 1);
f_null = m.MkFunc("null", 0);
// collect the array dimensions from the various array.Length functions, and
// collect all known datatype values
foreach (var fn in m.Functions)
{
if (Regex.IsMatch(fn.Name, "^_System.array[0-9]*.Length[0-9]*$"))
{
int j = fn.Name.IndexOf('.', 13);
int dims = j == 13 ? 1 : int.Parse(fn.Name.Substring(13, j - 13));
int idx = j == 13 ? 0 : int.Parse(fn.Name.Substring(j + 7));
foreach (var tpl in fn.Apps)
{
var elt = tpl.Args[0];
var len = tpl.Result;
Model.Element[] ar;
if (!ArrayLengths.TryGetValue(elt, out ar))
{
ar = new Model.Element[dims];
ArrayLengths.Add(elt, ar);
}
Contract.Assert(ar[idx] == null);
ar[idx] = len;
}
}
else if (fn.Name.StartsWith("#") && fn.Name.IndexOf('.') != -1 && fn.Name[1] != '#')
{
foreach (var tpl in fn.Apps)
{
var elt = tpl.Result;
DatatypeValues.Add(elt, tpl);
}
}
}
}
protected override string CanonicalBaseName(Model.Element elt, out NameSeqSuffix suff)
{
Model.FuncTuple fnTuple;
suff = NameSeqSuffix.WhenNonZero;
if (DatatypeValues.TryGetValue(elt, out fnTuple))
{
// elt is s a datatype value, make its name be the name of the datatype constructor
string nm = fnTuple.Func.Name;
if (fnTuple.Func.Arity == 0)
{
return(nm);
}
else
{
return(nm + "(...)");
}
}
var seqLen = f_seq_length.AppWithArg(0, elt);
if (seqLen != null)
{
// elt is a sequence
return(string.Format("[Length {0}]", seqLen.Result.AsInt()));
}
if (elt == f_null.GetConstant())
{
return("null");
}
var tp = f_dtype.TryEval(elt);
if (tp != null)
{
foreach (var app in tp.References)
{
if (app.Args.Length == 0 && app.Func.Name.StartsWith("class."))
{
suff = NameSeqSuffix.Always;
return(app.Func.Name.Substring(6));
}
}
}
return(base.CanonicalBaseName(elt, out suff));
}
// Elements (other than integers and Booleans) get canonical names of the form
// "<base>'<idx>", where <base> is returned by this function, and <idx> is given
// starting with 0, and incrementing when there are conflicts between bases.
//
// This function needs to return an appropriate base name for the element. It is given
// the element.
//
// A reasonable strategy is to check if it's a name of the local, and if so return it,
// and otherwise use the type of element (e.g., return "seq" for elements representing
// sequences). It is also possible to return "" in such cases.
//
// The suff output parameter specifies whether the number sequence suffix should be
// always added, only when it's non-zero, or never.
protected virtual string CanonicalBaseName(Model.Element elt, out NameSeqSuffix suff)
{
string res;
if (elt is Model.Integer || elt is Model.Boolean)
{
suff = NameSeqSuffix.None;
return(elt.ToString());
}
suff = NameSeqSuffix.Always;
if (UseLocalsForCanonicalNames)
{
if (localValue.TryGetValue(elt, out res))
{
return(res);
}
}
return("");
}
internal DafnyModelVariable(DafnyModelState state, Model.Element element,
string name, DafnyModelVariable parent)
{
this.state = state;
Element = element;
Type = state.Model.GetDafnyType(element);
children = new Dictionary <string, HashSet <DafnyModelVariable> >();
state.AddVar(element, this);
if (parent == null)
{
Name = name;
}
else
{
// TODO: a case can be made for refactoring this so that the indices
// are model-wide rather than state-wide
Name = "@" + state.VarIndex++;
parent.AddChild(name, this);
}
state.AddVarName(ShortName);
}
public DafnyModel(Model m, ViewOptions opts)
: base(m, opts)
{
f_heap_select = m.MkFunc("[3]", 3);
f_set_select = m.MkFunc("[2]", 2);
f_seq_length = m.MkFunc("Seq#Length", 1);
f_seq_index = m.MkFunc("Seq#Index", 2);
f_box = m.MkFunc("$Box", 1);
f_dim = m.MkFunc("FDim", 1);
f_index_field = m.MkFunc("IndexField", 1);
f_multi_index_field = m.MkFunc("MultiIndexField", 2);
f_dtype = m.MkFunc("dtype", 1);
f_null = m.MkFunc("null", 0);
// collect the array dimensions from the various array.Length functions, and
// collect all known datatype values
foreach (var fn in m.Functions) {
if (Regex.IsMatch(fn.Name, "^_System.array[0-9]*.Length[0-9]*$")) {
int j = fn.Name.IndexOf('.', 13);
int dims = j == 13 ? 1 : int.Parse(fn.Name.Substring(13, j - 13));
int idx = j == 13 ? 0 : int.Parse(fn.Name.Substring(j + 7));
foreach (var tpl in fn.Apps) {
var elt = tpl.Args[0];
var len = tpl.Result;
Model.Element[] ar;
if (!ArrayLengths.TryGetValue(elt, out ar)) {
ar = new Model.Element[dims];
ArrayLengths.Add(elt, ar);
}
Contract.Assert(ar[idx] == null);
ar[idx] = len;
}
} else if (fn.Name.StartsWith("#") && fn.Name.IndexOf('.') != -1 && fn.Name[1] != '#') {
foreach (var tpl in fn.Apps) {
var elt = tpl.Result;
DatatypeValues.Add(elt, tpl);
}
}
}
}
/// <summary>
/// Create a new variable to be associated with the given model element in
/// a given counterexample state or return such a variable if one already
/// exists.
/// </summary>
/// <param name="state"></param>
/// <param name="element"></param>
/// <param name="name">the name to be assigned to the variable OR,
/// if parent != null, the name of the field associated with it. In the later
/// case, Name is set to some unique id.</param>
/// <param name="parent">if not null, this variable represents the field of
/// some parent object</param>
/// <param name="duplicate">forces the creation of a new variable even if
/// one already exists </param>
/// <returns></returns>
public static DafnyModelVariable Get(DafnyModelState state,
Model.Element element, string name, DafnyModelVariable parent = null,
bool duplicate = false)
{
if (state.ExistsVar(element))
{
parent?.AddChild(name, state.GetVar(element));
if (!duplicate)
{
return(state.GetVar(element));
}
return(new DuplicateVariable(state, state.GetVar(element), name, parent));
}
if (state.Model.GetDafnyType(element).Name == "seq")
{
return(new SeqVariable(state, element, name, parent));
}
if (state.Model.GetDafnyType(element).Name == "map")
{
return(new MapVariable(state, element, name, parent));
}
return(new DafnyModelVariable(state, element, name, parent));
}
public DisplayNode(ILanguageSpecificModel model, EdgeName n, Model.Element elt)
{
langModel = model;
name = n;
element = elt;
}
public SudokuSolveStep(Model.Element element, int?newValue)
{
this.element = element;
this.originValue = element.Value;
this.newValue = newValue;
}
public IEnumerable <ElementNode> GetExpansion(StateNode state, Model.Element elt)
{
List <ElementNode> result = new List <ElementNode>();
return(result);
}
public DisplayNode(ILanguageSpecificModel model, string n, Model.Element elt)
: this(model, new EdgeName(n), elt)
{
}
public ElementNode(StateNode st, string name, Model.Element elt)
: this(st, new EdgeName(name), elt)
{
}
protected abstract void onElementValueChanged(Model.Element element, bool hasValue, int newValue);
public ElementNode(BaseState st, string name, Model.Element elt) : base(st.m, name, elt)
{
this.st = st;
}
public ElementNode(StateNode st, EdgeName name, Model.Element elt)
: base(st.dm, name, elt)
{
this.stateNode = st;
this.elt = elt;
}
public MapletNode(StateNode par, EdgeName realName, Model.Element elt)
: base(par, realName, elt)
{
}
protected override void onElementValueChanged(Model.Element element, bool hasValue, int newValue)
{
element.Value = hasValue ? newValue : default(int?);
}
/// <summary>
/// Execute a script function
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="elemt"></param>
/// <returns></returns>
public static T ExecuteFunction <T>(Model.Element elemt, FunctionOperation funcOp) where T : struct
{
if (funcOp == FunctionOperation.ForReading)
{
if (string.IsNullOrWhiteSpace(elemt.Structure.funcr))
{
return((T)Convert.ChangeType(elemt.Value, Type.GetTypeCode(typeof(T))));
}
}
if (funcOp == FunctionOperation.ForWriting)
{
if (string.IsNullOrWhiteSpace(elemt.Structure.funcw))
{
return((T)Convert.ChangeType(elemt.Value, Type.GetTypeCode(typeof(T))));
}
}
switch (elemt.Type)
{
case ElementValueType.Float:
case ElementValueType.Int:
case ElementValueType.Short:
case ElementValueType.UInt:
case ElementValueType.UShort:
break;
default:
return((T)Convert.ChangeType(elemt.Value, Type.GetTypeCode(typeof(T))));
}
// Parse function name ElementValueType
string func = elemt.Structure.funcr;
if (funcOp == FunctionOperation.ForWriting)
{
func = elemt.Structure.funcw;
}
string[] s1 = func.Split('(');
string funcName = s1[0];
PyFunctionDefinition pyFunc;
if (!_pyDictionary.TryGetValue(funcName, out pyFunc))
{
string msg = "ExecuteReadingFunction: The '" + funcName + "' function doesn't exist !!!";
MessageBox.Show(msg, "TESSnip Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return((T)Convert.ChangeType(elemt.Value, Type.GetTypeCode(typeof(T))));
}
object function = _objOps.GetMember(_snipClassObj, funcName); // get function
// Parse parameters
string p = s1[1].Replace("(", "").Replace(")", "").Trim();
var param = new object[0];
if (!string.IsNullOrWhiteSpace(p))
{
string[] parameters = p.Split(',');
param = new object[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
// management of the decimal separator
parameters[i] = parameters[i].Trim();
parameters[i] = parameters[i].Replace(".", _ni.CurrencyDecimalSeparator);
parameters[i] = parameters[i].Replace(",", _ni.CurrencyDecimalSeparator);
}
try
{
for (int i = 0; i < parameters.Length; i++)
{
switch (pyFunc.Parameters[i + 3]) //+2 jump self, element and value parameter
{
case "float":
param[i] = float.Parse(parameters[i], _ni);
break;
case "int":
param[i] = int.Parse(parameters[i], _ni);
break;
case "short":
param[i] = short.Parse(parameters[i], _ni);
break;
case "uint":
param[i] = uint.Parse(parameters[i], _ni);
break;
case "ushort":
param[i] = ushort.Parse(parameters[i], _ni);
break;
}
}
}
catch (Exception ex)
{
MessageBox.Show(string.Format(@"ExecuteReadingFunction: {0}", ex.Message), @"TESSnip Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
throw;
}
}
var result = elemt.Value;
try
{
var el = new PyElement
{
Name = elemt.Structure.name,
Desc = elemt.Structure.desc,
CondId = elemt.Structure.CondID,
FormIdType = elemt.Structure.FormIDType,
Flags = elemt.Structure.flags,
Group = elemt.Structure.@group,
Multiline = elemt.Structure.multiline,
NotInInfo = elemt.Structure.notininfo,
Optional = elemt.Structure.optional,
Options = elemt.Structure.options,
Repeat = elemt.Structure.repeat,
FuncRead = elemt.Structure.funcr,
FuncWrite = elemt.Structure.funcw,
ValueType = elemt.Structure.type
};
switch (elemt.Type)
{
case ElementValueType.Float:
result = _objOps.Invoke(function, el, (float)elemt.Value, param);
break;
case ElementValueType.Int:
result = _objOps.Invoke(function, el, (int)elemt.Value, param);
break;
case ElementValueType.Short:
result = _objOps.Invoke(function, el, (short)elemt.Value, param);
break;
case ElementValueType.UInt:
result = _objOps.Invoke(function, el, (uint)elemt.Value, param);
break;
case ElementValueType.UShort:
result = _objOps.Invoke(function, el, (ushort)elemt.Value, param);
break;
}
}
catch (Exception ex)
{
MessageBox.Show(string.Format("ExecuteReadingFunction: {0}", ex.Message), @"TESSnip Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
throw;
}
return((T)Convert.ChangeType(result, Type.GetTypeCode(typeof(T))));
}
public FieldName(Model.Element elt, DafnyModel dm) {
Field = elt;
NameArgs = new Model.Element[Dims];
var tpl = dm.f_dim.AppWithArg(0, elt);
if (tpl != null) {
Dims = tpl.Result.AsInt();
NameArgs = new Model.Element[Dims];
for (int i = Dims; 0 <= --i; ) {
if (i == 0) {
tpl = dm.f_index_field.AppWithResult(elt);
NameArgs[i] = tpl.Args[0];
} else {
tpl = dm.f_multi_index_field.AppWithResult(elt);
NameArgs[i] = tpl.Args[1];
elt = tpl.Args[0];
}
}
}
// now for the name
if (Dims == 0) {
NameFormat = Field.ToString();
foreach (var n in Field.Names) {
NameFormat = n.Func.Name;
int dot = NameFormat.LastIndexOf('.');
if (0 <= dot)
NameFormat = NameFormat.Substring(dot + 1);
break;
}
} else {
NameFormat = "[";
string sep = "";
for (int i = 0; i < Dims; i++) {
NameFormat += sep + "%" + i;
sep = ",";
}
NameFormat += "]";
}
}
public ElementNode(StateNode st, EdgeName name, Model.Element elt)
: base(st.dm, name, elt)
{
this.stateNode = st;
this.elt = elt;
}
private void UpdateMatches(bool force)
{
var bad = false;
Model.Element eltEq = null;
var eltRef = new List <Model.Element>();
var words = new List <string>();
foreach (var w in textBox1.Text.Split(' '))
{
if (w == "")
{
continue;
}
if (w.StartsWith("eq:"))
{
if (eltEq != null)
{
bad = true;
}
else
{
eltEq = LangModel.FindElement(w.Substring(3));
if (eltEq == null)
{
bad = true;
}
}
}
else if (w.StartsWith("use:"))
{
var e = LangModel.FindElement(w.Substring(4));
if (e == null)
{
bad = true;
}
else
{
eltRef.Add(e);
}
}
else
{
words.Add(w.ToLower());
}
}
textBox1.ForeColor = bad ? Color.Red : Color.Black;
var wordsA = words.ToArray();
var refsA = eltRef.ToArray();
if (eltEq == null && wordsA.Length == 0 && refsA.Length == 0)
{
bad = true;
}
var changed = true; // force;
var matches = new List <SkeletonItem>();
foreach (var s in allItems)
{
var newMatch = false;
if (s.isPrimary[CurrentState] && !bad)
{
newMatch = s.MatchesWords(wordsA, refsA, eltEq, CurrentState);
}
if (newMatch)
{
matches.Add(s);
}
if (s.isMatch != newMatch)
{
changed = true;
s.isMatch = newMatch;
}
}
if (PreviousState >= 0)
{
stateList.Items[PreviousState].ForeColor = previousStateBrush.Color;
}
stateList.Items[CurrentState].ForeColor = currentStateBrush.Color;
if (changed)
{
SyncListView(matches, matchesList, (di, _) => { di.IsMatchListItem = true; });
SyncCurrentStateView();
}
}
public IEnumerable <ElementNode> GetExpansion(StateNode state, Model.Element elt)
{
List <ElementNode> result = new List <ElementNode>();
if (elt.Kind != Model.ElementKind.Uninterpreted)
{
return(result);
}
// Perhaps elt is a known datatype value
Model.FuncTuple fnTuple;
if (DatatypeValues.TryGetValue(elt, out fnTuple))
{
// elt is a datatype value
int i = 0;
foreach (var arg in fnTuple.Args)
{
var edgname = new EdgeName(this, i.ToString());
result.Add(new FieldNode(state, edgname, arg));
i++;
}
return(result);
}
// Perhaps elt is a sequence
var seqLen = f_seq_length.AppWithArg(0, elt);
if (seqLen != null)
{
// elt is a sequence
foreach (var tpl in f_seq_index.AppsWithArg(0, elt))
{
var edgname = new EdgeName(this, "[%0]", tpl.Args[1]);
result.Add(new FieldNode(state, edgname, Unbox(tpl.Result)));
}
return(result);
}
// Perhaps elt is a set
foreach (var tpl in f_set_select.AppsWithArg(0, elt))
{
var setElement = tpl.Args[1];
var containment = tpl.Result;
var edgname = new EdgeName(this, "[%0]", Unbox(setElement));
result.Add(new FieldNode(state, edgname, containment));
}
if (result.Count != 0)
{
return(result); // elt is a set
}
// It seems elt is an object or array
Model.Element[] lengths;
if (ArrayLengths.TryGetValue(elt, out lengths))
{
int i = 0;
foreach (var len in lengths)
{
var name = lengths.Length == 1 ? "Length" : "Length" + i;
var edgname = new EdgeName(this, name);
result.Add(new FieldNode(state, edgname, len));
i++;
}
}
var heap = state.State.TryGet("$Heap");
if (heap != null)
{
foreach (var tpl in f_heap_select.AppsWithArgs(0, heap, 1, elt))
{
var field = new FieldName(tpl.Args[2], this);
if (field.NameFormat != "alloc")
{
var edgname = new EdgeName(this, field.NameFormat, field.NameArgs);
result.Add(new FieldNode(state, edgname, Unbox(tpl.Result)));
}
}
}
return(result);
}