public PrtEventNode(PrtValue e, PrtValue payload, string senderMachineName, string senderMachineStateName) { ev = e; arg = payload.Clone(); this.senderMachineName = senderMachineName; this.senderMachineStateName = senderMachineStateName; }
public override bool IsEqual(PrtValue val) { Debug.Assert(val is PrtSeqValue, "Error in type checking, invalid equals invocation"); var seqVal = val as PrtSeqValue; if (seqVal.elements.Count != this.elements.Count) { return(false); } else { int index = 0; while (index < this.elements.Count) { if (!this.elements[index].IsEqual(seqVal.elements[index])) { return(false); } index++; } } return(true); }
public void EnqueueEvent(PrtValue e, PrtValue arg) { Debug.Assert(e is PrtEventValue, "Illegal enqueue of null event"); PrtEventValue ev = e as PrtEventValue; if (ev.evt.maxInstances == PrtEvent.DefaultMaxInstances) { events.Add(new PrtEventNode(e, arg)); } else { if (CalculateInstances(e) == ev.evt.maxInstances) { if (ev.evt.doAssume) { throw new PrtAssumeFailureException(); } else { throw new PrtMaxEventInstancesExceededException( String.Format(@"< Exception > Attempting to enqueue event {0} more than max instance of {1}\n", ev.evt.name, ev.evt.maxInstances)); } } else { events.Add(new PrtEventNode(e, arg)); } } }
public PrtContinuation() { reason = PrtContinuationReason.Return; retVal = PrtValue.@null; nondet = false; retLocals = new List <PrtValue>(); }
public PrtValue UpdateAndReturnOldValue(PrtValue index, PrtValue val) { var oldVal = Lookup(index); Update(index, val); return(oldVal); }
public static PrtValue PrtConvertValue(PrtValue value, PrtType type) { //cast for interface types is implemented as reduce. if (type is PrtInterfaceType) { return((type as PrtInterfaceType).PrtReduceValue(value)); } else if (type is PrtIntType) { if (value is PrtIntValue) { return(new PrtIntValue((value as PrtIntValue).nt)); } else { return(new PrtIntValue((Int64)(value as PrtFloatValue).ft)); } } else if (type is PrtFloatType) { if (value is PrtIntValue) { return(new PrtFloatValue((value as PrtIntValue).nt)); } else { return(new PrtFloatValue((Int64)(value as PrtFloatValue).ft)); } } else { throw new PrtInternalException("unexpected type in convert operation"); } }
public PrtValue UpdateAndReturnOldValue(int index, PrtValue val) { var oldVal = fieldValues[index]; fieldValues[index] = val; return(oldVal); }
public override bool Equals(PrtValue val) { var tup = val as PrtNamedTupleValue; if (tup == null) { return(false); } if (tup.fieldValues.Count != this.fieldValues.Count) { return(false); } for (int i = 0; i < tup.fieldValues.Count; i++) { if (this.fieldNames[i] != tup.fieldNames[i]) { return(false); } if (!this.fieldValues[i].Equals(tup.fieldValues[i])) { return(false); } } return(true); }
public override bool Equals(PrtValue val) { if (val is PrtNamedTupleValue) { return(false); } var tupValue = (val as PrtTupleValue); if (tupValue == null) { return(false); } if (tupValue.fieldValues.Count != this.fieldValues.Count) { return(false); } for (int i = 0; i < fieldValues.Count; i++) { if (!this.fieldValues[i].Equals(tupValue.fieldValues[i])) { return(false); } } return(true); }
public PrtValue UpdateAndReturnOldValue(PrtValue key, PrtValue val) { var oldVal = Lookup(key); Update(key, val); return(oldVal); }
public void Announce(PrtEventValue ev, PrtValue payload, PrtMachine parent) { if (ev.Equals(PrtValue.@null)) { throw new PrtIllegalEnqueueException("Enqueued event must not be null"); } PrtType prtType = ev.evt.payloadType; //assertion to check if argument passed inhabits the payload type. if (prtType is PrtNullType) { if (!payload.Equals(PrtValue.@null)) { throw new PrtIllegalEnqueueException("Did not expect a payload value"); } } else if (!PrtValue.PrtInhabitsType(payload, prtType)) { throw new PrtInhabitsTypeException(String.Format("Payload <{0}> does not match the expected type <{1}> with event <{2}>", payload.ToString(), prtType.ToString(), ev.evt.name)); } var allSpecMachines = GetSpecMachines(parent.renamedName); foreach (var mon in allSpecMachines) { if (mon.observes.Contains(ev)) { TraceLine("<AnnounceLog> Enqueued Event <{0}, {1}> to Spec Machine {2}", ev, payload, mon.Name); mon.PrtEnqueueEvent(ev, payload, parent); } } }
public override bool IsEqual(PrtValue val) { Debug.Assert(val is PrtMapValue, "Error in type checking, invalid equals invocation"); var mapVal = val as PrtMapValue; if (mapVal.keys.Count != this.keys.Count) { return(false); } else { foreach (var k in this.keys) { if (!mapVal.Contains(k)) { return(false); } else { var index = this.keys.FindIndex(_k => _k.IsEqual(k)); var _index = mapVal.keys.FindIndex(_k => _k.IsEqual(k)); if (this.values[index].IsEqual(mapVal.values[_index])) { return(false); } } } return(true); } }
public void Announce(PrtValue ev, PrtValue payload, PrtMachine parent) { foreach (var spec in specObservers[ev]) { spec.PrtEnqueueEvent(ev, payload, parent); } }
public PrtValue Lookup(PrtValue key) { if (!Contains(key)) { throw new PrtAssertFailureException("Illegal key in Lookup"); } return(keyToValueMap.Where(x => x.Key.key.Equals(key)).Select(y => y.Value).First()); }
public PrtValue Lookup(PrtValue key) { if (!Contains(key)) { throw new PrtAssertFailureException("Illegal key in Lookup"); } return(keyToValueMap[new PrtMapKey(key, 0)]); }
public PrtValue UpdateAndReturnOldValue(PrtValue key, PrtValue val) { var prtKey = new PrtMapKey(key, 0); var oldVal = keyToValueMap[prtKey]; keyToValueMap[prtKey] = val; return(oldVal); }
public void Remove(PrtValue key) { if (!Contains(key)) { throw new PrtAssertFailureException("Illegal key in Remove"); } keyToValueMap.Remove(new PrtMapKey(key, 0)); }
public void Insert(Int64 index, PrtValue val) { if (index < 0 || index > elements.Count) { throw new PrtAssertFailureException("Illegal index for Insert"); } elements.Insert((int)index, val); }
public PrtValue Lookup(PrtValue key) { if (!Contains(key)) { throw new PrtAssertFailureException(string.Format("Illegal key ({0}) in Lookup", key.ToString())); } return(keyToValueMap[new PrtMapKey(key, 0)]); }
public static PrtValue PrtCastValue(PrtValue value, PrtType type) { if (!PrtInhabitsType(value, type)) { throw new PrtInhabitsTypeException(String.Format("value {0} is not a member of type {1}", value.ToString(), type.ToString())); } return(value.Clone()); }
public override void PrtEnqueueEvent(PrtValue e, PrtValue arg, PrtMachine source) { if (e is PrtNullValue) { throw new PrtIllegalEnqueueException("Enqueued event must be non-null"); } PrtType prtType; PrtEventValue ev = e as PrtEventValue; //assertion to check if argument passed inhabits the payload type. prtType = ev.evt.payloadType; if (!(prtType is PrtNullType) && !PrtValue.PrtInhabitsType(arg, prtType)) { throw new PrtInhabitsTypeException(String.Format("Payload <{0}> does not match the expected type <{1}> with event <{2}>", arg.GetString(), prtType.GetString(), ev.evt.name)); } else if (prtType is PrtNullType && !(arg is PrtNullValue)) { throw new PrtIllegalEnqueueException("Did not expect a payload value"); } if (currentStatus == PrtMachineStatus.Halted) { stateImpl.Trace( @"<EnqueueLog> {0}-{1} Machine has been halted and Event {2} is dropped", this.Name, this.instanceNumber, ev.evt.name); } else { stateImpl.Trace( @"<EnqueueLog> Enqueued Event <{0}, {1}> in {2}-{3} by {4}-{5}", ev.evt.name, arg.GetString(), this.Name, this.instanceNumber, source.Name, source.instanceNumber); this.eventQueue.EnqueueEvent(e, arg); if (this.maxBufferSize != -1 && this.eventQueue.Size() > this.maxBufferSize) { if (this.doAssume) { throw new PrtAssumeFailureException(); } else { throw new PrtMaxBufferSizeExceededException( String.Format(@"<EXCEPTION> Event Buffer Size Exceeded {0} in Machine {1}-{2}", this.maxBufferSize, this.Name, this.instanceNumber)); } } if (currentStatus == PrtMachineStatus.Blocked && this.eventQueue.IsEnabled(this)) { currentStatus = PrtMachineStatus.Enabled; } } //Announce it to all the monitors stateImpl.Announce(e, arg, source); }
public PrtContinuation() { reason = PrtContinuationReason.Return; createdMachine = null; retVal = null; nondet = false; retLocals = new List <PrtValue>(); receiveIndex = -1; }
public override bool Equals(PrtValue val) { var intVal = val as PrtIntValue; if (intVal == null) { return(false); } return(this.nt == intVal.nt); }
public override bool Equals(PrtValue val) { var eventVal = val as PrtEventValue; if (eventVal == null) { return(false); } return(this.evt.name == eventVal.evt.name); }
public override bool Equals(PrtValue val) { var machineVal = val as PrtMachineValue; if (machineVal == null) { return(false); } return(this.mach == machineVal.mach); }
public void Remove(PrtValue index) { var intIndex = (index as PrtIntValue).nt; if (intIndex < 0 || intIndex >= elements.Count) { throw new PrtAssertFailureException("Illegal index for Remove"); } elements.RemoveAt(intIndex); }
public override bool Equals(PrtValue val) { var boolVal = val as PrtBoolValue; if (boolVal == null) { return(false); } return(this.bl == boolVal.bl); }
public void Update(PrtValue key, PrtValue val) { if (!Contains(key)) { //TODO: raise an exception for invalid update } var index = keys.FindIndex((k => k.Equals(key))); values[index] = val.Clone(); }
public bool PrtIsPushTransitionPresent(PrtValue ev) { if (CurrentState.transitions.ContainsKey(ev)) { return(CurrentState.transitions[ev].isPushTran); } else { return(false); } }
public void Remove(PrtValue key) { if (!Contains(key)) { //TODO: raise an exception for invalid remove } var index = keys.FindIndex((k => k.Equals(key))); keys.RemoveAt(index); values.RemoveAt(index); }