DIRECTORY
FinchSmarts USING [ConvDesc, ObtainServiceInterface, ReportSystemStateProc, ReportConversationStateProc, ReportRequestStateProc, RegisterForReports, ServiceConnect],
Atom USING [GetPName, GetPropFromList, PutPropOnList],
Process USING [SecondsToTicks, SetTimeout, Ticks],
PupSocket USING [GetUniqueID],
RefID USING [ID, nullID],
Rope USING [ROPE, Concat],
RPC USING [CallFailed, ImportFailed],
Thrush USING [ActionType, ConversationID, InterfaceSpec, none, nullConvID, SHHH],
VoiceRopeServer,
VoiceRopeServerRpcControl USING [ImportInterface],
VoiceUtils USING [Problem],
VoiceRope;

VoiceRopeImpl: CEDAR MONITOR
IMPORTS Atom, FinchSmarts, Process, PupSocket, Rope, RPC, VoiceRopeServer, VoiceRopeServerRpcControl, VoiceUtils
EXPORTS VoiceRope
~ BEGIN

ROPE: TYPE ~ Rope.ROPE;

recordingService: ROPE = "recording";
recordingServiceInterface: ROPE = "VoiceRopeServer";

RequestID: TYPE = VoiceRope.RequestID;
PendingRequest: TYPE = REF PendingRequestBody;
PendingRequestBody: TYPE = RECORD [
id: RequestID,
state: Thrush.ActionType _ $unknown
];
PendingRequests: TYPE = LIST OF PendingRequest;

VoiceRopeInfo: TYPE = REF VoiceRopeInfoBody;
VoiceRopeInfoBody: TYPE = RECORD [
imported: BOOLEAN _ FALSE,
serviceID: RefID.ID _ RefID.nullID,
shhh: Thrush.SHHH _ Thrush.none
];

VoiceRopeDesc: TYPE = REF VoiceRopeDescBody;
VoiceRopeDescBody: TYPE = RECORD [
cDesc: FinchSmarts.ConvDesc _ NIL, -- only valid during operations below.
serviceID: RefID.ID _ RefID.nullID,
shhh: Thrush.SHHH _ Thrush.none,
pendingRequests: PendingRequests _ NIL,
reportArrived: CONDITION,
clientData: REF_NIL
];

info: VoiceRopeInfo _ NEW[VoiceRopeInfoBody];
Handle: TYPE = VoiceRope.Handle;  -- handles are no longer used for anything

Open: PUBLIC PROC [voiceRopeDBName: ROPE _ NIL, localName: ROPE _ NIL, Complain: PROC[complaint: ROPE] _ NIL] RETURNS [handle: Handle] ~ {
RETURN[NIL];  -- this routine is no longer needed!
};
Record: PUBLIC PROC[handle: Handle_NIL]
RETURNS [voiceRope: VoiceRope.VoiceRope_NIL] ~ { [voiceRope: voiceRope] _ RecordNB[handle: handle]; };

Play: PUBLIC PROC[handle: Handle_NIL, voiceRope: VoiceRope.VoiceRope,
queueIt: BOOL_TRUE, wait: BOOL_FALSE] ~ {
[] _ PlayNB[handle: handle, voiceRope: voiceRope, queueIt: queueIt, wait: wait]; };

Stop: PUBLIC PROC[handle: Handle_NIL] ~ { [] _ StopNB[handle: handle]; };

RecordNB: PUBLIC PROC [handle: Handle_NIL, requestID: RequestID_VoiceRope.nullRequestID, convID: Thrush.ConversationID_ Thrush.nullConvID, clientData: REF_NIL] RETURNS [nb: VoiceRope.NB, voiceRope: VoiceRope.VoiceRope_NIL, newConvID: Thrush.ConversationID_ Thrush.nullConvID] ~ {
ENABLE RPC.CallFailed => { IF ~info.imported THEN CONTINUE; info.imported_FALSE; RETRY; };
vrDesc: VoiceRopeDesc _ GetConversation[convID, clientData];
IF vrDesc = NIL THEN RETURN [$noConv, NIL];
newConvID _ vrDesc.cDesc.situation.self.convID;
requestID _ AddRequest[vrDesc, requestID];
[nb, voiceRope] _
VoiceRopeServer.Record[vrDesc.shhh,
vrDesc.cDesc.situation.self, vrDesc.serviceID, requestID, TRUE];
IF nb#$success THEN {
VoiceUtils.Problem[Rope.Concat["Attempt to record failed - ",Atom.GetPName[nb]], $VoiceRope];
RETURN;
};
WaitForRequestState[vrDesc: vrDesc, state: $finished, id: requestID];
[nb, voiceRope.length] _ VoiceRopeServer.Length[vrDesc.shhh, voiceRope
! RPC.CallFailed => {nb _ $callFailed; CONTINUE}];
IF nb#$success THEN {
VoiceUtils.Problem[Rope.Concat["Attempt to get voicerope length failed - ",Atom.GetPName[nb]], $VoiceRope];
nb _ $noLength;
RETURN;
};
};
PlayNB: PUBLIC PROC [handle: Handle_NIL, voiceRope: VoiceRope.VoiceRope, queueIt: BOOL_TRUE, wait: BOOL_FALSE, requestID: RequestID_VoiceRope.nullRequestID, convID: Thrush.ConversationID_Thrush.nullConvID, clientData: REF_NIL] RETURNS [nb: VoiceRope.NB, newConvID: Thrush.ConversationID _ Thrush.nullConvID] ~ {
ENABLE RPC.CallFailed => { IF ~info.imported THEN CONTINUE; info.imported_FALSE; RETRY; };
vrDesc: VoiceRopeDesc _ GetConversation[convID, clientData];
IF vrDesc = NIL THEN RETURN [$noConv];
newConvID _ vrDesc.cDesc.situation.self.convID;
requestID _ AddRequest[vrDesc, requestID];
nb _ VoiceRopeServer.Play[
vrDesc.shhh, voiceRope, vrDesc.cDesc.situation.self, vrDesc.serviceID, requestID, queueIt];
IF nb#$success THEN {
VoiceUtils.Problem[Rope.Concat["Attempt to play voicerope failed - ",Atom.GetPName[nb]], $VoiceRope];
RETURN;
};
IF wait THEN WaitForRequestState[vrDesc: vrDesc, state: $started, id: requestID];
};
StopNB: PUBLIC PROC [handle: Handle _ NIL, convID: Thrush.ConversationID_ Thrush.nullConvID] RETURNS [nb: VoiceRope.NB] ~ {
ENABLE RPC.CallFailed => { IF ~info.imported THEN CONTINUE; info.imported_FALSE; RETRY; };
vrDesc: VoiceRopeDesc _ GetConversation[convID, NIL, FALSE];
IF vrDesc=NIL THEN RETURN [$noConv];
nb _ VoiceRopeServer.Stop[vrDesc.shhh, vrDesc.cDesc.situation.self, vrDesc.serviceID];
IF nb#$success THEN {
VoiceUtils.Problem[Rope.Concat["Attempt to stop failed - ",Atom.GetPName[nb]], $VoiceRope];
RETURN;
};
};
Retain: PUBLIC PROC [handle: Handle _ NIL, vr: VoiceRope.VoiceRope, class: VoiceRope.InterestClass, refID: ROPE, other: ROPE _ NIL] ~ {
ENABLE RPC.CallFailed => { IF ~info.imported THEN CONTINUE; info.imported_FALSE; RETRY; };
nb: VoiceRope.NB;
IF NOT RecordingServiceInterface[] THEN RETURN; 
nb _ VoiceRopeServer.Retain[info.shhh, vr, class, refID, other];
IF nb#$success THEN {
VoiceUtils.Problem[Rope.Concat["Attempt to retain voicerope failed - ",Atom.GetPName[nb]], $VoiceRope];
RETURN;
};
};
Forget: PUBLIC PROC [handle: Handle _ NIL, vr: VoiceRope.VoiceRope, class: VoiceRope.InterestClass, refID: ROPE] ~ {
ENABLE RPC.CallFailed => { IF ~info.imported THEN CONTINUE; info.imported_FALSE; RETRY; };
nb: VoiceRope.NB;
IF NOT RecordingServiceInterface[] THEN RETURN; 
nb _ VoiceRopeServer.Forget[info.shhh, vr, class, refID];
IF nb#$success THEN {
VoiceUtils.Problem[Rope.Concat["Attempt to forget voicerope failed - ",Atom.GetPName[nb]], $VoiceRope];
RETURN;
};
};
GetByInterest: PUBLIC PROC [handle: Handle _ NIL, class: VoiceRope.InterestClass, refID: ROPE] RETURNS [voiceRope: VoiceRope.VoiceRope] ~ {
ENABLE RPC.CallFailed => { IF ~info.imported THEN CONTINUE; info.imported_FALSE; RETRY; };
nb: VoiceRope.NB;
IF NOT RecordingServiceInterface[] THEN RETURN; 
[nb, voiceRope] _ VoiceRopeServer.GetByInterest[info.shhh, class, refID];
IF nb#$success THEN {
VoiceUtils.Problem[Rope.Concat["Attempt to lookup voicerope by interest failed - ",Atom.GetPName[nb]], $VoiceRope];
RETURN;
};
};
Cat: PUBLIC PROC [handle: Handle _ NIL, vr1, vr2, vr3, vr4, vr5: VoiceRope.VoiceRope _ NIL] RETURNS [new: VoiceRope.VoiceRope_NIL] ~ {
ENABLE RPC.CallFailed => { IF ~info.imported THEN CONTINUE; info.imported_FALSE; RETRY; };
nb: VoiceRope.NB;
IF NOT RecordingServiceInterface[] THEN RETURN; 
[nb, new] _ VoiceRopeServer.Cat[info.shhh, vr1, vr2, vr3, vr4, vr5];
IF nb#$success THEN {
VoiceUtils.Problem[Rope.Concat["Attempt to cat voiceropes failed - ",Atom.GetPName[nb]], $VoiceRope];
RETURN;
};
};
Substr: PUBLIC PROC [handle: Handle _ NIL, vr: VoiceRope.VoiceRope, start: INT _ 0, len: INT _ LAST[INT]] RETURNS [new: VoiceRope.VoiceRope_NIL] ~ {
ENABLE RPC.CallFailed => { IF ~info.imported THEN CONTINUE; info.imported_FALSE; RETRY; };
nb: VoiceRope.NB;
IF NOT RecordingServiceInterface[] THEN RETURN; 
[nb, new] _ VoiceRopeServer.Substr[info.shhh, vr, start, len];
IF nb#$success THEN {
VoiceUtils.Problem[Rope.Concat["Attempt to substring voicerope failed - ",Atom.GetPName[nb]], $VoiceRope];
RETURN;
};
};
Replace: PUBLIC PROC [handle: Handle _ NIL, vr: VoiceRope.VoiceRope, start: INT _ 0, len: INT _ LAST[INT], with: VoiceRope.VoiceRope _ NIL] RETURNS [new: VoiceRope.VoiceRope_NIL] ~ {
ENABLE RPC.CallFailed => { IF ~info.imported THEN CONTINUE; info.imported_FALSE; RETRY; };
nb: VoiceRope.NB;
IF NOT RecordingServiceInterface[] THEN RETURN; 
[nb, new] _ VoiceRopeServer.Replace[info.shhh, vr, start, len, with];
IF nb#$success THEN {
VoiceUtils.Problem[Rope.Concat["Attempt to replace part of a voicerope failed - ",Atom.GetPName[nb]], $VoiceRope];
RETURN;
};
};
Length: PUBLIC PROC [handle: Handle _ NIL, vr: VoiceRope.VoiceRope] RETURNS [len: INT_1] ~ {
ENABLE RPC.CallFailed => { IF ~info.imported THEN CONTINUE; info.imported_FALSE; RETRY; };
nb: VoiceRope.NB;
IF NOT RecordingServiceInterface[] THEN RETURN; 
[nb, len] _ VoiceRopeServer.Length[info.shhh, vr ! RPC.CallFailed => {nb _ $callFailed; CONTINUE}];
IF nb#$success THEN {
VoiceUtils.Problem[Rope.Concat["Attempt to get voicerope length failed - ",Atom.GetPName[nb]], $VoiceRope];
RETURN;
};
};
DescribeRope: PUBLIC PROC [
handle: Handle _ NIL, vr: VoiceRope.VoiceRope, minSilence: INT _ -1]
RETURNS [noise: VoiceRope.IntervalSpecs_NIL] ~ {
ENABLE RPC.CallFailed => { IF ~info.imported THEN CONTINUE; info.imported_FALSE; RETRY; };
nb: VoiceRope.NB;
len: INT;
IF NOT RecordingServiceInterface[] THEN RETURN; 
[nb, len, noise] _ VoiceRopeServer.DescribeRope[info.shhh, vr, minSilence];
IF nb#$success THEN {
VoiceUtils.Problem[Rope.Concat["Attempt to describe voicerope failed - ",Atom.GetPName[nb]], $VoiceRope];
RETURN;
};
};

SystemReport: FinchSmarts.ReportSystemStateProc ~ {
NULL;
};

ConversationReport: FinchSmarts.ReportConversationStateProc ~ {
vrDesc: VoiceRopeDesc _ GetVRDesc[cDesc];
IF vrDesc = NIL THEN RETURN;
SELECT cDesc.situation.self.state FROM
$active => NULL;
$idle, $neverWas, $failed => {  -- throw away pending requests
RemoveRequests[vrDesc, NIL]; 
NotifyWaiters[vrDesc];
};
ENDCASE;
};

RequestReport: FinchSmarts.ReportRequestStateProc ~ {
request: PendingRequest;
vrDesc: VoiceRopeDesc _ GetVRDesc[cDesc];
IF vrDesc = NIL THEN RETURN;
SELECT actionReport.actionClass FROM
$recording, $playback => { 
request _ GetRequestByID[vrDesc, actionReport.actionID];
IF request = NIL THEN RETURN[NIL];
request.state _ actionReport.actionType;
SELECT request.state FROM
$scheduled, $started => NULL;
$finished, $flushed => 
RemoveRequests[vrDesc, request]; 
ENDCASE;
NotifyWaiters[vrDesc];
};
ENDCASE;
RETURN[NIL];  -- leave actionRequest alone
};


GetRequestByID: ENTRY PROC [vrDesc: VoiceRopeDesc, id: RequestID] RETURNS [request: PendingRequest _ NIL] ~ {
IF vrDesc=NIL THEN RETURN;
FOR q: PendingRequests _ vrDesc.pendingRequests, q.rest WHILE q # NIL DO
IF q.first.id = id THEN RETURN[q.first];
ENDLOOP;
};

AddRequest: ENTRY PROC [vrDesc: VoiceRopeDesc, id: RequestID] RETURNS [requestID: RequestID] ~ {
request: PendingRequest _ NEW[PendingRequestBody _
[requestID _ IF id=VoiceRope.nullRequestID THEN NewRequestID[] ELSE id]];
vrDesc.pendingRequests _ CONS[request, vrDesc.pendingRequests];
};

RemoveRequests: ENTRY PROC [vrDesc: VoiceRopeDesc, request: PendingRequest] RETURNS [] ~ {
IF vrDesc=NIL THEN RETURN;
IF request = NIL OR vrDesc.pendingRequests = NIL OR vrDesc.pendingRequests.first = request THEN
vrDesc.pendingRequests _ NIL
ELSE
FOR q: PendingRequests _ vrDesc.pendingRequests, q.rest WHILE q.rest # NIL DO
IF q.rest.first = request THEN {
q.rest _ NIL;  -- truncate queue to remove this and all previous requests
EXIT;
};
ENDLOOP;
};

NotifyWaiters: ENTRY PROC [vrDesc: VoiceRopeDesc] RETURNS [] ~ {
ENABLE UNWIND => NULL;
IF vrDesc=NIL THEN RETURN;
BROADCAST vrDesc.reportArrived;
};

Wait: ENTRY PROC [vrDesc: VoiceRopeDesc] RETURNS [] ~ {
ENABLE UNWIND => NULL;
IF vrDesc=NIL THEN RETURN;
WAIT vrDesc.reportArrived;
};

WaitForRequestState: PROC [vrDesc: VoiceRopeDesc, state: Thrush.ActionType, id: RequestID] RETURNS [] ~ {
request: PendingRequest;
timeout: Process.Ticks _ IF state = $started THEN Process.SecondsToTicks[2] ELSE Process.SecondsToTicks[10];
IF vrDesc=NIL THEN RETURN;
TRUSTED { Process.SetTimeout[@vrDesc.reportArrived, timeout]; };
DO
request _ GetRequestByID[vrDesc, id];
IF request = NIL THEN EXIT;  -- completed or conv went idle
SELECT state FROM
$scheduled => SELECT request.state FROM
$scheduled, $started, $finished, $flushed => EXIT;
ENDCASE => NULL;  -- unknown?
$started => SELECT request.state FROM
$started, $finished, $flushed => EXIT;
ENDCASE => NULL;  -- probably $scheduled
$finished => SELECT request.state FROM
$finished, $flushed => EXIT;
ENDCASE => NULL;  -- probably $scheduled or $started
ENDCASE => EXIT;
Wait[vrDesc];
ENDLOOP;
};

GetClientData: PUBLIC PROC[handle: Handle_NIL, cDesc: FinchSmarts.ConvDesc]
RETURNS[clientData: REF_NIL] = {
vrDesc: VoiceRopeDesc _ GetVRDesc[cDesc];
IF vrDesc#NIL THEN { -- vrDesc.cDesc_NIL; -- RETURN[vrDesc.clientData]; };
};
GetVRDesc: PROC[cDesc: FinchSmarts.ConvDesc] RETURNS[vrDesc: VoiceRopeDesc_NIL] = {
IF cDesc#NIL THEN
vrDesc _ NARROW[Atom.GetPropFromList[cDesc.props, $VoiceRopeDesc]];
IF vrDesc#NIL THEN vrDesc.cDesc _ cDesc;
};

GetConversation: PROC [
convID: Thrush.ConversationID, clientData: REF_NIL, createOK: BOOL_TRUE]
RETURNS [vrDesc: VoiceRopeDesc _ NIL] ~ {
nb: VoiceRope.NB;
cDesc: FinchSmarts.ConvDesc;
[nb, cDesc] _ FinchSmarts.ServiceConnect[recordingService, convID, createOK];
IF nb#$success THEN {
VoiceUtils.Problem[Rope.Concat["Can't establish conversation - ",Atom.GetPName[nb]], $VoiceRope];
RETURN[NIL];
};
vrDesc _ GetVRDesc[cDesc];
IF vrDesc=NIL THEN {
vrDesc _ NEW[VoiceRopeDescBody _ []];
cDesc.props _ Atom.PutPropOnList[cDesc.props, $VoiceRopeDesc, vrDesc];
vrDesc.cDesc _ cDesc;
};
IF clientData#NIL THEN vrDesc.clientData _ clientData;
IF ~RecordingServiceInterface[vrDesc] THEN cDesc _ NIL;
};

RecordingServiceInterface: PROC[vrDesc: VoiceRopeDesc _ NIL] RETURNS [imported: BOOLEAN _ TRUE] = {
nb: VoiceRope.NB;
interfaceSpec: Thrush.InterfaceSpec;
cDesc: FinchSmarts.ConvDesc _ IF vrDesc=NIL THEN NIL ELSE vrDesc.cDesc;
IF info.imported AND vrDesc#NIL AND vrDesc.serviceID#RefID.nullID THEN RETURN[TRUE];
[nb, info.shhh, interfaceSpec] _
FinchSmarts.ObtainServiceInterface[recordingService, recordingServiceInterface, cDesc];
IF nb#$success THEN RETURN[FALSE];
info.serviceID _ interfaceSpec.serviceID;
IF vrDesc#NIL THEN { vrDesc.serviceID _ info.serviceID; vrDesc.shhh _ info.shhh; };
IF info.imported THEN RETURN[TRUE];
info.imported _ TRUE;
VoiceRopeServerRpcControl.ImportInterface[interfaceName: interfaceSpec.interfaceName, hostHint: interfaceSpec.hostHint 
! RPC.ImportFailed => {
info.imported _ FALSE; 
VoiceUtils.Problem["Can't import recording service.", $VoiceRope];
CONTINUE}];
RETURN[info.imported];
};

NewRequestID: PUBLIC PROC RETURNS [VoiceRope.RequestID] = {
RETURN[LOOPHOLE[PupSocket.GetUniqueID[]]]};
FinchSmarts.RegisterForReports[c: ConversationReport, r: RequestReport];

END.
:VoiceRopeImpl.mesa
Copyright c 1986 by Xerox Corporation.  All rights reserved.
Doug Terry, October 14, 1986 3:59:55 pm PDT
Swinehart, July 24, 1987 4:14:18 pm PDT
Polle Zellweger (PTZ) July 27, 1987 2:44:12 pm PDT

Client code for interacting with the Voice Rope Service.



Probably needs more reporting when RPC calls fail and reconnects fail, too.
VoiceRope client interface
If voiceRopeDBName or localName is omitted, a default based on the user profile choice of Thrush Server is invented.  If Complain is omitted, Log.Problem[...$Finch] is used.

Records a voice rope, registers it , and returns its ID.  A NIL return value indicates that something went wrong.
Create or find conversation, import service interface, record client data if provided
wait for report that says it finished (or was abandoned)
vrDesc.cDesc _ NIL; -- 
Break cycles when conversation goes away

Play a specified voice rope.  The boolean arguments are interpreted as follows:
queueIt => play after all other record/playback requests are satisfied.
wait => wait until things appear to be started properly, or have failed.
vrDesc.cDesc _ NIL;

Stops any recording or playback in progress.
vrDesc.cDesc _ NIL;

Registers a new interest in the voice rope.  The voice rope will be retained until either a corresponding Forget is done or the class' garbage collection process determines that the voice rope is no longer referenced, e.g. refID no longer exists.  Taken together, the vr, class, and refID must be unique.  Repeated calls of Retain with the same parameters (ignoring other) will only register a single interest.

The specified refID of the specified class drops its interest in the voice rope.  The voice rope is not necessarily deleted, however, since other interests in the same voice rope may exist.

Returns any voice rope that is of interest to the given class and refID; returns NIL if no such voice rope exists.

Concatenates together the non-NIL voice ropes to produce a new voice rope.

Creates a new voice rope that is a substring of an existing voice rope.

Creates a new voice rope in which the given interval of the voice rope "vr" is replaced by the voice rope "with".

Returns the actual length of the voice rope.  This operation ignores the start and length values specified in the voice rope.  Thus, vr.start _ 0; vr.length _ Length[handle, vr] will restore a voice rope to its full contents.


Report handling
Action reports are generated by the voice rope server when a request for $recording/$playback is $scheduled, $started, $finished, or $flushed.  Reports are also available from FinchSmarts concerning the state of a conversation or Finch in general.

A list of pending requests is maintained as part of VoiceRopeInfo.  This list is sorted so that the most recent request is at the head of the list.  Upon receipt of a $finished or $flushed report, the associated request (and all previous requests) are removed from the pending request queue.  All pending requests are flushed if the established conversation goes idle (i.e. the user hangs up).  The condition, reportArrived, is raised whenever a new report is received.  Procedures that wish to wait for a given action report may wait on this condition; they should then check the state of the pending request queue and take appropriate action (such as waiting again).
Don't care about changes in system state at the moment.
[ nb: NB, cDesc: ConvDesc, remark: ROPE_NIL ]
[ cDesc: ConvDesc, actionReport: Thrush.ActionReport, actionRequest: REF ] RETURNS [betterActionRequest: REF]
Throw away pending requests that are complete.  This includes requests preceding the one being reported on.
The following routines manage the queue of pending requests.  (They are the only monitor entry procedures in this module.)
Establishing conversations and RPC connections
Initializations
Doug Terry, August 14, 1986 9:40:42 am PDT
changes to: DIRECTORY, VoiceRopeClientImpl, EXPORTS, ~, Open, Record, Play, Stop, Retain, Forget, GetByInterest, Cat, Substr, Replace, Length, DescribeRope, Proc, Proc
Doug Terry, August 14, 1986 9:58:55 am PDT
changes to: DIRECTORY, VoiceRopeClientImpl, EXPORTS, ~, Open, Record, Play, Stop, Retain, Forget, GetByInterest, Cat, Substr, Replace, Length, DescribeRope, VoiceRopeInterface, Proc, Proc, END
Doug Terry, August 27, 1986 11:43:29 am PDT
changes to: DIRECTORY, VoiceRopeImpl, ~, Open, Play, Stop, VoiceRopeInterface, DescribeRope
Doug Terry, August 29, 1986 4:13:15 pm PDT
changes to: ~, Play, VoiceRopeImpl, Record, Stop, NewID, Proc, Retain, Forget, GetByInterest, Cat, Substr, Replace, Length, DescribeRope, RecordingServiceInterface
Doug Terry, September 5, 1986 4:28:37 pm PDT
changes to: DIRECTORY, IMPORTS, EXPORTS, ~, Handle, Open, Proc
Doug Terry, September 25, 1986 2:59:31 pm PDT
changes to: DIRECTORY, SystemReport, ConversationReport, RequestReport, FinchSmarts, Record
Doug Terry, September 29, 1986 5:56:59 pm PDT
changes to: SystemReport, Record, ConversationReport, RequestReport, ~
Doug Terry, October 3, 1986 3:51:47 pm PDT
changes to: ~, GetRequestByID, GetRequestByRef, NewRequest, RemoveRequests, NewID, Record, Play, ConversationReport, RequestReport, WaitForRequestState, DIRECTORY, IMPORTS, Retain, Forget, GetByInterest, Cat, Substr, Replace, Length, DescribeRope, RecordingServiceInterface, Stop, WaitForRequestState, Handle, Open
Doug Terry, October 3, 1986 4:45:36 pm PDT
changes to: RequestReport
Doug Terry, October 6, 1986 1:44:44 pm PDT
changes to: DIRECTORY, ~, Record, Play, Stop, Retain, Forget, GetByInterest, Cat, Substr, Replace, Length, DescribeRope, RecordingServiceInterface, IMPORTS
Doug Terry, October 9, 1986 8:00:18 pm PDT
changes to: Record, Stop, Retain, Forget, GetByInterest, Cat, Substr, Replace, Length, DescribeRope
Doug Terry, October 9, 1986 8:45:25 pm PDT
changes to: Wait, WaitForRequestState
Doug Terry, October 14, 1986 3:59:55 pm PDT
changes to: ConversationReport
Polle Zellweger (PTZ) July 20, 1987 5:57:28 pm PDT
Changes to allow TiogaVoice to monitor conversation state/reports about voicerope operations.
changes to: Record, Play, Stop, NewID=>NewRequestID
Polle Zellweger (PTZ) July 20, 1987 6:08:42 pm PDT
changes to: DIRECTORY, Record, Play, Stop, Retain, Forget, GetByInterest, Cat, Substr, Replace, Length, DescribeRope, GetConversation, RecordingServiceInterface, NewRequestID
Polle Zellweger (PTZ) July 21, 1987 12:04:32 pm PDT
changes to: DIRECTORY, Record, Play, Record, Play, Stop, StopNB

Swinehart, July 24, 1987 12:12:38 pm PDT
Merge disparate changes to VoiceRope.  Improve error and connection recovery; adapt to interface changes in FinchSmarts.
changes to: DIRECTORY, ~, Open, Record, Play, queueIt, Stop, RecordNB, PlayNB, StopNB, Retain, Forget, GetByInterest, Cat, Substr, Replace, Length, DescribeRope, GetConversation, RecordingServiceInterface, NewRequestID
Polle Zellweger (PTZ) July 27, 1987 12:20:16 pm PDT
changes to: PlayNB, RecordNB, StopNB, GetClientData, GetConversation


สช˜
codeš
œ™Kšœ
ฯm
œ1™<K™+Kš
œ'™'Kš
œ2™2—K™K™8K™š
ฯk	˜	Kšœžœ”
˜ฅ
Kšœžœ,˜6Kšœžœ%˜2Kšœ
žœ˜Kšœžœžœ
˜Kšœžœžœ
˜Kšžœ
žœ˜%Kšœžœ?žœ˜QKš
œ˜Kšœžœ˜2Kšœžœ˜Kš
œ
˜
—K˜Kšะbl
œžœ
ž˜Kšžœi˜pKšžœ
˜šœž˜K˜Kšžœžœžœ
˜K˜Kšœžœ˜%Kšœžœ˜4K˜Kšœžœž
œ
˜&Kšœžœžœ˜.šœžœžœ˜#Kš
œ˜Kš
œ#˜#K˜—Kšœžœžœ
žœ˜/K˜Kšœžœžœ˜,šœžœžœ˜"Kšœ
žœžœ
˜Kšœžœ˜#Kšœ
žœ˜K˜K˜—Kšœžœžœ˜,šœžœžœ˜"Kšœžœฯc&˜IKšœžœ˜#Kšœ
žœ˜ Jšœ#žœ
˜'Jšœž
˜Kšœžœ
ž˜K˜K˜—Kšœžœ˜-J™Jš
œM™M—
head™Kšœžœž
œ	 *˜LK˜šฯnœžœ
žœžœžœ
žœžœกœžœžœžœžœ˜Š
Jš
œญ
™ญ
Kšžœ
žœ $˜2K˜K™—šกœžœ
žœžœ
˜'Jšžœ!žœ;˜fJ˜—šกœžœžœ!˜Eš	œ	žœ
žœžœ
žœ˜)Jš
œS˜S—J˜—šกœžœžœ%˜IJ˜—šกœžœ
žœžœnžœ
žœžœžœ!žœ:˜—K™qJšัkosะos
ขฃขฃขฃ
ขฃขฃขฃ˜Zš
œ<˜<Jš
œU™U—Jš
žœ
žœ
žœ
žœžœ˜+J˜/Jš
œ*˜*šœฯtœ˜šœค˜#Jšค$œ	คœžค˜@——šžœ
žœ
ž
˜Kš
œ]˜]Jšžœ
˜J˜—Jš
œ8™8Jš
œE˜Ešœ6คœ
˜FJšคžœคœžœ˜2—šžœ
žœ
ž
˜Kš
œk˜kJ˜Jšžœ
˜J˜—Jšœžœ ค
 (ค
™AK˜K™—šกœžœ
žœžœ+žœ
žœžœ
žœmžœ
žœžœžœ;˜ทš
œO™OJš
œG™GJš
œH™H—Jšขฃ
ขฃขฃขฃ
ขฃขฃขฃ˜ZJš
œ<˜<Jšžœ
žœ
žœ
žœ˜&Jš
œ/˜/Jš
œ*˜*šœค˜Jšœคœ	คœคœค
œ	คœ	ค˜[—šžœ
žœ˜Jš
œe˜eJšžœ
˜J˜—JšžœžœE˜QJšœžœ
™Kš
œ˜K™—šกœžœ
žœžœ4žœžœ˜{K™,Jšขฃ
ขฃขฃขฃ
ขฃขฃขฃ˜ZJšœ0žœžœ˜<Jšžœžœ
žœ
žœ˜$Jš
œคœคœคœค
œ	ค˜Všžœ
žœ˜Jš
œ[˜[Jšžœ
˜J˜—Jšœžœ
™˜K™——šกœžœ
žœžœBžœ	žœžœ˜‡
Kš
œš™šJšขฃ
ขฃขฃขฃ
ขฃขฃขฃ˜ZJš
œ˜Jšžœ
žœžœ
žœ˜0Jšœค
œคœคœคœคœค˜@šžœ
žœ
ž
˜Jš
œg˜gJšžœ
˜J˜—K˜K™—š
กœžœ
žœžœBžœ˜tKš
œฝ
™ฝ
Jšขฃ
ขฃขฃขฃ
ขฃขฃขฃ˜ZJš
œ˜Jšžœ
žœžœ
žœ˜0Jš
œค
œคœคœคœค˜9šžœ
žœ
ž
˜Jš
œg˜gJšžœ
˜J˜—K˜K™—šก
œžœ
žœžœ)žœžœ%˜‹
Kš
œr™rJšขฃ
ขฃขฃขฃ
ขฃขฃขฃ˜ZJš
œ˜Jšžœ
žœžœ
žœ˜0Jšœ!ค
œ
คœคœค˜Išžœ
žœ
ž
˜Jš
œs˜sJšžœ
˜J˜—K˜K™—šกœžœ
žœžœ1žœžœžœ˜†
K™JJšขฃ
ขฃขฃขฃ
ขฃขฃขฃ˜ZJšœžœ
˜Jšžœ
žœžœ
žœ˜0Jšœค
œคœค˜Dšžœ
žœ
ž
˜Jš
œe˜eJšžœ
˜J˜—K˜K™—šกœžœ
žœžœ"žœžœžœ
žœžœžœ˜”
K™GJšขฃ
ขฃขฃขฃ
ขฃขฃขฃ˜ZJš
œ˜Jšžœ
žœžœ
žœ˜0Jšœค
œคœค˜>šžœ
žœ
ž
˜Jš
œj˜jJšžœ
˜J˜—K˜K™—šกœžœ
žœžœ"žœžœžœ
žœžœžœžœ˜ถ
K™qJšขฃ
ขฃขฃขฃ
ขฃขฃขฃ˜ZJš
œ˜Jšžœ
žœžœ
žœ˜0Jšœค
œคœค˜Ešžœ
žœ
ž
˜Jš
œr˜rJšžœ
˜J˜—K˜K™—šกœžœ
žœžœžœžœ˜\K™แ
Jšขฃ
ขฃขฃขฃ
ขฃขฃขฃ˜ZJš
œ˜Jšžœ
žœžœ
žœ˜0Jš
œค
œคœคžœคœžœ
ค˜cšžœ
žœ
ž
˜Jš
œk˜kJšžœ
˜Jš
œ˜—Kš
œ˜K™—šกœžœ
žœ˜Kšœžœ'žœ˜DKšžœ!žœ˜0Jšขฃ
ขฃขฃขฃ
ขฃขฃขฃ˜ZJš
œ˜Jšœžœ
˜	Jšžœ
žœžœ
žœ˜0Jšœ"ค
œคœค˜Kšžœ
žœ
ž
˜Jš
œi˜iJšžœ
˜J˜—K˜K™——™Kš
œ๗
™๗
K™Kš
œœ™œK˜šกœ'˜3Kš
œ7™7Kšžœ
˜K˜K˜—šกœ-˜?Kšœžœžœ
žœ™-Jš
œ)˜)Jšžœ
žœ
žœ
žœ
˜šžœž˜&Jšœžœ
˜šœ  ˜>Kšœžœ˜Kš
œ˜Jš
œ˜—Jšžœ
˜—K˜K˜—šก
œ(˜5KšœEžœžœžœ
™mJš
œ˜Jš
œ)˜)Jšžœ
žœ
žœ
žœ
˜šžœž˜$š
œ˜Kš
œ8˜8Kš
žœžœ
žœ
žœ
žœ˜"Kš
œ(˜(šžœž˜Kšœžœ
˜K™kš
œ˜Kš
œ!˜!—Kšžœ
˜—Kš
œ˜K˜—Kšžœ
˜—Kšžœ
žœ ˜*Kš
œ˜K˜—K™zK˜šกœž
œ(žœžœ˜mKšžœžœ
žœ
žœ
˜šžœ5žœžœ
ž˜HKšžœžœ
žœ
˜(Kšžœ
˜—K˜K˜—šก
œžœ
žœ(žœ˜`šœžœ˜2Kšœ
žœžœžœ˜I—Kšœžœ"˜?K˜K˜—šกœž
œ2žœ˜ZKšžœžœ
žœ
žœ
˜šžœžœ
žœžœ
žœ(ž˜_Kšœž˜—š
ž˜šžœ5žœ
žœ
ž˜Mšžœžœ˜ Kšœ	žœ :˜IKšžœ
˜K˜—Kšžœ
˜——K˜K˜—šก
œž
œžœ˜@Kšžœ
žœžœ
˜Kšžœžœ
žœ
žœ
˜Kšž	œ˜K˜—K˜šกœž
œžœ˜7Kšžœ
žœžœ
˜Kšžœžœ
žœ
žœ
˜Kšžœ˜K˜—K˜šกœžœBžœ˜iJš
œ˜Kšœžœžœžœ˜lJšžœžœ
žœ
žœ
˜Jšžœ9˜@š
ž˜Kš
œ%˜%Kš	žœžœ
žœ
žœ ˜;šžœž˜šœžœž˜'Kšœ-žœ
˜2Kšžœžœ ˜—šœžœž˜%Kšœ!žœ
˜&Kšžœžœ ˜(—šœ
žœž˜&Kšœžœ
˜Kšžœžœ "˜4—Kšžœžœ
˜—Kš
œ
˜
Kšžœ
˜—K˜K˜—šก
œžœ
žœžœ˜KKšžœ
žœ˜ Jš
œ)˜)Kš
žœžœ
žœ œ
žœ˜JK˜——™.šก	œžœžœžœ˜Sšžœžœ
ž˜Jšœ	žœ4˜C—Kšžœžœ
žœ˜(K˜K˜—šกœžœ˜Kš	œ+žœ
žœžœ
žœ
˜HKšžœžœ˜)Jšœžœ
˜J˜Jš
œM˜Mšžœ
žœ˜Jš
œa˜aJšžœ
žœ˜J˜—Kš
œ˜šžœžœ
žœ˜Kšœ	žœ˜%Jš
œF˜FJ˜J˜—Jšžœžœ
žœ ˜6Kšžœ$žœ	žœ
˜7K˜—J˜šกœžœžœžœžœžœ˜cJš
œ˜Jš
œ$˜$Jšœžœžœ
žœ
žœ
žœ˜GJšžœžœžœ
žœžœ
žœ
žœ˜Tš
œ ˜ Jš
œW˜W—Jšžœ
žœ
žœ
žœ˜"Jš
œ)˜)Jšžœžœ
žœA˜SJšžœžœ
žœ
žœ˜#Jšœžœ
˜š
œw˜wšœžœ˜Kšœžœ˜Kš
œB˜BKšžœ˜——Jšžœ˜J˜J˜—šกœžœ
žœ
žœ˜;Jšžœ
žœ˜+——™Kš
œH˜H—K˜Kšžœ
˜™*Kšœฯr›
™ง
—™*Kšœฅด
™ภ
—™+KšœฅO™[—™*Kšœฅ—
™ฃ
—™,Kšœฅ2™>—™-KšœฅO™[—™-Kšœฅ:™F—™*Kšœฅฎ™บ—™*Kšœฅ
™—™*Kšœฅ
™›
—™*KšœฅW™c—™*Kšœฅ™%—™+Kšœฅ™—š
œ2™2Kš
œ]™]Kšœฅ'™3—š
œ2™2Kšœฅข
™ฎ
—š
œ3™3Kšœฅ3™?—K™™(K™xKšœฅฮ
™ฺ
—™3Kšœฅ8™D—K™K™—…—8>g"