Prepares the given database for service. The name of the entries database is derived from the script database name by adding "Entries" after the base name.

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

sDB, eDB: ROPE;

cp: FS.ComponentPositions;

IF dbName = NIL THEN RETURN[NIL];

[sDB, cp] ← FS.ExpandName[dbName];

IF cp.ext.length = 0 THEN

eDB ← Rope.Replace[base: sDB, start: cp.base.start+cp.base.length, len: 0, with: "Entries"];

handle ← NEW[HandleRec ← [scriptDBName: sDB, scriptEntriesDBName: eDB]];

handle.scriptDB ← LoganBerry.Open[dbName: handle.scriptDBName];

handle.scriptEntriesDB ← LoganBerry.Open[dbName: handle.scriptEntriesDBName];

};

Returns the descriptor of the given script.

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

lbe: LBEntry ← NIL;

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

lbe ← LoganBerry.ReadEntry[db: handle.scriptDB, key: $SID, value: sid].entry;

script ← LBEntryToScriptDesc[lbe];

};

Writes the script descriptor into the LoganBerry database.

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

lbe: LoganBerry.Entry ← ScriptDescToLBEntry[script];

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

LoganBerry.WriteEntry[db: handle.scriptDB, entry: lbe];

};

Deletes the given script (regardless of what entries may exist).

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

LoganBerry.DeleteEntry[db: handle.scriptDB, key: $SID, value: sid];

};

Find all scripts that start in the given file. This includes all scripts with an internal first entry whose create date is not later than the file and all scripts with an external first entry whose create date is equal to the file.

For this to work as written, filenames should not have version parts!

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

continue: BOOLEAN ← TRUE;

cursor: LoganBerry.Cursor;

lbe: LoganBerry.Entry;

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

scriptList ← NIL;

cursor ← LoganBerry.GenerateEntries[db: handle.scriptDB, key: $StartingFile, start: file.name];

WHILE (lbe ← LoganBerry.NextEntry[cursor: cursor]) # NIL DO

LoganBerry.EndGenerate[cursor: cursor];

};

Returns the descriptor of the given script.

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

lbe: LBEntry ← NIL;

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

lbe ← LoganBerry.ReadEntry[db: handle.scriptEntryDB, key: $EID, value: eid].entry;

scriptEntry ← LBEntryToScriptEntryDesc[lbe];

};

Writes the script descriptor into the LoganBerry database.

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

lbe: LoganBerry.Entry ← ScriptEntryDescToLBEntry[scriptEntry];

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

LoganBerry.WriteEntry[db: handle.scriptEntryDB, entry: lbe];

};

Deletes the given script entry (regardless of what entries may exist).

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

LoganBerry.DeleteEntry[db: handle.scriptEntryDB, key: $EID, value: eid];

};

Converts a script descriptor to a list of (attribute, value) pairs suitable for storing in the db.

lbe ← LIST[NEW[Attribute ← [$StartingFiledate, Convert.RopeFromTime[from: s.startingFile.createTime, end: seconds]]]];

lbe ← CONS[NEW[Attribute ← [$StartingFilename, s.startingFile.name], list]];

lbe ← CONS[NEW[Attribute ← [$NumEntries, Convert.RopeFromInt[s.numEntries]], list]];

lbe ← CONS[NEW[Attribute ← [$Creation, Convert.RopeFromTime[from: s.sCreateInfo.creation, end: seconds]], list]];

lbe ← CONS[NEW[Attribute ← [$Creator, s.sCreateInfo.creator], list]];

lbe ← CONS[NEW[Attribute ← [$Desc, s.sDesc], list]];

lbe ← CONS[NEW[Attribute ← [$Name, s.sName], list]];

lbe ← CONS[NEW[Attribute ← [$FirstEntry, s.firstEntry.eid], list]];

lbe ← CONS[NEW[Attribute ← [$SID, s.sid], list]];

};

Converts a list of (attribute, value) pairs from the db into a script descriptor.

s ← NEW[defaultScript];

WHILE lbe#NIL DO

};

Converts a script entry descriptor to a list of (attribute, value) pairs suitable for storing in the db.

lbe ← LIST[NEW[Attribute ← [$Creation, Convert.RopeFromTime[from: se.sCreateInfo.creation, end: seconds]], list]];

lbe ← CONS[NEW[Attribute ← [$Creator, se.sCreateInfo.creator], list]];

lbe ← CONS[NEW[Attribute ← [$Desc, se.eDesc], list]];

lbe ← CONS[NEW[Attribute ← [$Name, se.eName], list]];

lbe ← CONS[NEW[Attribute ← [$NextEntries, FlattenNextEntries[se.nextEntries]], list]];

lbe ← CONS[NEW[Attribute ← [$PauseAfter, Convert.RopeFromInt[se.pauseAfter]], list]];

lbe ← CONS[NEW[Attribute ← [$PauseBefore, Convert.RopeFromInt[se.pauseBefore]], list]];

lbe ← CONS[NEW[Attribute ← [$Action, se.action], list]];

lbe ← CONS[NEW[Attribute ← [$CharsLen, Convert.RopeFromInt[se.chars.len]], list]];

lbe ← CONS[NEW[Attribute ← [$CharsStart, Convert.RopeFromInt[se.chars.start]], list]];

lbe ← CONS[NEW[Attribute ← [$Class, Convert.RopeFromAtom[se.class]], list]];

lbe ← CONS[NEW[Attribute ← [$Internal, Convert.RopeFromBool[se.internal]], list]];

lbe ← CONS[NEW[Attribute ← [$Filedate, Convert.RopeFromTime[from: se.file.createTime, end: seconds]]]];

lbe ← CONS[NEW[Attribute ← [$Filename, se.file.name], list]];

lbe ← CONS[NEW[Attribute ← [$SID, se.scriptHeader.sid], list]];

lbe ← CONS[NEW[Attribute ← [$EID, se.eid], list]];

};

Converts a list of (attribute, value) pairs from the db into a script entry descriptor.

se ← NEW[defaultScriptEntry];

WHILE lbe#NIL DO

};

WHILE nextEntryList#NIL DO

};

nextEntryList ← NEW[];

};

Returns the tune list representing the structure of the voice rope.

IF entry = NIL THEN RETURN[NIL];

UNTIL entry.first.type = $TID DO

struct ← entry;

};

Returns the tune list representing the structure of the voice rope interval. Warning: this operation modifies the original list!

tuneInterval: Thrush.VoiceInterval; -- the current tune's interval

prevSamples: INT; -- number of samples in entry excluding the current tune interval

samples: INT; -- number of samples in entry including the current tune interval

intervalMustChange: BOOLEAN ← FALSE;

IF list = NIL THEN RETURN[NIL];

IF interval.length = -1 THEN interval.length ← LAST[INT];

prevSamples ← 0;

tuneInterval ← UnmarshalInterval[list.rest.rest.first.value];

samples ← tuneInterval.length;

UNTIL samples > interval.start DO

at this point: prevSamples <= interval.start < samples

new ← list;

IF prevSamples # interval.start THEN { -- don't want first part of existing interval

Note: there's a possibility that interval.start + interval.length could cause an integer overflow; do I want to pay the cost to check for this?

IF (interval.length # LAST[INT]) AND (samples >= interval.start + interval.length) THEN { -- interval contained within a single tune interval

IF intervalMustChange THEN

IF (interval.length = LAST[INT]) OR (samples >= interval.start + interval.length) THEN -- no need to go on

UNTIL samples >= interval.start + interval.length DO

at this point: prevSamples <= interval.start + interval.length <= samples

IF samples # interval.start + interval.length THEN { -- want only first part of tune interval

list.rest.rest.rest ← NIL; -- truncate list since we have has much as we need

RETURN[new];

};

entry: LoganBerry.Entry;

entry ← info.struct;

entry ← CONS[[$Length, Convert.RopeFromInt[info.length]], entry];

the creator field is not really needed, but is included for compatibility with existing databases

entry ← CONS[[$Creator, info.creator], entry];

entry ← CONS[[$VRID, info.vrID], entry];

RETURN[entry];

};

newID ← BadUniqueID[];

header.first.value ← newID;

};

Returns the information associated with a voice rope header.

list: LoganBerry.Entry ← header;

IF header = NIL THEN RETURN;

info.vrID ← list.first.value;

list ← list.rest;

ignore creator field

list ← list.rest;

info.length ← Convert.IntFromRope[list.first.value];

[info.creator, info.timestamp] ← ParseUniqueID[info.vrID];

info.struct ← list.rest;

};

Adds an entry to the interest database if a similar entry does not already exist.

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

entry: LoganBerry.Entry ← NIL;

oldEntry: LoganBerry.Entry;

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

oldEntry ← ReadInterest[handle, interest.vrID, interest.class, interest.refID];

interest.interestID ← IF oldEntry = NIL THEN GenerateUniqueID[] ELSE oldEntry.first.value;

entry ← PackInterest[interest];

LoganBerry.WriteEntry[db: handle.voiceInterestDB, entry: entry, replace: oldEntry # NIL ! LoganBerry.Error => IF ec = $ValueNotUnique AND oldEntry = NIL THEN {interest.interestID ← ReplaceInterestID[entry]; RETRY}];

};

Removes an entry from the interest database.

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

entry: LoganBerry.Entry;

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

entry ← ReadInterest[handle, interest.vrID, interest.class, interest.refID];

IF entry = NIL THEN RETURN;

LoganBerry.DeleteEntry[db: handle.voiceInterestDB, key: $IID, value: entry.first.value];

};

Searches for an entry with matching ropeID, class, and refID.

info: InterestInfo;

cursor: LoganBerry.Cursor ← LoganBerry.GenerateEntries[db: handle.voiceInterestDB, key: $RefID, start: refID, end: refID];

entry ← LoganBerry.NextEntry[cursor: cursor];

UNTIL entry = NIL DO

LoganBerry.EndGenerate[cursor: cursor];

};

Returns an interest with the given class and refID, if one exists.

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

interest ← ReadInterest[handle: handle, class: class, refID: refID];

};

Returns an interest for the voice rope, if one exists.

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

interest ← LoganBerry.ReadEntry[db: handle.voiceInterestDB, key: $VRID, value: ropeID].entry;

};

Calls the enumeration procedure for every interest of the given class. Stops when proc returns FALSE or the end of the database is encountered.

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

continue: BOOLEAN ← TRUE;

entry: LoganBerry.Entry;

info: InterestInfo;

cursor: LoganBerry.Cursor;

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

IF proc = NIL THEN Error[$NoProc, "No procedure passed to EnumerateInterestClass"];

cursor ← LoganBerry.GenerateEntries[db: handle.voiceInterestDB, key: $Class, start: class, end: class];

entry ← LoganBerry.NextEntry[cursor: cursor];

UNTIL entry = NIL OR NOT continue DO

LoganBerry.EndGenerate[cursor: cursor];

};

interest ← NIL;

IF info.data # NIL THEN

interest ← CONS[[$RefID, info.refID], interest];

interest ← CONS[[$Class, info.class], interest];

interest ← CONS[[$VRID, info.vrID], interest];

interest ← CONS[[$IID, info.interestID], interest];

};

newID ← BadUniqueID[];

interest.first.value ← newID;

};

list: LoganBerry.Entry ← interest;

IF interest = NIL THEN RETURN;

info.interestID ← list.first.value;

list ← list.rest;

info.vrID ← list.first.value;

list ← list.rest;

info.class ← list.first.value;

list ← list.rest;

info.refID ← list.first.value;

list ← list.rest;

IF list # NIL THEN

[info.creator, info.timestamp] ← ParseUniqueID[info.interestID];

};

cardKey: LONG POINTER TO ARRAY[0..2) OF LONG CARDINAL=LOOPHOLE [LONG[@key]];

r ← IO.PutFR["%bB %bB", IO.card[cardKey[0]], IO.card[cardKey[1]]];

};

cardKey: LONG POINTER TO ARRAY[0..2) OF LONG CARDINAL=LOOPHOLE[LONG[@key]];

keyStream: IO.STREAM ← IO.RIS[r];

cardKey[0] ← IO.GetCard[keyStream];

cardKey[1] ← IO.GetCard[keyStream];

};

Writes a start and length field into a rope.

r ← IO.PutFR["%g %g", IO.int[interval.start], IO.int[interval.length]];

};

Parses the input rope into a start and length field.

s: IO.STREAM ← IO.RIS[r];

interval.start ← IO.GetInt[s];

interval.length ← IO.GetInt[s];

};

timestamp: INT ← MAX[counter, BasicTime.Period[BasicTime.earliestGMT, BasicTime.Now[]]];

id ← IO.PutFR["%g#%g", IO.rope[processorID], IO.int[timestamp]];

counter ← counter + 1;

};

seconds: INT;

i: INT ← Rope.Find[s1: id, s2: "#"];

creatingProcessor ← Rope.Substr[base: id, start: 0, len: i];

seconds ← Convert.IntFromRope[Rope.Substr[base: id, start: i+1]];

timestamp ← BasicTime.Update[BasicTime.earliestGMT, seconds];

};

userName ← UserCredentials.Get[].name;

};

counter ← BasicTime.Period[BasicTime.earliestGMT, BasicTime.Now[]];

kicks ← 0;

processorID ← ThisMachine.ProcessorID[$Hex];

counter ← CheckCounter[counter, processorID];

userName ← UserCredentials.Get[].name;

UserCredentials.RegisterForChange[NewUser];

};

This routine should check pid#tentativeCounter in the scriptDB and the scriptEntriesDB to make sure that all greater UIDs have a different pid. If not, they should return a new counter that satisfies that property. Very unlikely to be needed.

};