FinchSmartsImpl.mesa
Copyright © 1984, 1986 by Xerox Corporation. All rights reserved.
Last Edited by: Swinehart, June 1, 1986 7:50:15 pm PDT
Polle Zellweger (PTZ) October 24, 1985 4:55:57 pm PDT
DIRECTORY
Commander USING [ CommandProc, Register ],
FinchSmarts,
IO,
LarkFeepRpcControl USING [ Feep, ImportNewInterface ],
LupineRuntime USING [ BindingError ],
MBQueue USING [ Create, QueueClientAction ],
NamesGV USING [ GVGetAttribute ],
NamesGVImpExp USING [ GVImport, UnGVImport ],
NamesRPC USING [ StartConversation ],
Nice,
PrincOpsUtils USING [ IsBound ],
Process USING [ SecondsToTicks, SetTimeout, Ticks ],
RefID USING [ ID ],
RefQ USING [ Dequeue, Enqueue, Map, MapType, Queue ],
Rope,
RPC USING [ AuthenticateFailed, CallFailed, EncryptionKey, ImportFailed, VersionRange ],
ThParty USING [ Advance, Alert, ConversationInfo, CreateConversation, Deregister, Enable, GetConversationInfo, GetParty, GetPartyFromNumber, GetPartyInfo, LookupServiceInterface, Register ],
ThPartyRpcControl,
Thrush
USING[
ActionReport, ConversationID, ConvEvent, Credentials, NB, none, nullConvID, nullID, PartyID, Reason, ROPE, SHHH, SmartsID, StateInConv, unencrypted ],
ThSmarts,
ThSmartsRpcControl,
ThVersions USING [ GetThrushVR, FinchVersion, FinchVR ],
UserProfile USING [ Token],
VoiceUtils USING [ CurrentPasskey, CurrentRName, InstanceFromNetAddress, MakeRName, NetAddress, NetAddressFromRope, OwnNetAddress, Problem, ProblemFR, Report ]
;
FinchSmartsImpl:
CEDAR
MONITOR
IMPORTS Commander, IO, FinchSmarts, LarkFeepRpcControl, LupineRuntime, MBQueue, NamesGV, NamesGVImpExp, NamesRPC, Nice, PrincOpsUtils, Process, RefQ, Rope, RPC, ThParty, ThPartyRpcControl, ThSmartsRpcControl, ThVersions, UserProfile, VoiceUtils
EXPORTS FinchSmarts, ThSmarts = {
OPEN IO;
Declarations
ConvDesc: TYPE = FinchSmarts.ConvDesc;
ConversationID:
TYPE = Thrush.ConversationID;
nullConvID: ConversationID = Thrush.nullConvID;
FinchInfo: TYPE = FinchSmarts.FinchInfo;
NB: TYPE = Thrush.NB;
none: SHHH = Thrush.none;
nullID: RefID.ID = Thrush.nullID;
PartyID: TYPE = Thrush.PartyID;
ROPE: TYPE = Thrush.ROPE;
SHHH: TYPE = Thrush.SHHH;
SmartsID: TYPE = Thrush.SmartsID;
StateInConv: TYPE = Thrush.StateInConv;
PD:
TYPE =
RECORD [
doReports: BOOL←FALSE,
doNice: BOOL←FALSE,
timeoutNoAction: INTEGER ← 30,
timeoutJayConnect: INTEGER ← 1,
noJayTicks: Process.Ticks ← Process.SecondsToTicks[1],
encryptionRequested: BOOLEAN←TRUE,
interfacesAreImported: BOOLEAN←FALSE,
smartsIsExported: BOOLEAN←FALSE,
waitsForConnect: NAT𡤆,
queueIt: BOOL←FALSE,
finchOn: BOOLEAN←FALSE,
maxProseLength: INT�
];
info: FinchInfo;
pd: REF PD ← NEW[PD←[]];
Report:
PROC[what:
ROPE] = {
IF NOT pd.doReports THEN RETURN;
VoiceUtils.Report[what, $Finch];
};
BeNice:
PROC[r:
REF, d:
INT] = {
IF NOT pd.doNice THEN RETURN;
Nice.BeNice[r, d, $Finch, NIL];
};
Supervision
Progress:
PUBLIC
ENTRY
PROC[
shh: SHHH,
convEvent: Thrush.ConvEvent
] = {
ENABLE UNWIND => NULL; -- RestoreInvariant;
Some party has changed state in a conversation we know about (or should).
Two cases:
Our party has changed state in a conversation, whether or not we're going to deal with it (at present, LarkSmarts makes all such decisions)
Another party changed state in a conversation we know about (at present, we don't need to know that; again, LarkSmarts does all the work.) That case is filtered out in Progress, above.
It is our duty to obtain all relevant information about the call when the information becomes available, and to notify any Finch Clients.
IF convEvent.self.partyID = convEvent.other.partyID THEN [] ← NoteNewState[convEvent];
};
Substitution:
PUBLIC
ENTRY
PROC[
shh: SHHH,
convEvent: Thrush.ConvEvent,
oldPartyID: Thrush.PartyID,
newPartyID: Thrush.PartyID
] = {
ENABLE UNWIND => NULL; -- RestoreInvariant;
One party has replaced another (they were or are now in a poacher/poachee relationship) in this conversation, so we need to update our information about the conversation. Same as Progress, except that we clear any indication that we know anything about the present state before noting the new state.
If this notice indicates that our own party is the oldPartyID, we should find a way to inform our ReportConversationState clients that we are no longer involved in this conversation. We should also pull the conv. from our active list. This happens when the same user logs in and runs Finch somewhere else.
cDesc: ConvDesc = GetConv[convEvent.self.convID, FALSE];
IF cDesc#NIL THEN cDesc.numParties ← 0; -- This will force the information update.
[] ← NoteNewState[ convEvent ];
};
ReportAction:
PUBLIC
ENTRY
PROC[
shh: SHHH,
report: Thrush.ActionReport
] = {
shh ← shh; shh ← shh; -- a place to stand during debugging
};
Client Functions
CallInfo: TYPE = REF CallInfoBody; -- needed because MBQueue requires a REF
CallInfoBody:
TYPE =
RECORD [
convID: Thrush.ConversationID,
calledPartyID: Thrush.PartyID←nullID,
reason: Thrush.Reason←NIL,
comment: ROPE←NIL
];
DisconnectCall:
PUBLIC
ENTRY
PROC[
convID: Thrush.ConversationID,
reason: Thrush.Reason ← $terminating,
comment: ROPE←NIL] = {
ENABLE UNWIND => NULL; -- RestoreInvariant;
info.requests.QueueClientAction[QdDisconnect,
NEW[CallInfoBody ← [convID: convID, reason: reason, comment: comment]]];
};
QdDisconnect:
ENTRY
PROC[r:
REF] = {
ENABLE UNWIND => NULL; -- RestoreInvariant;
callInfo: CallInfo = NARROW[r];
cDesc: ConvDesc; state: StateInConv;
IF NOT(([,cDesc, state]𡤏inchOn[callInfo.convID]).on) THEN RETURN;
SELECT state
FROM
$idle, $neverWas => {
info.ReportConversationState[$convNotActive, NIL, "No conversation to disconnect"];
RETURN;
};
ENDCASE;
[]←Request[cDesc, $idle, callInfo.reason, callInfo.comment];
};
AnswerCall:
PUBLIC
ENTRY
PROC[convID: Thrush.ConversationID] = {
ENABLE UNWIND => NULL; -- RestoreInvariant;
info.requests.QueueClientAction[QdAnswerCall, NEW[CallInfoBody ← [convID: convID]]];
};
QdAnswerCall:
ENTRY
PROC[r:
REF] = {
ENABLE UNWIND => NULL; -- RestoreInvariant;
callInfo: CallInfo = NARROW[r];
cDesc: ConvDesc; state: StateInConv;
IF NOT(([,cDesc, state]𡤏inchOn[callInfo.convID]).on) THEN RETURN;
SELECT state
FROM
$ringing, $notified => NULL;
ENDCASE=>RETURN;
[]←Request[cDesc, $active];
};
PlaceCall:
PUBLIC
ENTRY
PROC [
convID: Thrush.ConversationID←nullConvID,
rName: ROPE, -- rName or description
number: ROPE, -- telephone number, if present
useNumber: BOOL←FALSE
] = {
ENABLE UNWIND => NULL; -- RestoreInvariant;
calledPartyID: PartyID;
nb: NB;
reason: Thrush.Reason ← $notFound;
comment: Rope.ROPE ← NIL;
IF NOT (FinchOn[].on) THEN RETURN;
IF ~useNumber
THEN {
[nb, calledPartyID] ←ThParty.GetParty[shh:info.shh, partyID:info.partyID, rName:rName];
SELECT nb FROM $noSuchParty2, $noIdentSupplied => useNumber ← TRUE; ENDCASE;
};
IF useNumber
AND number.Length[]>0
THEN
[nb, calledPartyID] ← ThParty.GetPartyFromNumber[
shh: info.shh, partyID: info.partyID, phoneNumber: number, description: rName];
SELECT nb
FROM
$success => reason ← NIL; -- reason: NIL, comment: NIL
$noSuchParty2 => NULL; -- reason: $notFound, comment: NIL
$narcissism => comment ← "Attempt to call self rejected on philosophical grounds";
ENDCASE => { info.ReportConversationState[nb, NIL, NIL]; RETURN; };
info.requests.QueueClientAction[QdPlaceCall,
NEW[CallInfoBody ← [convID: convID, calledPartyID: calledPartyID, reason: reason, comment: comment]]];
};
QdPlaceCall:
ENTRY
PROC [r:
REF] = {
ENABLE {
UNWIND=>NULL; -- RestoreInvariant;
RPC.CallFailed => { UninitFinchSmarts["Communication Failure"]; CONTINUE; };
};
callInfo: CallInfo = NARROW[r];
IF NOT (FinchOn[].on) THEN RETURN;
[--cDesc--]𡤌onnect[callInfo.calledPartyID, callInfo.convID, callInfo.reason, callInfo.comment];
};
Feep:
PUBLIC
ENTRY
PROC[convID: ConversationID, feepString:
ROPE] = {
cDesc: ConvDesc;
nb: Thrush.NB←$success;
state: StateInConv;
IF NOT(([,cDesc, state]𡤏inchOn[convID]).on) OR state#$active THEN nb ← $convNotActive;
IF nb=$success
AND cDesc.feepInterface=
NIL
THEN {
IF cDesc.numParties>1
THEN [nb, cDesc.feepInterfaceSpec] ← ThParty.LookupServiceInterface[
info.shh, cDesc.situation.self, cDesc.partyInfo[1].partyID, "LarkFeep"]
ELSE nb←$noFeepingParty;
IF nb=$success
THEN
cDesc.feepInterface ← LarkFeepRpcControl.ImportNewInterface[
interfaceName: cDesc.feepInterfaceSpec.interfaceName,
hostHint: cDesc.feepInterfaceSpec.hostHint!RPC.ImportFailed => CONTINUE
];
};
IF nb=$success
THEN nb ← LarkFeepRpcControl.Feep[
interface: cDesc.feepInterface, shhh: info.shh,
serviceID: cDesc.feepInterfaceSpec.serviceID,
convID: cDesc.situation.self.convID, requestingParty: cDesc.situation.self.partyID,
number: feepString, noisy: TRUE, on: 100, off: 80
];
IF nb # $success THEN VoiceUtils.Report["Sorry, was not able to `feep'.", $Finch];
};
Utilities
GetConv:
PUBLIC
PROC[convID: ConversationID, createOK:
BOOL←
FALSE]
RETURNS [ cDesc: ConvDesc←NIL ] = --INLINE-- {
IsConv: RefQ.MapType = {
cDesc ← NARROW[subqueue.first];
IF cDesc.situation.self.convID = convID THEN RETURN[TRUE];
};
IF convID#nullConvID AND RefQ.Map[info.conversations, IsConv] THEN RETURN;
IF ~createOK THEN RETURN;
New conversation
cDesc ←
NEW[FinchSmarts.ConvDescBody←[
situation: [ self: [ convID: convID, smartsID: info.smartsID, partyID: info.partyID ]]]];
info.conversations ← RefQ.Enqueue[info.conversations, cDesc];
};
FinchOn:
INTERNAL
PROC[convID: ConversationID←nullConvID]
RETURNS [
on: BOOL←FALSE, cDesc: ConvDesc←NIL, state: StateInConv←$idle] = {
IF ~pd.finchOn
OR info=
NIL
THEN {
VoiceUtils.Report["Your Finch is not running", $Finch]; RETURN; };
on←TRUE;
IF convID=nullConvID THEN RETURN;
cDesc ← GetConv[convID, FALSE];
state�sc.situation.self.state;
};
NoteNewState:
INTERNAL
PROC[convEvent: Thrush.ConvEvent]
RETURNS[cDesc: ConvDesc]= {
cInfo: ThParty.ConversationInfo;
nb: NB;
cDesc ← GetConv[convEvent.self.convID, TRUE];
cDesc.situation ← convEvent^;
[nb, cInfo] ← ThParty.GetConversationInfo[shh: info.shh, convID: convEvent.self.convID];
Now gather up additional information that we might not know yet:
Who started this?
Who the other party(s) is (are)
SELECT
TRUE
FROM
nb # $success => Problem["Can't obtain conversation information"];
cDesc.numParties#cInfo.numParties, cDesc.numActive#cInfo.numActive,
cDesc.numIdle#cInfo.numIdle => {
State information guaranteed correct only as of last time one of these numbers changed.
cDesc.subject ← cInfo.subject;
cDesc.startTime ← cInfo.startTime;
cDesc.numParties ← cInfo.numParties;
cDesc.numActive ← cInfo.numActive;
cDesc.numIdle ← cInfo.numIdle;
[nb, cDesc.partyInfo] ←
ThParty.GetPartyInfo[shh: info.shh, credentials: cDesc.situation.self,
nameReq: $description, allParties: TRUE];
IF nb#$success THEN Problem["Can't obtain conversation information"]
ELSE
IF cDesc.numParties>=1
THEN
cDesc.whoOriginated ←
IF cDesc.partyInfo[0].partyID=cInfo.originator THEN $us ELSE $them;
};
ENDCASE;
SELECT cDesc.situation.self.state
FROM
$idle, $neverWas => info.conversations ← RefQ.Dequeue[info.conversations, cDesc];
ENDCASE => cDesc.ultimateState ← cDesc.situation.self.state;
If we've been called due to a Substitution that's kicking us out (cf Subst.), we should find a way to inform our ReportConversationState clients that we are no longer involved in this conversation. We should also do a Dequeue as above.
info.ReportConversationState[$success, cDesc, NIL];
};
Request:
INTERNAL
PROC[
cDesc: ConvDesc,
state: StateInConv,
reason: Thrush.Reason←NIL,
comment: ROPE←NIL
]
RETURNS [nb: NB] = {
DO
convEvent: Thrush.ConvEvent;
reportToAll:
BOOL =
SELECT state
FROM
$idle, $active, $inactive, $ringing => TRUE, ENDCASE=>FALSE;
[nb, convEvent] ←
ThParty.Advance[shhh: info.shh, credentials: cDesc.situation.self, state: state,
reportToAll: reportToAll, reason: reason, comment: comment];
SELECT nb
FROM
$success => []←NoteNewState[convEvent];
$stateMismatch => {
cDesc←NoteNewState[convEvent];
IF state=$idle AND cDesc.situation.self.state # $idle THEN LOOP;
};
ENDCASE =>
-- Some cases are fatal, requiring re-registration! --
info.ReportConversationState[nb, cDesc, "Telephone server action failed"];
Real confused about Problem (typeout only) reporting vs. client reporting. The responsibilities are unconvincingly distributed among Smarts and client.
EXIT;
ENDLOOP;
};
Connect:
INTERNAL
PROC [calledPartyID: PartyID, convID: ConversationID←nullConvID, reason: Thrush.Reason ←
NIL, comment:
ROPE←
NIL]
RETURNS [ cDesc: ConvDesc ] = {
If there's a reason, the connect request's only purpose is to record an error condition, audibly as well as visually. This requires the creation of a conversation, then its immediate termination.
state: StateInConv;
newState: StateInConv =IF reason=NIL THEN $initiating ELSE $failed;
nb: NB;
convEvent: Thrush.ConvEvent;
[,cDesc, state]𡤏inchOn[convID];
SELECT state
FROM
$idle => {
[nb, convEvent] ← ThParty.CreateConversation[
shhh: info.shh,
credentials: [partyID: info.partyID, smartsID: info.smartsID],
state: newState,
reason: reason,
comment: comment
];
IF nb = $success THEN cDesc ← NoteNewState[convEvent];
};
$reserved, $parsing => nb ← Request[cDesc, newState, reason, comment];
ENDCASE => {
info.ReportConversationState[$convStillActive, NIL, "Conversation already in progress"];
RETURN;
};
IF nb # $success THEN { -- Do something interesting -- ERROR; };
IF newState=$failed THEN RETURN; -- not establishing a two-party conversation.
cDesc.originatorRecorded ← TRUE;
nb←ThParty.Alert[shhh: info.shh,
credentials: cDesc.situation.self, calledPartyID: calledPartyID];
SELECT nb
FROM
$success => NULL;
$stateMismatch => {
[]←Request[cDesc, $failed, $error, "Conversation already in progress"];
Some smarts don't do this. They probably should.
RETURN;
};
ENDCASE => {
-- Do something interesting — see other smarts for more confusion -- ERROR; };
};
WaitForActive:
INTERNAL
PROC[cDesc: ConvDesc] = {
For use in Recording, and so on, where client needs to wait for setup.
FOR i:
NAT
IN [0..pd.waitsForConnect)
DO
TRUSTED { Process.SetTimeout[@info.stateChange, pd.noJayTicks]; };
WAIT info.stateChange; -- <<The supervisor condition vbl; will this work?>>
SELECT cDesc.situation.self.state
FROM
$active => RETURN;
$idle, $neverWas, $failed => EXIT;
ENDCASE;
ENDLOOP;
This isn't queued; does it have to be?
[]←Request[cDesc, $failed, $error, "Finch failed to connect to voice service."];
};
Problem:
PROC[remark:
ROPE←
NIL, nb:
NB←
NIL] = {
IF nb=
NIL
THEN VoiceUtils.Problem[remark, $Finch]
ELSE VoiceUtils.ProblemFR["%g, reason: %g", $Finch, NIL, rope[remark], atom[nb]];
};
Registration
InitFinchSmarts:
PUBLIC
PROC [
thrushInstance: Thrush.ROPE←NIL,
ReportSystemState: PROC[ on: BOOL ],
ReportConversationState: PROC[ nb: NB, cDesc: ConvDesc, remark: Rope.ROPE ]
] = {
problem: ROPE←NIL; nb: NB; {
ENABLE RPC.CallFailed => { problem ← "Communication Failure"; GOTO InitFailed; };
credentials: Thrush.Credentials;
thVR: RPC.VersionRange = ThVersions.GetThrushVR;
problem: Thrush.ROPE ← NIL;
namesGVInstance: Thrush.ROPE←NIL;
hostHint: VoiceUtils.NetAddress;
UninitFinchSmarts[NIL];
info ← NEW[FinchSmarts.FinchInfoBody]; -- Dump any old one!
info.requests ← MBQueue.Create[];
info.conversations ← NIL;
info.ReportSystemState←ReportSystemState;
info.ReportConversationState←ReportConversationState;
thrushInstance ← VoiceUtils.MakeRName[style: rName, name:
IF thrushInstance#NIL THEN thrushInstance
ELSE UserProfile.Token[key: "ThrushClientServerInstance", default: "Strowger.Lark"]];
info.myName ← [
type: "ThSmarts.Lark",
instance: VoiceUtils.InstanceFromNetAddress[netAddress: VoiceUtils.OwnNetAddress[], suffix: "0"],
version: ThVersions.FinchVR];
info.myRName ← VoiceUtils.CurrentRName[];
info.myPassword ← VoiceUtils.CurrentPasskey[];
ThSmartsRpcControl.ExportInterface[
interfaceName: info.myName,
user: info.myRName,
password: info.myPassword];
pd.smartsIsExported←
TRUE;
For the purpose of importing NamesGV, use prior binding of serverInstance if there is one and the server name is the same as before.
namesGVInstance ← UserProfile.Token[key: "NamesGVInstance", default: "Strowger.lark"];
IF ~(PrincOpsUtils.IsBound[
LOOPHOLE[NamesGVImpExp.GVImport]]
AND NamesGVImpExp.GVImport[namesGVInstance])
THEN {
problem ← "Couldn't import Grapevine Package"; GOTO InitFailed; };
info.shh ← IF NOT pd.encryptionRequested THEN Thrush.unencrypted
ELSE NamesRPC.StartConversation [
caller: info.myRName,
callee: thrushInstance,
key: info.myPassword,
level: --<<ECB>>--CBCCheck !
RPC.AuthenticateFailed=> { problem←"Could not authenticate"; GOTO InitFailed}];
hostHint ←
VoiceUtils.NetAddressFromRope[NamesGV.GVGetAttribute[thrushInstance, $connect, NIL]];
ThPartyRpcControl.ImportInterface[
interfaceName: [type: "ThParty.Lark", instance: thrushInstance, version: thVR],
hostHint: hostHint!
RPC.ImportFailed=> {
IF why=wrongVersion THEN
problem ← IO.PutFR["Finch version %d too old; import failed",
card[ThVersions.FinchVersion]];
GOTO InitFailed;
}];
pd.interfacesAreImported←TRUE;
[nb, credentials]←ThParty.Register[
shh: info.shh,
rName: info.myRName,
type: $individual,
interface: info.myName,
properties: [$controller, VoiceUtils.OwnNetAddress[]]
];
IF nb=$success THEN nb ← ThParty.Enable[shh: info.shh, smartsID: credentials.smartsID];
IF nb#$success
THEN {
problem←"Can't register with server"; GOTO InitFailed; };
info.smartsID ← credentials.smartsID;
info.partyID ← credentials.partyID;
ThParty.ConversationsForParty[shh: info.shh, partyID: partyID];
pd.finchOn←TRUE;
info.ReportSystemState[pd.finchOn];
EXITS
InitFailed => UninitFinchSmarts[problem, nb];
};};
UninitFinchSmarts:
PUBLIC
PROC[problem:
ROPE←
NIL, nb:
NB←
NIL] = {
ENABLE RPC.CallFailed => GOTO Failed;
IF problem#NIL THEN Problem[problem, nb];
IF info#
NIL
THEN {
IF pd.finchOn
AND info.partyID#nullID
AND info.smartsID#nullID
THEN
[-- nb --]←ThParty.Deregister[info.shh, info.smartsID!RPC.CallFailed=>CONTINUE];
info.shh←none;
info.ReportSystemState[FALSE];
{
ClearConvs: RefQ.MapType = {
cDesc: ConvDesc=NARROW[subqueue.first];
cDesc.clientData ← NIL;
};
[]←RefQ.Map[info.conversations, ClearConvs];
info.conversations ← NIL;
};
};
pd.finchOn←FALSE;
IF PrincOpsUtils.IsBound[
LOOPHOLE[NamesGVImpExp.UnGVImport]]
THEN
NamesGVImpExp.UnGVImport[];
pd.interfacesAreImported←FALSE;
IF pd.smartsIsExported
THEN
ThSmartsRpcControl.UnexportInterface[!LupineRuntime.BindingError=>CONTINUE];
pd.smartsIsExported←FALSE;
EXITS
Failed => pd.interfacesAreImported ← pd.smartsIsExported ← FALSE;
FinchIsRunning:
PUBLIC
PROC RETURNS [finchIsRunning:
BOOL] = {
RETURN[pd.finchOn]; };
Debugging nonsense
ViewCmd: Commander.CommandProc =
TRUSTED {
Nice.View[pd, "Finch PD"];
};
Commander.Register["VuFinch", ViewCmd, "Program Management variables Finch"];
Commander.Register["FlushNoiseCache", FlushNoiseCacheCmd, "Forget cached SysNoises"];
Registration for use by arms-length systems
FinchSmarts.Register[
NEW[FinchSmarts.ProcsRecord ← [
playbackTune: PlaybackTune,
playNoise: PlayNoise,
recordTune: RecordTune,
stopTune: StopTune,
textToSpeech: TextToSpeech,
registerTranslateProc: RegisterTranslateProc,
stopSpeech: StopSpeech,
finchIsRunning: FinchIsRunning
]]];
}.
Swinehart, May 22, 1985 1:08:51 pm PDT
Changes to GetParty.
changes to: JayConnection
Polle Zellweger (PTZ) July 13, 1985 5:20:26 pm PDT
adding Text-to-Speech server
changes to: DIRECTORY, ProseSpec, ProseSpecs, stopIntervalSpec (was stopSpec), stopProseSpec, Progress, Supervise, DisconnectCall, PlaceCall, StopSpeech, TextToSpeech, InitFinchSmarts, GetConv, ReportProses, EnqueueProses, Complain, Connect, ProseConnection
Swinehart, August 6, 1985 5:43:08 pm PDT
Merge PTZ prose changes
changes to: DIRECTORY, NB, PD, stopIntervalSpec, stopProseSpec, Report, Progress, Supervise, DisconnectCall, PlaceCall, StopTune, NoiseSpec, PlaybackTune, TextToSpeech, InitFinchSmarts, GetConv, ReportProses, CompareIntID, EnqueueProses, Complain, Connect, JayConnection, ProseConnection, RepRet, FinchSmarts
Polle Zellweger (PTZ) August 19, 1985 4:16:40 pm PDT
Meter text in TextToSpeech so as to avoid sending large ropes all at once. Allows speech to begin sooner and flush faster. Also flushing changes.
changes to: FinchInfo, PD, Supervise, TextToSpeech, StopSpeech, ReportProses (comments only)
Polle Zellweger (PTZ) September 3, 1985 6:28:29 pm PDT
Allow registration of defaultTranslateProc.
changes to: Supervise, defaultTranslateProc, RegisterTranslateProc, TextToSpeech, FinchSmarts
Swinehart, September 16, 1985 10:00:59 am PDT
If Finch has never been initialized, info is NIL -- don't let that bother you.
changes to: GetRname, PlayNoise, FinchOn
Polle Zellweger (PTZ) October 22, 1985 5:10:44 pm PDT
changes to: Progress (add prose debugging reports), TextToSpeech (report connection failure), ReportProses (fix debugging reports), JayConnection (report connection failure), ProseConnection (report connection failure)
Polle Zellweger (PTZ) October 24, 1985 4:53:21 pm PDT
Move bluejayConnection and proseConnection from FinchInfo to ConvDesc.
changes to: Supervise, DisconnectCall, InitFinchSmarts, Connect, JayConnection, ProseConnection
Swinehart, October 28, 1985 12:31:20 pm PST
Merge Above changes with other other minor changes (RefQ and the like)
changes to: DIRECTORY, FinchSmartsImpl, Progress, Supervise, DisconnectCall, TextToSpeech, InitFinchSmarts, UninitFinchSmarts, IsConv, GetConv, IsConv (local of GetConvDesc), GetConvDesc, ReportProses, FinchOn, Connect, JayConnection, ProseConnection, PlaybackTune, ClearConvs (local of UninitFinchSmarts)
Swinehart, December 13, 1985 2:52:25 pm PST
Massive change to new Thrush, leaving out proses and intervals for the moment.
changes to: ConversationHandle, FinchInfo, Progress, Supervise, DisconnectCall, AnswerCall, PlaceCall, Apprise, Complain, Connect, Problem, FinchSmarts, Progress, QdProgress
Swinehart, December 17, 1985 10:05:46 am PST
Major revision for new Thrush. Removed all Prose and Bluejay stuff temporarily
changes to: QdProgress, NoteNewState, PutFTime, Connect, Problem, Progress, Other, Supervise
Swinehart, May 19, 1986 12:22:17 pm PDT
Cedar 6.1
changes to: DIRECTORY, SHHH
Swinehart, June 1, 1986 7:48:10 pm PDT
Add ReportAction, eliminate the MBQueueing of ThParty-provoked actions. Others remain, but should go.
changes to: Progress, Substitution, ReportAction