DIRECTORY
Atom USING [GetPName, MakeAtom, GetProp, PutProp],
BasicTime USING [GMT, Period],
BTree USING [Error, GetState],
BTreeSimple USING [DeleteKey, EnumerateRecords, --GetState,-- InternalKey, New, NewPathStk, Open, PathStk, ReadRecord, --ReadValue,-- Relation, SetState, Tree, UpdateRecord, Value, ValueObject],
Convert USING [IntFromRope, RopeFromInt],
DFUtilities USING [--DirectoryItem,-- FileItem, CommentItem, ParseFromStream, ProcessItemProc, RemoveVersionNumber, SyntaxError],
FS USING [Close, Error, ExpandName, FileInfo, OpenFile],
GeneralFS USING [Open, Create, StreamOpen],
IO USING [BreakProc, Close, EndOf, EndOfStream, Error, Flush, GetChar, --GetID,-- GetIndex, GetInt, GetLength, GetLineRope, GetRopeLiteral, GetToken, GetTokenRope, IDProc, PeekChar, PutChar, PutF, RIS, rope, SetIndex, SetLength, SkipWhitespace, STREAM],
RefID USING [Seal, Unseal, Release],
RefTab USING [Create, EachPairAction, Fetch, Insert, Pairs, Ref],
RefText USING [Equal, line, ObtainScratch, ReleaseScratch],
Rope USING [Cat, Compare, Concat, Equal, Find, Index, ROPE, Substr],
SymTab USING [Create, Fetch, Insert, Ref, SeqIndex],
LB,
LoganBerryBackdoor,
LoganBerry,
LoganBerryStructure;

LoganBerryImpl: CEDAR MONITOR LOCKS dbinfo USING dbinfo: OpenDBInfo
IMPORTS Atom, BasicTime, BTree, BTreeSimple, Convert, DFUtilities, FS, GeneralFS, IO, RefText, Rope, RefTab, RefID, SymTab
EXPORTS LB, LoganBerry, LoganBerryBackdoor
~ BEGIN

OPEN LoganBerry, LoganBerryStructure;

ROPE: TYPE = Rope.ROPE;
STREAM: TYPE = IO.STREAM;
Error: PUBLIC ERROR [ec: ErrorCode, explanation: ROPE _ NIL] = CODE;

Open: PUBLIC PROC [conv: Conv _ NIL, dbName: ROPE] RETURNS [db: OpenDB] ~ {
dbinfo: OpenDBInfo _ OpenI[dbName];
IF NOT dbinfo.remoteAccess THEN ERROR Error[$DBNotAvailable, dbinfo.statusMsg];
db _ RefID.Seal[dbinfo];
};

ReadEntry: PUBLIC PROC [conv: Conv _ NIL, db: OpenDB, key: AttributeType, value: AttributeValue] RETURNS [entry: Entry, others: BOOLEAN] ~ {
[entry, others] _ ReadEntryI[GetInfo[db], key, value];
};

EnumerateEntries: PUBLIC PROC [db: OpenDB, key: AttributeType, start: AttributeValue _ NIL, end: AttributeValue _ NIL, proc: EntryProc] RETURNS [] ~ {
EnumerateEntriesI[GetInfo[db], key, start, end, proc];
};

GenerateEntries: PUBLIC PROC [conv: Conv _ NIL, db: OpenDB, key: AttributeType, start: AttributeValue _ NIL, end: AttributeValue _ NIL] RETURNS [cursor: Cursor] ~ {
newCursor: CursorInfo _ GenerateEntriesI[GetInfo[db], key, start, end];
cursor _ RefID.Seal[newCursor];
};

NextEntry: PUBLIC PROC [conv: Conv _ NIL, cursor: Cursor, dir: CursorDirection _ increasing] RETURNS [entry: Entry] ~ {
c: CursorInfo;
WITH RefID.Unseal[cursor] SELECT FROM
ci: CursorInfo => c _ ci;
ENDCASE => c _ NIL;
IF c = NIL THEN ERROR Error[$BadCursor, "Invalid cursor passed to NextEntry."];
entry _ NextEntryI[c.dbinfo, c, dir];
};

EndGenerate: PUBLIC PROC [conv: Conv _ NIL, cursor: Cursor] RETURNS [] ~ {
[] _ RefID.Release[cursor];
};

WriteEntry: PUBLIC PROC [conv: Conv _ NIL, db: OpenDB, entry: Entry, log: LogID _ activityLog, replace: BOOLEAN _ FALSE] RETURNS [] ~ {
WriteEntryI[GetInfo[db], entry, log, replace];
};

DeleteEntry: PUBLIC PROC [conv: Conv _ NIL, db: OpenDB, key: AttributeType, value: AttributeValue] RETURNS [] ~ {
DeleteEntryI[GetInfo[db], key, value];
};

Close: PUBLIC PROC [conv: Conv _ NIL, db: OpenDB] RETURNS [] ~ {
CloseI[GetInfo[db ! Error => IF ec=$DBClosed THEN CONTINUE]];
};

BuildIndices: PUBLIC PROC [conv: Conv _ NIL, db: OpenDB] RETURNS [] ~ {
BuildIndicesI[GetInfo[db]];
};

CompactLogs: PUBLIC PROC [conv: Conv _ NIL, db: OpenDB] RETURNS [] ~ {
CompactLogsI[GetInfo[db]];
};

Describe: PUBLIC PROC [conv: Conv _ NIL, db: OpenDB] RETURNS [info: SchemaInfo] ~ {
info _ DescribeI[GetInfo[db]];
};

GetInfo: PROC [db: OpenDB] RETURNS [OpenDBInfo] ~ INLINE {
ref: REF = RefID.Unseal[db];
IF ref = NIL THEN
ERROR Error[$BadDBHandle, "NIL OpenDB handle."];
WITH ref SELECT FROM
dbinfo: OpenDBInfo => {
IF NOT dbinfo.remoteAccess THEN ERROR Error[$DBNotAvailable, dbinfo.statusMsg];
IF NOT dbinfo.isOpen THEN ERROR Error[$DBClosed, dbinfo.statusMsg];
RETURN[dbinfo];
};
ENDCASE => ERROR Error[$BadDBHandle, "Invalid OpenDB handle."];
};

OpenI: PUBLIC PROC [dbName: ROPE] RETURNS [dbinfo: OpenDBInfo] ~ {
dbinfo _ GetSharedDB[dbName];
IF NOT dbinfo.isOpen THEN
MonitoredOpen[dbinfo];
RETURN[dbinfo];
};

MonitoredOpen: ENTRY PROC [dbinfo: OpenDBInfo] RETURNS [] ~ {
ENABLE UNWIND => NULL;
needToRebuild: BOOLEAN _ FALSE;
IF dbinfo.isOpen THEN RETURN;  -- lost race
IF dbinfo.primaryIndex = NIL THEN
ReadSchema[dbinfo];
OpenLogs[dbinfo.logs];
IF Recover[dbinfo] THEN
needToRebuild _ TRUE;
IF OpenIndices[dbinfo.indices] THEN
needToRebuild _ TRUE;
IF needToRebuild THEN
BuildIndicesWorker[dbinfo];
dbinfo.isOpen _ TRUE;
};

ReadEntryI: PUBLIC ENTRY PROC [dbinfo: OpenDBInfo, key: AttributeType, value: AttributeValue] RETURNS [entry: Entry, others: BOOLEAN] ~ {
ENABLE UNWIND => NULL;
indexEntry: IndexEntry;
index: IndexInfo;
aValue: AttributeValue;
pathSkt: BTreeSimple.PathStk _ BTreeSimple.NewPathStk[];
index _ NARROW[RefTab.Fetch[dbinfo.indices, key].val];
IF index = NIL THEN 
ERROR Error[$NoIndex, Rope.Cat["Index for ",Atom.GetPName[key]," does not exist."]];
[aValue, indexEntry] _ GetIndexEntry[index: index, value: value, pathStk: pathSkt];
IF aValue = NIL THEN RETURN[entry: NIL, others: FALSE]; 
entry _ ReadLogEntry[dbinfo.logs[indexEntry.log].stream, indexEntry.firstByte];
IF index.type = primary THEN
others _ FALSE
ELSE {
aValue _ GetIndexEntry[index: index, value: aValue, valueIsKey: TRUE, relation: greater, pathStk: pathSkt].actual;
others _ Rope.Equal[s1: value, s2: UniqueKeyToValue[aValue], case: FALSE];
};
RETURN[entry, others];
};

SimpleEntryProc: EntryProc = { -- for debugging purposes
cont: BOOLEAN _ TRUE;
RETURN[cont];
};

EnumerateEntriesI: PUBLIC ENTRY PROC [dbinfo: OpenDBInfo, key: AttributeType, start: AttributeValue _ NIL, end: AttributeValue _ NIL, proc: EntryProc] RETURNS [] ~ {
ENABLE UNWIND => NULL;
EntriesInSubrange: PROC [key: BTreeSimple.InternalKey, value: BTreeSimple.Value] RETURNS [continue: BOOLEAN] = {
indexEntry: IndexEntry;
entry: Entry;
IF end # NIL AND Rope.Compare[s1: key, s2: end, case: FALSE] = greater THEN RETURN[continue: FALSE];
TRUSTED {
indexEntry _ LOOPHOLE[@value[0], IndexPtr]^;
};
entry _ ReadLogEntry[dbinfo.logs[indexEntry.log].stream, indexEntry.firstByte];
RETURN[continue: proc[entry]];
};
index: IndexInfo;
index _ NARROW[RefTab.Fetch[dbinfo.indices, key].val];
IF index = NIL THEN 
ERROR Error[$NoIndex, Rope.Cat["Index for ",Atom.GetPName[key]," does not exist."]];
IF index.type = secondary THEN {
IF start # NIL THEN
start _ ValueToSmallKey[start];
IF end # NIL THEN
end _ ValueToLargeKey[end];
};
[] _ BTreeSimple.EnumerateRecords[tree: index.btree, key: start, Proc: EntriesInSubrange !
BTree.Error => ERROR Error[IF reason = closed THEN $DBClosed ELSE $BadIndex, Rope.Cat["Problem enumerating index for ",Atom.GetPName[key],"."]]];
};

GenerateEntriesI: PUBLIC ENTRY PROC [dbinfo: OpenDBInfo, key: AttributeType, start: AttributeValue _ NIL, end: AttributeValue _ NIL] RETURNS [cinfo: CursorInfo] ~ {
ENABLE UNWIND => NULL;
newCursor: CursorInfo;
index: IndexInfo;
index _ NARROW[RefTab.Fetch[dbinfo.indices, key].val];
IF index = NIL THEN 
ERROR Error[$NoIndex, Rope.Cat["Index for ",Atom.GetPName[key]," does not exist."]];
newCursor _ NEW[CursorRecord];
newCursor.index _ index;
newCursor.dbinfo _ dbinfo;
newCursor.key _ key;
newCursor.start _ start;
newCursor.end _ end;
IF newCursor.index.type = secondary THEN {
IF start # NIL THEN
newCursor.start _ ValueToSmallKey[start];
IF end # NIL THEN
newCursor.end _ ValueToLargeKey[end];
};
newCursor.pathStk _ BTreeSimple.NewPathStk[];
newCursor.current _ IF start # NIL THEN GetIndexEntry[index: newCursor.index, value: newCursor.start, valueIsKey: TRUE, relation: less, pathStk: newCursor.pathStk].actual ELSE NIL;
RETURN[newCursor];
};

NextEntryI: PUBLIC ENTRY PROC [dbinfo: OpenDBInfo, cinfo: CursorInfo, dir: CursorDirection _ increasing] RETURNS [entry: Entry] ~ {
ENABLE UNWIND => NULL;
actualValue: AttributeValue;
indexEntry: IndexEntry;
[actualValue, indexEntry] _ GetIndexEntry[index: cinfo.index, value: cinfo.current, valueIsKey: TRUE, relation: IF dir = increasing THEN greater ELSE less, pathStk: cinfo.pathStk];
IF (actualValue = NIL) OR (dir = increasing AND cinfo.end # NIL AND Rope.Compare[actualValue, cinfo.end, FALSE] = greater) OR (dir = decreasing AND Rope.Compare[actualValue, cinfo.start, FALSE] = less) THEN
RETURN[NIL];
entry _ ReadLogEntry[dbinfo.logs[indexEntry.log].stream, indexEntry.firstByte];
cinfo.current _ actualValue;
RETURN[entry];
};

EndGenerateI: PUBLIC ENTRY PROC [dbinfo: OpenDBInfo, cinfo: CursorInfo] RETURNS [] ~ {
ENABLE UNWIND => NULL;
NULL;  -- this routine is unnecessary since cursors get garbage collected
};

WriteEntryI: PUBLIC ENTRY PROC [dbinfo: OpenDBInfo, entry: Entry, log: LogID _ activityLog, replace: BOOLEAN _ FALSE] RETURNS [] ~ {
ENABLE UNWIND => NULL;
value: AttributeValue;
indexData: IndexEntry _ [log: log, firstByte: 0];
doReplace: BOOLEAN _ FALSE;
replacedIndexEntry: IndexEntry;
replacedEntry: Entry;
value _ GetAttributeValue[entry, dbinfo.primaryIndex.key];
IF value = NIL THEN 
ERROR Error[$NoPrimaryKey, "Entry does not contain a primary key."];
IF dbinfo.logs[log].access = readOnly THEN
ERROR Error[$LogReadOnly, "Can't write to a read only log."];
[value, replacedIndexEntry] _ GetIndexEntry[index: dbinfo.primaryIndex, value: value];
IF value # NIL THEN 
IF replace THEN 
doReplace _ TRUE
ELSE 
ERROR Error[$ValueNotUnique, "An existing entry already contains the primary key."];
IF doReplace THEN {
IF replacedIndexEntry.log # log THEN
ERROR Error[$InvalidReplace, "Cross-log replacements are not allowed."];
[] _ WriteLogEntry[dbinfo.logs[log].stream, LIST[[$REPLACED, Convert.RopeFromInt[replacedIndexEntry.firstByte]]]];
};
indexData.firstByte _ WriteLogEntry[dbinfo.logs[log].stream, entry, doReplace];
IF doReplace THEN {
replacedEntry _ ReadLogEntry[dbinfo.logs[log].stream, replacedIndexEntry.firstByte];
RemoveEntryFromIndices[dbinfo.indices, replacedEntry, replacedIndexEntry];
};
AddEntryToIndices[dbinfo.indices, entry, indexData];
MarkUpdateComplete[dbinfo.logs[log].stream];
};

DeleteEntryI: PUBLIC ENTRY PROC [dbinfo: OpenDBInfo, key: AttributeType, value: AttributeValue] RETURNS [] ~ {
ENABLE UNWIND => NULL;
indexEntry: IndexEntry;
index: IndexInfo;
pathSkt: BTreeSimple.PathStk _ BTreeSimple.NewPathStk[];
avalue: AttributeValue;
delete: Entry;
entry: Entry;
index _ NARROW[RefTab.Fetch[dbinfo.indices, key].val];
IF index = NIL THEN 
ERROR Error[$NoIndex, Rope.Cat["Index for ",Atom.GetPName[key]," does not exist."]];
[avalue, indexEntry] _ GetIndexEntry[index: index, value: value, pathStk: pathSkt];
IF avalue = NIL THEN RETURN;
avalue _ GetIndexEntry[index: index, value: avalue, valueIsKey: TRUE, relation: greater, pathStk: pathSkt].actual;
IF Rope.Equal[s1: value, s2: UniqueKeyToValue[avalue], case: FALSE] THEN
ERROR Error[$ValueNotUnique, "Entry to be deleted insufficiently specified."];
IF dbinfo.logs[indexEntry.log].access = readOnly THEN
ERROR Error[$LogReadOnly, "Can't delete entries in a read only log."];
delete _ LIST[[$DELETED, Convert.RopeFromInt[indexEntry.firstByte]]];
[] _ WriteLogEntry[dbinfo.logs[indexEntry.log].stream, delete];
entry _ ReadLogEntry[dbinfo.logs[indexEntry.log].stream, indexEntry.firstByte];
RemoveEntryFromIndices[dbinfo.indices, entry, indexEntry];
MarkUpdateComplete[dbinfo.logs[indexEntry.log].stream];
};

CloseI: PUBLIC ENTRY PROC [dbinfo: OpenDBInfo] RETURNS [] ~ {
ENABLE UNWIND => NULL;
CloseLogs[dbinfo.logs];
CloseIndices[dbinfo.indices];
dbinfo.isOpen _ FALSE;
};

BuildIndicesI: PUBLIC ENTRY PROC [dbinfo: OpenDBInfo] RETURNS [] ~ {
ENABLE UNWIND => NULL;
BuildIndicesWorker[dbinfo];
};

BuildIndicesWorker: PROC [dbinfo: OpenDBInfo] RETURNS [] ~ {
indexData: IndexEntry;
logstream: STREAM;
entry: Entry;
indexEntry: IndexEntry;
saveStreamPosition: INT;
EraseIndices[dbinfo.indices];
FOR log: LogID IN [0..dbinfo.logs.size) DO
IF dbinfo.logs[log] # NIL THEN {
indexData _ [log, 0];
logstream _ dbinfo.logs[log].stream;
FOR entry _ ReadLogEntry[logstream, 0], ReadLogEntry[logstream, -1] UNTIL entry = NIL DO
IF (entry.first.type # $DELETED) AND (entry.first.type # $REPLACED) THEN {  -- WriteEntry
AddEntryToIndices[dbinfo.indices, entry, indexData];
}
ELSE {  -- DeleteEntry
saveStreamPosition _ IO.GetIndex[logstream]; -- before the following read changes the index
indexEntry _ [log: log, firstByte: Convert.IntFromRope[entry.first.value]];
entry _ ReadLogEntry[dbinfo.logs[indexEntry.log].stream, indexEntry.firstByte];
RemoveEntryFromIndices[dbinfo.indices, entry, indexEntry];
IO.SetIndex[logstream, saveStreamPosition];
};
IF IO.EndOf[logstream] OR IO.GetChar[logstream] # EndOfEntry THEN 
ERROR Error[$BadLogEntry, "Missing terminator on log entry."];
indexData.firstByte _ IO.GetIndex[logstream];
ENDLOOP;
};
ENDLOOP;
};

CompactLogsI: PUBLIC ENTRY PROC [dbinfo: OpenDBInfo] RETURNS [] ~ {
ENABLE { UNWIND => NULL; FS.Error => ERROR Error[$InternalError, error.explanation]; };
KeepEntry: PROC [key: BTreeSimple.InternalKey, value: BTreeSimple.Value] RETURNS [continue: BOOLEAN] = {
indexEntry: IndexEntry;
entry: Entry;
TRUSTED {
indexEntry _ LOOPHOLE[@value[0], IndexPtr]^;
};
IF dbinfo.logs[indexEntry.log].access # readOnly THEN {
entry _ ReadLogEntry[dbinfo.logs[indexEntry.log].stream, indexEntry.firstByte];
[] _ WriteLogEntry[newlogs[indexEntry.log].stream, entry];
MarkUpdateComplete[newlogs[indexEntry.log].stream];
};
RETURN[continue: TRUE];
};

newlogs: LogSet _ NEW[LogSetRecord[dbinfo.logs.size]];
FOR i: LogID IN [0..dbinfo.logs.size) DO
IF dbinfo.logs[i] # NIL AND dbinfo.logs[i].access # readOnly THEN {
newlogs[i] _ NEW[LogInfoRecord];
newlogs[i].stream _ GeneralFS.StreamOpen[dbinfo.logs[i].filename, $create !
FS.Error => ERROR Error[$CantOpenLog, error.explanation]];
};
ENDLOOP;
[] _ BTreeSimple.EnumerateRecords[tree: dbinfo.primaryIndex.btree, key: NIL, Proc: KeepEntry !
BTree.Error => ERROR Error[IF reason = closed THEN $DBClosed ELSE $BadIndex, "Problem enumerating primary index."]];
FOR i: LogID IN [0..dbinfo.logs.size) DO
IF newlogs[i] # NIL THEN {
IO.Close[newlogs[i].stream];
IO.Close[dbinfo.logs[i].stream];
dbinfo.logs[i].stream _ GeneralFS.StreamOpen[dbinfo.logs[i].filename, $append !
FS.Error => ERROR Error[$CantOpenLog, error.explanation]];
};
ENDLOOP;
BuildIndicesWorker[dbinfo];
};

SetRemoteAccessI: PUBLIC ENTRY PROC [dbinfo: OpenDBInfo, accessible: BOOLEAN _ TRUE, why: ROPE _ NIL] RETURNS [] ~ {
ENABLE UNWIND => NULL;
dbinfo.remoteAccess _ accessible;
dbinfo.statusMsg _ why;
};
SchemaChars: PUBLIC REF READONLY TEXT = "-->";

ParseSchemaLine: PROC [s: STREAM, buffer: REF TEXT, wdir: ROPE] RETURNS [item: REF ANY, needFilename: BOOLEAN _ FALSE] ~ {
ENABLE {
IO.Error => ERROR Error[$BadSchema, "Error parsing schema statement."];
IO.EndOfStream => ERROR Error[$BadSchema, "Unexpected end of stream."] };
token: REF TEXT;
log: LogInfo;
index: IndexInfo;
needFilename _ FALSE;
token _ IO.GetToken[s, IO.IDProc, buffer].token;
IF NOT RefText.Equal[token, SchemaChars] THEN RETURN[NIL, FALSE];
token _ IO.GetToken[s, IO.IDProc, buffer].token;
SELECT TRUE FROM
RefText.Equal[token, "log", FALSE] => {
log _ NEW[LogInfoRecord];
log.id _ IO.GetInt[s];
token _ IO.GetToken[s, IO.IDProc, buffer].token;
log.access _ IF RefText.Equal[token, "ReadOnly", FALSE] THEN readOnly ELSE readWrite;
log.filename _ IO.GetTokenRope[s, IO.IDProc ! IO.EndOfStream => {needFilename _ TRUE; CONTINUE}].token;
IF NOT needFilename THEN
log.filename _ FS.ExpandName[log.filename, wdir].fullFName;
item _ log;
};
RefText.Equal[token, "index", FALSE] => {
index _ NEW[IndexInfoRecord];
index.key _ Atom.MakeAtom[IO.GetRopeLiteral[s]]; 
token _ IO.GetToken[s, IO.IDProc, buffer].token;
index.type _ IF RefText.Equal[token, "primary", FALSE] THEN primary ELSE secondary;
index.filename _ IO.GetTokenRope[s, IO.IDProc ! IO.EndOfStream => {needFilename _ TRUE; CONTINUE}].token;
IF NOT needFilename THEN
index.filename _ FS.ExpandName[index.filename, wdir].fullFName;
item _ index;
};
ENDCASE => ERROR Error[$BadSchema, "Invalid keyword."];
};

ReadSchema: PROC [dbinfo: OpenDBInfo] RETURNS [] ~ {
ENABLE  DFUtilities.SyntaxError => ERROR Error[$BadSchema, reason];
NewDBInfo: PROC [item: REF ANY, filename: ROPE _ NIL] RETURNS [] ~ {
WITH item SELECT FROM 
log: LogInfo => {
IF filename # NIL THEN
log.filename _ filename;
dbinfo.logs[log.id] _ log;
};
index: IndexInfo => {
IF filename # NIL THEN
index.filename _ filename;
[] _ RefTab.Insert[dbinfo.indices, index.key, index];
IF index.type = primary THEN
IF dbinfo.primaryIndex = NIL THEN
dbinfo.primaryIndex _ index
ELSE
ERROR Error[$BadSchema, "Multiple primary indices specified."];
};
ENDCASE => ERROR Error[$InternalError];
};
SchemaItemProc: DFUtilities.ProcessItemProc = {
WITH item SELECT FROM 
comment: REF DFUtilities.CommentItem => {
IF needFilename THEN
ERROR Error[$BadSchema, "No file name specified for some log or index."];
[lastSchemaItem, needFilename] _ ParseSchemaLine[IO.RIS[comment.text], buffer, wdir];
IF lastSchemaItem # NIL AND NOT needFilename THEN
NewDBInfo[lastSchemaItem];
};
file: REF DFUtilities.FileItem => {
IF needFilename THEN {
NewDBInfo[lastSchemaItem, FS.ExpandName[DFUtilities.RemoveVersionNumber[file.name], wdir].fullFName];
needFilename _ FALSE;
};
};
ENDCASE => {
IF needFilename THEN
ERROR Error[$BadSchema, "No file name specified for some log or index."];
}; 
};
needFilename: BOOLEAN _ FALSE;
lastSchemaItem: REF ANY;
buffer: REF TEXT = RefText.ObtainScratch[RefText.line];
wdir: ROPE = Rope.Substr[dbinfo.dbName, 0, FS.ExpandName[dbinfo.dbName].cp.base.start];
schemaStream: STREAM _ GeneralFS.StreamOpen[dbinfo.dbName !
FS.Error => ERROR Error[$CantOpenSchema, error.explanation]];
DFUtilities.ParseFromStream[in: schemaStream, proc: SchemaItemProc, filter: [comments: TRUE]];
RefText.ReleaseScratch[buffer];
};

DescribeI: PROC [dbinfo: OpenDBInfo] RETURNS [info: SchemaInfo] ~ {
AddIndexInfo: RefTab.EachPairAction = {
index: IndexInfo _ NARROW[val];
IF index # dbinfo.primaryIndex THEN {
info.keys _ CONS[index.key, info.keys];
info.indexNames _ CONS[index.filename, info.indexNames];
};
RETURN[quit: FALSE];
};
info.dbName _ dbinfo.dbName;
info.logs _ NIL;
info.logNames _ NIL;
FOR i: LogID IN [0..dbinfo.logs.size) DO
IF dbinfo.logs[i] # NIL THEN {
info.logs _ CONS[i, info.logs];
info.logNames _ CONS[dbinfo.logs[i].filename, info.logNames];
};
ENDLOOP;
info.keys _ NIL;
info.indexNames _ NIL;
[] _ RefTab.Pairs[dbinfo.indices, AddIndexInfo];
info.keys _ CONS[dbinfo.primaryIndex.key, info.keys];
info.indexNames _ CONS[dbinfo.primaryIndex.filename, info.indexNames];
};
GetAttributeValue: PROC [entry: Entry, type: AttributeType] RETURNS [AttributeValue] ~ {
FOR e: Entry _ entry, e.rest WHILE e # NIL DO
IF e.first.type = type THEN
RETURN[e.first.value];
ENDLOOP;
RETURN[NIL];
};

ReverseEntry: PROC [entry: Entry] RETURNS[Entry] =  {
l1, l2, l3: Entry _ NIL;
IF entry = NIL THEN RETURN[NIL];
l3 _ entry;
UNTIL (l1 _ l3) = NIL DO
l3 _ l3.rest;
l1.rest _ l2;
l2 _ l1;
ENDLOOP;
RETURN[l2];
};

OpenLogs: PROC [logs: LogSet] RETURNS [] ~ {
FOR i: LogID IN [0..logs.size) DO
IF (logs[i] # NIL) AND (logs[i].stream = NIL) THEN {
logs[i].stream _ GeneralFS.StreamOpen[logs[i].filename, IF logs[i].access = readWrite THEN $append ELSE $read !
FS.Error => ERROR Error[$CantOpenLog, error.explanation]];
};
ENDLOOP;
};

ReadLogEntry: PUBLIC PROC [logStream: STREAM, byte: LogAddress] RETURNS [Entry] ~ {
ENABLE { IO.EndOfStream, IO.Error => ERROR Error[$BadLogEntry] };
AttributeBreakProc: IO.BreakProc = {
RETURN[SELECT char FROM
': => sepr,
ENDCASE => other]
};
ReadAttribute: PROC [s: STREAM] RETURNS [a: Attribute] ~ {
a.type _ Atom.MakeAtom[IO.GetTokenRope[s, AttributeBreakProc].token];
[] _ IO.GetChar[s];  -- attribute separation char
[] _ IO.SkipWhitespace[stream: s, flushComments: FALSE];
IF IO.PeekChar[s] = '" THEN {
a.value _ IO.GetRopeLiteral[s];
[] _ IO.GetLineRope[s];
} 
ELSE 
a.value _ IO.GetLineRope[s];
};
entry: Entry;
attribute: Attribute;
IF logStream = NIL THEN ERROR Error[$DBClosed];
IF byte >= 0 THEN
IO.SetIndex[logStream, byte ! IO.Error => ERROR Error[$BadIndex]];
IF IO.PeekChar[logStream] = UpdateComplete THEN RETURN[NIL]; -- at end of log
UNTIL IO.PeekChar[logStream] = EndOfEntry DO
attribute _ ReadAttribute[logStream];
entry _ CONS[attribute, entry];
ENDLOOP;
RETURN[ReverseEntry[entry]];
};

WriteLogEntry: PUBLIC PROC [logStream: STREAM, entry: Entry, continuation: BOOLEAN _ FALSE] RETURNS [LogAddress] ~ {
WriteAttribute: PROC [s: STREAM, a: Attribute] RETURNS [] ~ {
value: ROPE _ a.value;
IF Rope.Find[a.value, "\n"] # -1 THEN  -- write out value as rope literal
value _ Rope.Cat["\"", a.value, "\""];
IO.PutF[s, "%g: %g\n", IO.rope[Atom.GetPName[a.type]], IO.rope[value]]
};
byteOffset: LogAddress;
IF logStream = NIL THEN ERROR Error[$DBClosed];
byteOffset _ IO.GetLength[logStream];
IF byteOffset > 0 AND NOT continuation THEN
byteOffset _ byteOffset - 1;  --remove update marker from end of log
IO.SetIndex[logStream, byteOffset];
FOR e: Entry _ entry, e.rest WHILE e # NIL DO
WriteAttribute[logStream, e.first];
ENDLOOP;
IO.PutChar[logStream, EndOfEntry];
IO.Flush[logStream];
RETURN[byteOffset];
};

MarkUpdateComplete: PUBLIC PROC [logStream: STREAM] RETURNS [] ~ {
byteOffset: LogAddress _ IO.GetLength[logStream];
IO.SetIndex[logStream, byteOffset];
IO.PutChar[logStream, UpdateComplete];
IO.Flush[logStream];
};

CloseLogs: PROC [logs: LogSet] RETURNS [] ~ {
FOR i: LogID IN [0..logs.size) DO
IF (logs[i] # NIL) AND (logs[i].stream # NIL) THEN {
IO.Close[logs[i].stream];
logs[i].stream _ NIL;
};
ENDLOOP;
};

OpenIndices: PROC [indices: IndexSet] RETURNS [needToRebuild: BOOLEAN] ~ {
OpenIndex: RefTab.EachPairAction = {
init: BOOLEAN _ FALSE;
index: IndexInfo _ NARROW[val];
IF index.btree = NIL THEN {
index.btree _ BTreeSimple.New[];
};
IF BTree.GetState[index.btree].state # open THEN {
index.openfile _ GeneralFS.Open[name: index.filename, lock: $write
! FS.Error => {  -- problem opening btree so create new one
IF error.group = $user AND error.code = $unknownFile THEN {
init _ TRUE;
needToRebuild _ TRUE;
index.openfile _ GeneralFS.Create[name: index.filename];
CONTINUE;
}
ELSE
ERROR Error[$CantOpenIndex, error.explanation];
}
];
BTreeSimple.Open[tree: index.btree, file: index.openfile, initialize: init !
BTree.Error => ERROR Error[$BadIndex, Rope.Cat["Bad index for ",Atom.GetPName[NARROW[key]],"."]]];
};
RETURN[quit: FALSE];
};
needToRebuild _ FALSE;
[] _ RefTab.Pairs[indices, OpenIndex];
RETURN[needToRebuild];
};

GetIndexEntry: PROC [index: IndexInfo, value: AttributeValue, valueIsKey: BOOLEAN _ FALSE, relation: BTreeSimple.Relation _ equal, pathStk: BTreeSimple.PathStk _ NIL] RETURNS [actual: AttributeValue, data: IndexEntry] ~ {
btreeValue: BTreeSimple.Value;
useKey: AttributeValue _ value;
useRelation: BTreeSimple.Relation _ relation;
IF NOT valueIsKey AND index.type = secondary THEN 
SELECT relation FROM
less => 
useKey _ ValueToSmallKey[value];
lessEqual =>
useKey _ ValueToLargeKey[value];
equal => { --start small and look upwards
useKey _ ValueToSmallKey[value];
useRelation _ greaterEqual;
};
greaterEqual => 
useKey _ ValueToSmallKey[value];
greater =>
useKey _ ValueToLargeKey[value];
ENDCASE;
[actual, btreeValue] _ BTreeSimple.ReadRecord[tree: index.btree, key: useKey, relation: useRelation, pathStk: pathStk, useExistingPath: pathStk # NIL !
BTree.Error => ERROR Error[IF reason = closed THEN $DBClosed ELSE $BadIndex]];
IF NOT valueIsKey AND index.type = secondary AND relation = equal AND NOT Rope.Equal[value, UniqueKeyToValue[actual], FALSE] THEN -- found entry larger than desired
actual _ NIL;
IF btreeValue # NIL THEN TRUSTED {
data _ LOOPHOLE[@btreeValue[0], IndexPtr]^;
};
RETURN[actual, data];
};

CreateIndexEntry: PROC [index: IndexInfo, value: AttributeValue, data: IndexEntry] RETURNS [] ~ {
btreeValue: BTreeSimple.Value;
btreeValue _ NEW[BTreeSimple.ValueObject[SIZE[IndexEntry]]];
TRUSTED {
LOOPHOLE[@btreeValue[0], IndexPtr]^ _ data;
};
BTreeSimple.UpdateRecord[tree: index.btree, key: IF index.type = primary THEN value ELSE ValueToUniqueKey[value, data], value: btreeValue !
BTree.Error => ERROR Error[IF reason = closed THEN $DBClosed ELSE $BadIndex]];
};

DeleteIndexEntry: PROC [index: IndexInfo, value: AttributeValue, data: IndexEntry] RETURNS [] ~ {
[] _ BTreeSimple.DeleteKey[tree: index.btree, key: IF index.type = primary THEN value ELSE ValueToUniqueKey[value, data] !
BTree.Error => ERROR Error[IF reason = closed THEN $DBClosed ELSE $BadIndex]];
};

AddEntryToIndices: PROC [indices: IndexSet, entry: Entry, data: IndexEntry] RETURNS [] ~ {
index: IndexInfo;
FOR e: Entry _ entry, e.rest WHILE e # NIL DO
index _ NARROW[RefTab.Fetch[indices, e.first.type].val];
IF index # NIL THEN {  -- index key in entry so add to index
CreateIndexEntry[index, e.first.value, data];
};
ENDLOOP;
};

RemoveEntryFromIndices: PROC [indices: IndexSet, entry: Entry, data: IndexEntry] RETURNS [] ~ {
index: IndexInfo;
FOR e: Entry _ entry, e.rest WHILE e # NIL DO
index _ NARROW[RefTab.Fetch[indices, e.first.type].val];
IF index # NIL THEN {  -- index key in entry so remove from index
DeleteIndexEntry[index, e.first.value, data];
};
ENDLOOP;
};

EraseIndices: PROC [indices: IndexSet] RETURNS [] ~ {
EraseIndex: RefTab.EachPairAction = {
index: IndexInfo _ NARROW[val];
IF index.btree = NIL THEN RETURN[quit: FALSE];
IF BTree.GetState[index.btree].state # closed THEN {
BTreeSimple.SetState[index.btree, closed];
FS.Close[index.openfile];
};
index.openfile _ GeneralFS.Create[index.filename];
BTreeSimple.Open[tree: index.btree, file: index.openfile, initialize: TRUE];
RETURN[quit: FALSE];
};
[] _ RefTab.Pairs[indices, EraseIndex];
};

CloseIndices: PROC [indices: IndexSet] RETURNS [] ~ {
CloseIndex: RefTab.EachPairAction = {
index: IndexInfo _ NARROW[val];
IF index.btree # NIL AND BTree.GetState[index.btree].state # closed THEN {
BTreeSimple.SetState[index.btree, closed];
FS.Close[index.openfile];
};
RETURN[quit: FALSE];
};
[] _ RefTab.Pairs[indices, CloseIndex];
};


IsUniqueKey: PROC [key: ROPE] RETURNS [BOOLEAN] ~ INLINE {
RETURN[Rope.Find[key, "\000"] # -1];
};

ValueToUniqueKey: PROC [value: AttributeValue, data: IndexEntry] RETURNS [ROPE] ~ INLINE {
RETURN[Rope.Cat[value, "\000", Convert.RopeFromInt[data.log], " ", Convert.RopeFromInt[data.firstByte]]];
};

ValueToSmallKey: PROC [value: AttributeValue] RETURNS [ROPE] ~ INLINE {
RETURN[Rope.Concat[value, "\000\000"]];
};

ValueToLargeKey: PROC [value: AttributeValue] RETURNS [ROPE] ~ INLINE {
RETURN[Rope.Concat[value, "\000\377"]];
};

UniqueKeyToValue: PROC [key: ROPE] RETURNS [AttributeValue] ~ INLINE {
RETURN[Rope.Substr[key, 0, Rope.Index[key, 0, "\000"]]];
};
Recover: PROC [dbinfo: OpenDBInfo] RETURNS [needToRebuild: BOOLEAN] ~ {
needToRebuild _ FALSE;
FOR i: LogID IN [0..dbinfo.logs.size) DO
IF (dbinfo.logs[i] # NIL) AND (dbinfo.logs[i].access # readOnly) THEN {
IF NOT InGoodState[dbinfo.logs[i].stream] THEN
IF RestoreLog[dbinfo.logs[i].stream] THEN
needToRebuild _ TRUE;
};
ENDLOOP;
RETURN[needToRebuild];
};

InGoodState: PROC [logStream: STREAM] RETURNS [BOOLEAN] ~ {
length: INT;
thirdToLastByte, secondToLastByte, lastByte: CHAR;
length _ IO.GetLength[logStream];
IF length < 3 THEN { -- log just created (or too short to be valid)
IO.SetLength[logStream, 0];
MarkUpdateComplete[logStream];
RETURN[TRUE];
};
IO.SetIndex[logStream, length-3];
thirdToLastByte _ IO.GetChar[logStream];
secondToLastByte _ IO.GetChar[logStream];
lastByte _ IO.GetChar[logStream];
RETURN[(thirdToLastByte = '\n) AND (secondToLastByte = EndOfEntry) AND (lastByte = UpdateComplete)];
};

RestoreLog: PROC [logStream: STREAM] RETURNS [needToRebuild: BOOLEAN] ~ {
logAddress: INT;
prevByte, byte: CHAR;
lastEntry: Entry;
logAddress _ IO.GetLength[logStream]-2;
IO.SetIndex[logStream, logAddress];
prevByte _ IO.GetChar[logStream];
byte _ IO.GetChar[logStream];
IF (byte = EndOfEntry) AND (prevByte = '\n) THEN { 
needToRebuild _ TRUE;
}
ELSE { 
UNTIL ((byte = EndOfEntry) AND (prevByte = '\n)) OR (logAddress = 0) DO
byte _ prevByte;
logAddress _ logAddress - 1;
IO.SetIndex[logStream, logAddress];
prevByte _ IO.GetChar[logStream];
ENDLOOP;
IO.SetLength[logStream, IF logAddress = 0 THEN 0 ELSE logAddress + 2];
needToRebuild _ FALSE;
};
IF logAddress # 0 THEN {
byte _ prevByte;
logAddress _ logAddress - 1;
IO.SetIndex[logStream, logAddress];
prevByte _ IO.GetChar[logStream];
UNTIL ((byte = EndOfEntry) AND (prevByte = '\n)) OR (logAddress = 0) DO  
byte _ prevByte;
logAddress _ logAddress - 1;
IO.SetIndex[logStream, logAddress];
prevByte _ IO.GetChar[logStream];
ENDLOOP;
IF logAddress # 0 THEN
logAddress _ logAddress + 2;
lastEntry _ ReadLogEntry[logStream, logAddress];
IF lastEntry.first.type = $REPLACED THEN {
IO.SetLength[logStream, logAddress];
needToRebuild _ FALSE;
};
};
MarkUpdateComplete[logStream];
RETURN[needToRebuild];
};

IndicesOutOfDate: PROC [dbinfo: OpenDBInfo] RETURNS [BOOLEAN] ~ {
fileDate: BasicTime.GMT;
indexDate: BasicTime.GMT _ FS.FileInfo[name: dbinfo.primaryIndex.filename].created;
FOR i: LogID IN [0..dbinfo.logs.size) DO
IF dbinfo.logs[i] # NIL THEN {
fileDate _ FS.FileInfo[name: dbinfo.logs[i].filename].created;
IF BasicTime.Period[from: indexDate, to: fileDate] > 0 THEN RETURN[TRUE];
};
ENDLOOP;
RETURN[FALSE];
};

OpenDBTable: SymTab.Ref;

OpenDBTableSize: SymTab.SeqIndex = 2039;

GetSharedDB: PROC [dbName: ROPE] RETURNS [dbinfo: OpenDBInfo] ~ {
fname: ROPE _ FS.FileInfo[dbName ! FS.Error => ERROR Error[$CantOpenSchema, error.explanation]].fullFName;
dbinfo _ NARROW[SymTab.Fetch[OpenDBTable, fname].val];
IF dbinfo = NIL THEN {
dbinfo _ NEW[OpenDBRecord];
dbinfo.dbName _ fname;
dbinfo.isOpen _ FALSE;
dbinfo.remoteAccess _ TRUE;
dbinfo.statusMsg _ "Open for service.";
dbinfo.indices _ RefTab.Create[];
dbinfo.primaryIndex _ NIL;
dbinfo.logs _ NEW[LogSetRecord[LAST[LogID]]];
IF NOT SymTab.Insert[OpenDBTable, fname, dbinfo] THEN  -- lost race
dbinfo _ NARROW[SymTab.Fetch[OpenDBTable, fname].val];
};
};

OpenDBTable _ NARROW[Atom.GetProp[$LoganBerry, $OpenDBTable]];
IF OpenDBTable = NIL THEN {
OpenDBTable _ SymTab.Create[mod: OpenDBTableSize, case: FALSE];
Atom.PutProp[$LoganBerry, $OpenDBTable, OpenDBTable];
};

END.
6bLoganBerryImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Doug Terry, October 17, 1986 3:45:59 pm PDT
Swinehart, November 8, 1986 3:26:03 pm PST

LoganBerry is a simple facility for managing databases.  Data is stored in one or more log files and indexed using stable btrees.  This "poor man's" database facility is intended to allow various types of data to be stored persistently.  A database survives processor crashes, but the data management facility does not provide atomic transactions.  Only very simple queries are supported: retrieval by key or key subrange.  Databases may be shared by multiple clients and accessed remotely via RPC.

Exported RPC operations
These routines export to the LoganBerry interface.  All of the operations (except EnumerateEntries) can be invoked via RPC.  They take a RPC.Conversation as the first argument so that secure remote procedure calls can be made to a LoganBerry database server.

Initiates database activity and checks for consistency.  This can be called any number of times to get a new OpenDB handle or reopen a database that has been closed.  Indices are automatically rebuilt if any are missing or if a partially-completed update left them out-of-date.
Returns an entry that contains the given attribute value for the given key.  If the key refers to the primary index then the unique entry is returned and `others' is FALSE.  If the key is secondary and several entries exist with the same value for the key, then an arbitrary entry is returned and `others' is set to TRUE; use EnumerateEntries to get all of the matching entries.
Calls `proc' for each entry in the specified range of key values.  The enumeration is halted when either the range of entries is exhausted or `proc' returns FALSE.  A NIL value for `start' represents the least attribute value, while a NIL value for `end' represents the largest attribute value.  Thus, the complete database can be enumerated by specifying start=NIL and end=NIL with `key' equal to the primary key.
Similar to EnumerateEntries, but creates a cursor so that entries in the specified range of key values can be retrieved using NextEntry (defined below).  Initially, the cursor points to the start of the sequence.  A NIL value for `start' represents the least attribute value, while a NIL value for `end' represents the largest attribute value.  Thus, the complete database can be enumerated by specifying start=NIL and end=NIL with `key' equal to the primary key.
Retrieves the next entry relative to the given cursor.  The cursor, and thus the sequence of desired entries, must have been previously created by a call to GenerateEntries.  The cursor is automatically updated so that NextEntry may be repeatedly called to enumerate entries.  NIL is returned if the cursor is at the end of the sequence and dir=increasing or at the start of the sequence and dir=decreasing.
Releases the cursor; no further operations may be performed using the given cursor.  This must be called once for every call to GenerateEntries.
Adds a new entry to the database.  The entry is added to the activity log unless another log is explicitly requested.  The entry must have an attribute for the primary key.  The primary attribute value must be unique throughout the database unless replace=TRUE; in this case, an existing entry with the same primary attribute value is atomically replaced with the new entry. 
Deletes the entry that contains the given attribute value for the given key.  If the key is for a secondary index and the value is not unique then an Error[$ValueNotUnique] is raised.  Deletes are actually performed by logging the delete request (so that the log can be replayed at a later time) and then updating all of the indices.
Terminates database activity and closes all log and index files.  Databases are always maintained consistently on disk so it doesn't hurt to leave a database open.  The main reason for calling Close is to release the FS locks on the log files so they can be manually edited.
Rebuilds the indices by scanning the logs and performing WriteEntry or DeleteEntry operations.
Removes deleted entries from the logs by enumerating the primary index and writing new logs.
Returns schema information about the database.
Unseals the database handle, ensures that it's valid, and checks if remote access is allowed.
Internal monitored operations
These routines export to the internal LB interface.  The operations are monitored so that several processes can share a database.  All of the operations (except OpenI) take a monitored OpenDBInfo handle as their first parameter.
Initiates database activity and checks for consistency.  This can be called any number of times to get a new OpenDB handle or reopen a database that has been closed.  Indices are automatically rebuilt if any are missing or if a partially-completed update left them out-of-date.
WARNING: SINCE THIS ROUTINE IS NOT MONITORED, RACE CONDITIONS MUST BE CAREFULLY AVOIDED.
Want at most one client to attempt to open a database.
Returns an entry that contains the given attribute value for the given key.  If the key refers to the primary index then the unique entry is returned and `others' is FALSE.  If the key is secondary and several entries exist with the same value for the key, then an arbitrary entry is returned and `others' is set to TRUE; use EnumerateEntries to get all of the matching entries.
Find appropriate index
[entry: LoganBerry.Entry] RETURNS [continue: BOOL]
set breakpoint here to look at entry
Calls `proc' for each entry in the specified range of key values.  The enumeration is halted when either the range of entries is exhausted or `proc' returns FALSE.  A NIL value for `start' represents the least attribute value, while a NIL value for `end' represents the largest attribute value.  Thus, the complete database can be enumerated by specifying start=NIL and end=NIL with `key' equal to the primary key.
Similar to EnumerateEntries, but creates a cursor so that entries in the specified range of key values can be retrieved using NextEntry (defined below).  Initially, the cursor points to the start of the sequence.  A NIL value for `start' represents the least attribute value, while a NIL value for `end' represents the largest attribute value.  Thus, the complete database can be enumerated by specifying start=NIL and end=NIL with `key' equal to the primary key.
back up one so we're in a position to start (assuming dir=increasing)
Retrieves the next entry relative to the given cursor.  The cursor, and thus the sequence of desired entries, must have been previously created by a call to GenerateEntries.  The cursor is automatically updated so that NextEntry may be repeatedly called to enumerate entries.  NIL is returned if the cursor is at the end of the sequence and dir=increasing or at the start of the sequence and dir=decreasing.
Note: The end conditions may not be what is desired, since changing directions at either end causes the first element at that end to be skipped.
Releases the cursor; no further operations may be performed using the given cursor.  This must be called once for every call to GenerateEntries.
Adds a new entry to the database.  The entry is added to the activity log unless another log is explicitly requested.  The entry must have an attribute for the primary key and the primary attribute value must be unique throughout the database. 
For replacements, the entry being replaced and its replacement must reside in the same log.  A replace operation is logged in a similar manner to delete operations.  The entry written after the replace log entry is the replacement.  Both log entries are written before any of the indices are updated.  In the event of a crash, both entries must be recovered atomically.
Deletes the entry that contains the given attribute value for the given key.  If the key is for a secondary index and the value is not unique then an Error[$ValueNotUnique] is raised.  Deletes are actually performed by logging the delete request (so that the log can be replayed at a later time) and then updating all of the indices.
Find appropriate index
Locate log entry
Log delete operation
Update indices
Terminates database activity and closes all log and index files.  Databases are always maintained consistently on disk so it doesn't hurt to leave a database open.  The main reason for calling Close is to release the FS locks on the log files so they can be manually edited.
Maintenance operations
Rebuilds the indices by scanning the logs and performing WriteEntry or DeleteEntry operations.
This routine grabs the monitor lock then calls on the internal procedure to do the real work.
Removes deleted entries from the logs by enumerating the primary index and writing new logs.
Controls access by remote clients to the database.  If accessible=FALSE then the database can not be accessed through the normal LoganBerry interface, only via this interface; setting accessible=TRUE makes the database commonly available (the normal case).  This operation is intended for use by administrators that wish to temporarily remove a database from service.
Database schema
A schema is created by clients of this package and stored in a DF file that can be used to backup the database.  Lines of the file starting with "-->" are deemed to contain schema information for the file named in the subsequent line of the DF file or at the end of the same line.  The two types of schema entries are as follows:
--> log <logID> <readOnly or readWrite> <optional CR> <filename>
--> index <key> <primary or secondary> <optional CR> <filename>

Takes an input stream and parses one schema entry from it.  The item returned is of type LogInfo or IndexInfo; needFilename=TRUE indicates that no file name existed in the input stream (it must be on the next line of the schema file).
Read the database schema from dbinfo.dbName.  
[item: REF ANY] RETURNS [stop: BOOL _ FALSE]
Returns schema information about the database.  This routine is not monitored since it can safely be called while other operations are in progress.
[key: RefTab.Key, val: RefTab.Val] RETURNS [quit: BOOLEAN]
Entries
Destructively reverses the order of the entry's attributes.  Taken from LispImpl.DReverse.
Log management
Some day these routines may be placed in a separate module.
[char: CHAR] RETURNS [IO.CharClass]
read a list of attributes until endofentry
the list is constructed backwards, so it is reversed before being returned
write a list of attributes
Index management
Some day these routines may be placed in a separate module.
[key: RefTab.Key, val: RefTab.Val] RETURNS [quit: BOOL]
Note: the AttributeValue's passed in and out may be unique keys or not.
[key: RefTab.Key, val: RefTab.Val] RETURNS [quit: BOOL]
the following two statements may not really be needed
[key: RefTab.Key, val: RefTab.Val] RETURNS [quit: BOOL]
Secondary indices: need not be unique so special btree keys must be generated.  Unique keys are obtained by appending a logID/logAddress pair to an AttributeValue.
Crash recovery
Checks that the log is in a consistent state.  The last byte of the log should be the UpdateComplete marker.
PROBLEM: the byte count returned by GetLength may be wrong after a crash?
Restores the log to a consistent state.  There are two cases to consider: 1) the system was interupted while writing an entry on the log, 2) a complete entry exists on the log but the btrees have only been partially updated.
entry complete so roll forward, but don't know state of indices so must rebuild them
entry only partially written so roll backward: scan log from end looking for EndOfEntry, then reset log length
A replaced entry should never be the last entry in a log.  If this is the case, then we must have crashed before writing the replacement entry.  To recover, simply remove the replaced entry.
Back up one more character, then continue backwards search to find last entry
Log is now in good shape.
Determines if logs have been edited manually, i.e. if the indices are currently out-of-date, by checking the create date of the primary index against those of the logs.
This doesn't actually work since simply opening an activity log changes its date.
Shared databases
A given database can not actually be opened more than once because of the concurrency control provided by FS.  Thus, we keep a table of databases that are already open.
2039 is a good candidate because it is prime and is large enough that collisions should be rare.
Remember: this routine is not called under a monitor lock.  If several clients try to create an OpenDBRecord concurrently, the first one to register with the OpenDBTable wins.

Want the table of open databases to be created only once, even if this package is re-run.
Doug Terry August 12, 1985 1:05:48 pm PDT
created 
Doug Terry, January 23, 1986 8:28:43 pm PST
changes to: DIRECTORY, Open, Close, GetInfo, dbinfo (local of GetInfo), OpenI, MonitoredOpen, EnumerateEntriesI, CloseI, CompactLogsI, SetRemoteAccessI, ReadLogEntry, WriteLogEntry, CloseLogs, GetIndexEntry, CreateIndexEntry, DeleteIndexEntry, CloseIndex (local of CloseIndices), OpenDBTable, OpenDBTableSize, GetSharedDB, OpenDBTable, IF, IMPORTS
Doug Terry, January 24, 1986 9:39:30 am PST
changes to: MonitoredOpen, BuildIndicesI, BuildIndicesWorker
Swinehart, January 27, 1986 5:10:45 pm PST
Fullname expansion does not produce a canonical name (case may differ); GetSharedDB now uses a case-insensitive symbol table.
changes to: GetSharedDB
Doug Terry, January 31, 1986 4:25:40 pm PST
changes to: DIRECTORY, OpenIndex (local of OpenIndices), CloseIndex (local of CloseIndices), EraseIndex (local of EraseIndices), CompactLogsI
Doug Terry, March 5, 1986 5:21:27 pm PST
Implemented Describe so that clients can obtain schema information even if they don't have access to the schema file.
changes to: Describe, DescribeI, AddIndexInfo (local of DescribeI)
Κ'V˜
codeš
œ™Kšœ
Οm
œ1™<Kš
œ+™+K™*—K™Kš
œς™ςK™š
Οk	˜	Kšœžœ(˜2Kšœ
žœžœ
˜Kšœžœ˜KšœžœΟcœŸœ…
˜Β
Kšœžœ˜)Kšœžœp˜
Kšžœ
žœ0˜8Kšœ
žœ˜+Kšžœ
žœΫ
žœžœ˜ύ
Kšœžœ˜$Kšœžœ5˜AKšœžœ.˜;Kšœžœ,žœ
˜DKšœžœ(˜4K˜Kš
œ˜Kš
œ˜Kš
œ˜—K˜Kš
Πblœžœ
žœ
žœžœ˜CKšžœ-žœžœžœ&˜zKšžœ#˜*šœž˜K˜Kšžœ!˜%K˜Icode0šžœžœžœ
˜Lšžœžœžœ
žœ
˜—
headš
œ™Kš
œ‚™‚K™Lšœžœ
žœžœžœžœ
˜DL˜šΟnœžœ
žœžœ
žœžœ˜KKš
œ•™•Kš
œ#˜#Kšžœ
žœžœ
žœ*˜OKš
œ˜Kš
œ˜—K˜š‘	œžœ
žœžœ9žœžœ˜Œ
Kš
œϊ™ϊKš
œ6˜6K˜—K˜š
‘œžœ:žœžœžœ˜–
Kš
œž™žKš
œ6˜6K˜—K˜š‘œžœ
žœžœ:žœžœžœ˜€
Kš
œΟ™ΟKš
œG˜GKš
œ˜Kš
œ˜—K˜š
‘	œžœ
žœžœ5žœ˜wKš
œ—™—Kš
œ˜šžœžœ
ž˜%Kš
œ˜Kšžœžœ
˜—Kšžœžœ
žœ
žœ:˜OKš
œ%˜%K˜—K˜š
‘œžœ
žœžœžœ˜JKš
œ
™
K˜K˜—K˜š‘
œžœ
žœžœ?žœžœžœ˜‡
Kšœ€žœs™χKš
œ.˜.K˜—K˜š
‘œžœ
žœžœ9žœ˜qKš
œΝ™ΝKš
œ&˜&K˜—K˜š
‘œžœ
žœžœžœ˜@K™’Kšœžœžœ
žœ˜=K˜—K˜š
‘œžœ
žœžœžœ˜GKš
œ^™^Kš
œ˜Kš
œ˜—K˜š
‘œžœ
žœžœžœ˜FKš
œ\™\Kš
œ˜K˜—K˜š
‘œžœ
žœžœžœ˜SK™.Kšœžœ˜K˜—K˜š‘œžœžœžœ˜:K™]Kšœžœ˜šžœžœ
ž˜Kšžœ+˜0—šžœžœ
ž˜šœž
˜Kšžœ
žœžœ
žœ*˜OKšžœ
žœžœ
žœ$˜CKšžœ	˜K˜—Kšžœžœ/˜?—K˜——š
œ™Kš
œδ
™δ
L˜š
‘œžœ
žœ
žœžœ˜BKš
œ•™•Kš
ΟsX™XKš
œ˜šžœ
žœž˜Kš
œ˜—Kšžœ	˜Kš
œ˜—K˜š‘
œž
œžœ˜=Kšžœ
žœžœ
˜K™6Kšœžœžœ
˜Kšžœžœ
žœŸ˜+šžœžœ
ž˜!Kš
œ˜—Kš
œ˜šžœž˜Kšœžœ
˜—šžœž˜#Kšœžœ
˜—šžœž˜Kš
œ˜—Kšœžœ
˜K˜—K˜š‘
œžœ
žœ
žœAžœžœ˜‰
Kšžœ
žœžœ
˜Kš
œϊ™ϊKš
œ˜Kš
œ˜Kš
œ˜Kš
œ8˜8Lš
œ™Lšœžœ(˜6šžœ	žœ
žœ
˜LšžœO˜T—Lš
œS˜SLšžœ
žœ
žœ
žœžœ
žœ˜8Kš
œO˜Ošžœž˜Kšœ	ž˜—šžœ˜Lšœ@žœ.˜rKšœCžœ˜JK˜—Kšžœ˜K˜—K˜•StartOfExpansion6 -- [entry: IndexedLog.Entry] RETURNS [continue: BOOL]šΟbœŸ˜8Kš
Πck2™2Kšœžœžœ
˜Kš
œ$™$Kšžœ˜
K˜—K˜š‘œžœ
ž
œBžœžœžœ˜₯
Kšžœ
žœžœ
˜Kš
œž™žš£œžœ:žœžœ˜pKš
œ˜K˜
Kšžœžœ
žœ&žœžœ
žœžœ˜d
code2šžœ˜	Nšœ
žœ˜,N˜—Kš
œO˜OKšžœ˜K˜—Kš
œ˜Lšœžœ(˜6šžœ	žœ
žœ
˜LšžœO˜T—šžœžœ˜ šžœ	žœ
ž˜Lš
œ˜—šžœžœ
ž˜Lš
œ˜—L˜—š
œZ˜ZKš	œžœžœžœžœP˜‘
—K˜—K˜š‘œžœ
ž
œBžœžœžœ˜€
Kšžœ
žœžœ
˜Kš
œΟ™ΟLš
œ˜Lš
œ˜Lšœžœ(˜6šžœ	žœ
žœ
˜LšžœO˜T—Kšœžœ˜Lš
œ˜K˜K˜K˜K˜šžœ"žœ˜*šžœ	žœ
ž˜Lš
œ)˜)—šžœžœ
ž˜Lš
œ%˜%—L˜—Kš
œ-˜-Kš
œE™EKš
œžœ	žœ
žœKžœ5žœ
žœ
˜΄
Kšžœ˜Kš
œ˜—K˜š‘
œžœ
ž
œLžœ˜ƒ
Kšžœ
žœžœ
˜Kš
œ—™—K™
Kšœžœ˜Kš
œ˜Lš	œ`žœžœžœ	žœ˜΄
šžœžœžœžœ
žœ
žœ&žœ
žœžœ(žœ
ž˜Ξ
Lšžœ
žœ˜—Kš
œO˜OKš
œ˜Kšžœ˜K˜—K˜š‘œžœ
ž
œ)žœ˜VKšžœ
žœžœ
˜Kš
œ
™
KšžœŸB˜IK˜—K˜š‘œžœ
ž
œGžœžœžœ˜„
Kšžœ
žœžœ
˜Kš
œτ
™τ
Kš
œ˜Kš
œ1˜1Kšœžœžœ
˜Kš
œ˜Kš
œ˜Lš
œ:˜:šžœ	žœ
žœ
˜Lšžœ?˜D—šžœ$ž˜*Kšžœ8˜=—Lš
œV˜Všžœ	žœ
žœ
˜šžœ	žœ
˜Kšœž˜—š
ž˜KšžœO˜T——K™ρšžœžœ˜šžœž˜$KšžœC˜H—Kšœ,žœB˜rK˜—Kš
œO˜Ošžœžœ˜Kš
œT˜TKš
œJ˜JK˜—Kš
œ4˜4Kš
œ,˜,K˜—K˜š
‘œžœ
žœ
žœAžœ˜nKšžœ
žœžœ
˜Kš
œΝ™ΝKš
œ˜Kš
œ˜Kš
œ8˜8K˜Kš
œ˜Kš
œ
˜
Lš
œ™Lšœžœ(˜6šžœ	žœ
žœ
˜LšžœO˜T—Lš
œ™Lš
œS˜SKšžœ
žœ
žœ
žœ
˜Lšœ@žœ.˜ršžœ;žœž˜HKšžœI˜N—šžœ/ž˜5KšžœA˜F—Kš
œ™Kšœ	žœ8˜EKš
œ?˜?Kš
œ™Kš
œO˜OKš
œ:˜:Kš
œ7˜7K˜—K˜š‘œžœ
ž
œžœ˜=Kšžœ
žœžœ
˜K™’K˜Kš
œ˜Kšœžœ
˜K˜—K˜—š
œ™š
‘
œžœ
žœ
žœžœ˜DKšžœ
žœžœ
˜Kš
œ^™^K™]Kš
œ˜K˜—K˜š‘œžœžœ˜<Kšœ	žœ
ž
˜Kšœžœ
˜Kš
œ
˜
Kš
œ˜Kšœžœ
˜Kš
œ˜šžœžœž˜*šžœžœ
žœ˜ Kš
œ˜Kš
œ$˜$šžœAžœ	žœ
ž˜Xšžœžœ žœŸ
˜YKš
œ4˜4K˜
—šžœŸ˜KšœžœŸ.˜[Kš
œK˜KKš
œO˜OKš
œ:˜:Kšžœ)˜+K˜—š
žœ
žœžœ
žœ!žœ
˜BKšžœ9˜>—Kšœžœ˜-Kšžœ
˜—K˜—Kšžœ
˜—K˜—K˜š‘œžœ
ž
œžœ˜CKš
žœ
žœžœ
žœ
žœ-˜WKš
œ\™\š£	œžœ:žœžœ˜hKš
œ˜K˜
šžœ˜	Nšœ
žœ˜,N˜—šžœ/žœ˜7Kš
œO˜OKš
œ:˜:Kš
œ3˜3K˜—Kšžœžœ˜K˜—K˜Kšœžœ!˜6šžœ
žœž˜(šžœžœ
žœ"žœ˜CKšœ
žœ˜ š
œK˜KKšžœ
žœ)˜:—K˜—Kšžœ
˜—šœHžœ˜^Kš	œžœžœžœžœ3˜t—šžœ
žœž˜(šžœžœ
žœ˜Kšžœ˜Kšžœ˜ šœžœ7˜OKšžœ
žœ)˜:—K˜—Kšžœ
˜—Kš
œ˜K˜—K˜š‘œžœ
žœ
žœ"žœžœžœžœžœ˜tKšžœ
žœžœ
˜KšœB’œ|’œ¨
™οKš
œ!˜!Kš
œ˜K˜——š
œ™š
œΙ™ΙKš
œ@™@Kš
œ?™?—K™Kšœ
žœ
žœ	˜.L˜šΠbnœžœžœ
žœ
žœžœžœžœ
žœžœ˜zKš
œκ
™κ
šžœ˜Kšžœ
žœ6˜GKšžœžœ2˜I—Kšœžœ
žœ
˜Kš
œ
˜
Kš
œ˜Kšœžœ
˜Kšœžœ
žœ˜0Kšžœ
žœ#žœ
žœ
žœžœ˜AKšœžœ
žœ˜0šžœ
žœ
ž˜šœžœ˜'Kšœžœ˜Kšœ	žœ˜Kšœžœ
žœ˜0Kš	œ
žœ"žœžœ	žœ˜UKšœžœžœ
žœ žœžœ	˜gšžœ
žœž˜Kš
œ;˜;—K˜K˜—šœžœ˜)Kšœžœ˜Kšœžœ˜1Kšœžœ
žœ˜0Kš	œ
žœ!žœžœžœ˜SKšœžœžœ
žœ žœžœ	˜išžœ
žœž˜Kš
œ?˜?—K˜
K˜—Kšžœžœ'˜7—K˜—K˜š‘
œžœžœ˜4Kš
œ.™.K–0 -- [item: REF ANY] RETURNS [stop: BOOL _ FALSE]šžœžœ˜Cš‘	œžœžœ
žœžœžœžœ˜Dšžœžœ
žœ
˜š
œ˜šžœžœ
ž˜K˜—Kš
œ˜K˜—š
œ˜šžœžœ
ž˜Kš
œ˜—Kš
œ5˜5šžœž˜šžœžœ
ž˜!Kš
œ˜—š
ž˜Kšžœ:˜?——K˜—Kšžœžœ˜'—K˜—š£œ!˜/Kš
€,™,šžœžœ
žœ
˜šœ	žœ˜)šžœž˜KšžœD˜I—Kš
œU˜Uš	žœžœ
žœ
žœž˜1Kš
œ˜—K˜—šœžœ˜#šžœžœ˜Kš
œe˜eKšœžœ
˜K˜—K˜—šžœ˜šžœž˜KšžœD˜I—Kš
œ˜——K˜—Kšœžœžœ
˜Kšœžœ
žœ
˜Kšœžœ
žœ'˜7KšœžœM˜Wšœžœ'˜;Kšžœ
žœ,˜=—KšœWžœ˜^K˜K˜K˜—š‘	œžœžœ˜CK™“
–> -- [key: RefTab.Key, val: RefTab.Val] RETURNS [quit: BOOLEAN]š
œ'˜'Kš
€:™:Kšœžœ˜šžœžœ˜%Kšœžœ˜'Kšœžœ"˜8K˜—Kšžœžœ˜K˜—Kš
œ˜Kšœžœ
˜Kšœžœ
˜šžœ
žœž˜(šžœžœ
žœ˜Kšœžœ˜Kšœžœ)˜=K˜—Kšžœ
˜—Kšœžœ
˜Kšœžœ
˜Kš
œ0˜0Kšœžœ%˜5Kšœžœ0˜FK˜——™š‘œžœ%žœ˜Xšžœžœžœ
ž˜-šžœž˜Kšžœ˜—Kšžœ
˜—Kšžœ
žœ˜K˜—K˜š‘œžœžœ˜5Kš
œZ™Zšœžœ
˜Kš
žœ	žœ
žœ
žœ
žœ˜ Kš
œ˜šžœ
žœ
ž˜Kš
œ
˜
Kš
œ
˜
Kš
œ˜Kšžœ
˜—Kšžœ˜Kš
œ˜———™Kš
Ÿ;™;K˜š‘œžœžœ˜,šžœ
žœž˜!š
žœžœžœžœžœ˜4šœ8žœžœ	žœ˜oKšžœ
žœ)˜:—K˜—Kšžœ
˜—K˜—K˜š‘œžœ
žœžœ˜SKšžœžœžœ
žœ˜A–' -- [char: CHAR] RETURNS [IO.CharClass]š£œžœ˜$Kš
€#™#šžœ
žœž˜Kš
œ˜Kšžœ
˜—K˜—š‘
œžœžœžœ˜:Kšœžœ,˜EKšœžœŸ˜1K–0[stream: 
STREAM, flushComments: 
BOOL _ TRUE]šœžœ*žœ˜8šžœ
žœžœ˜Kšœ
žœ˜Kšœžœ˜Kš
œ˜—š
ž˜Kšœ
žœ˜—K˜—Kš
œ
˜
Kš
œ˜Kšžœ
žœ
žœ
žœ˜/šžœž˜Kšžœžœ
žœ˜B—Kšžœ
žœ&žœ
žœ
žœŸ˜MKš
œ*™*šžœ
žœ"ž˜,Kš
œ%˜%Kšœžœ˜Kšžœ
˜—K™JKšžœ˜K˜—K˜š‘
œžœ
žœžœžœžœ˜t–; -- [key: SymTab.Key, val: SymTab.Val] RETURNS [quit: BOOL]š£œžœžœžœ˜=Kšœžœ˜šžœžœ
Ÿ#˜IK˜&—Kšžœžœžœ
˜FKš
œ˜—Kš
œ˜Kšžœ
žœ
žœ
žœ˜/Kšœ
žœ˜%šžœžœ
žœž˜+KšœŸ&˜D—Kšžœ!˜#Kš
œ™šžœžœžœ
ž˜-Kš
œ#˜#Kšžœ
˜—Kšžœ ˜"Lšžœ˜Lšžœ
˜K˜—K˜š
‘œžœ
žœ
žœžœ˜BKšœžœ˜1Kšžœ!˜#Kšžœ$˜&Lšžœ˜K˜—K˜š£	œžœžœ˜-šžœ
žœž˜!š
žœžœžœžœžœ˜4Kšžœ˜Kšœžœ
˜K˜—Kšžœ
˜—K˜——™Kš
Ÿ;™;K˜š‘œžœžœžœ˜Jš£	œ˜$Kš
€7™7Kšœžœžœ
˜Kšœžœ˜šžœžœ
žœ˜Kš
œ ˜ K˜—šžœ*žœ˜2š
œB˜Bšœžœ
Ÿ*˜;šžœžœžœ˜;Nšœžœ
˜Nšœžœ
˜Nš
œ8˜8Nšžœ
˜	Nš
œ
˜
—š
ž˜Nšžœ*˜/—Nš
œ
˜
—Kš
œ˜—š
œL˜LKšœžœ:žœ˜b—K˜—Kšžœžœ˜K˜—Kšœžœ
˜Kš
œ&˜&Kšžœ˜K˜—K˜š‘
œžœ7žœžœIžœžœ/˜έ
Kš
œG™GKš
œ˜Kš
œ˜Kš
œ-˜-šžœ
žœžœžœ
˜2šžœ
ž˜š
œ˜Lš
œ ˜ —š
œ˜Lš
œ ˜ —šœŸ˜)Lš
œ ˜ Lš
œ˜L˜—š
œ˜Lš
œ ˜ —š
œ
˜
Lš
œ ˜ —Lš
ž˜——šœ’
žœ˜—
Lš	œžœžœžœžœ
˜N—šžœ
žœžœžœžœ
žœ-žœžœ
Ÿ"˜€
Lšœžœ
˜
—šžœžœ
žœ
žœ˜"Nšœžœ˜+N˜—Nšžœ˜K˜—K˜š‘œžœ=žœ˜aKš
œ˜Kšœ
žœžœ˜<šžœ˜	Nšžœ#˜+N˜—šœ1žœžœžœ3˜‹
Lš	œžœžœžœžœ
˜N—K˜—K˜š‘œžœ=žœ˜ašœ3žœžœžœ ˜zKš	œžœžœžœžœ
˜N—K˜—K˜š‘œžœ5žœ˜ZKš
œ˜šžœžœžœ
ž˜-Lšœžœ*˜8šžœ	žœ
žœŸ%˜<Kš
œ-˜-L˜—Kšžœ
˜—K˜—K˜š£œžœ5žœ˜_Kš
œ˜šžœžœžœ
ž˜-Lšœžœ*˜8šžœ	žœ
žœŸ*˜AKš
œ-˜-L˜—Kšžœ
˜—K˜—K˜š‘œžœžœ˜5š£
œ˜%Kš
€7™7Kšœžœ˜Kš
žœžœ
žœ
žœžœ˜.Kš
œ5™5šžœ,žœ˜4Kš
œ*˜*Lšžœ˜K˜—Kš
œ2˜2KšœFžœ˜LKšžœžœ˜K˜—Kš
œ'˜'K˜K˜—š‘œžœžœ˜5š£
œ˜%Kš
€7™7Kšœžœ˜šžœžœ
žœ,žœ˜JKš
œ*˜*Lšžœ˜K˜—Kšžœžœ˜K˜—Kš
œ'˜'K˜—K˜Kš
ϣ
™£
K˜š‘œžœžœžœžœžœ
˜:Kšžœ˜$K˜—K˜š
‘œžœ+žœžœžœ
˜ZKšžœc˜iK˜—K˜š
‘œžœžœžœžœ
˜GKšžœ!˜'K˜—K˜š
‘œžœžœžœžœ
˜GKšžœ!˜'K˜—K˜š
‘œžœžœžœžœ
˜FKšžœ2˜8K˜——™š‘œžœžœžœ˜GKšœžœ
˜šžœ
žœž˜(šžœžœžœ$žœ˜Gšžœ
žœ$ž˜.šžœ#ž˜)Kšœžœ
˜——K˜—Kšžœ
˜—Kšžœ˜K˜—K˜š
‘œžœ
žœžœžœ˜;Kš
œl™lKš
œI™IKšœžœ
˜Kšœ-žœ
˜2Kšœ	žœ˜!šžœžœŸ.˜CKšžœ˜Kš
œ˜Kšžœ
žœ˜
K˜—Kšžœ˜!Kšœžœ˜(Kšœžœ˜)Kšœžœ˜!Kšžœžœ!žœ˜dK˜—K˜š
‘
œžœ
žœžœžœ˜IK™ΰ
Kšœžœ
˜Kšœžœ
˜K˜Kšœ
žœ˜'Kšžœ!˜#Kšœžœ˜!Kšœžœ˜šžœžœžœ˜3Kš
œT™TKšœžœ
˜K˜
—šžœ˜Kš
œn™nšžœžœžœž˜GKš
œ˜Kš
œ˜Kšžœ!˜#Kšœžœ˜!Kšžœ
˜—Kšžœžœžœžœ˜FKšœžœ
˜K˜—K™Ύ
šžœžœ˜Kš
œM™MKš
œ˜Kš
œ˜Kšžœ!˜#Kšœžœ˜!šžœžœžœž˜IKš
œ˜Kš
œ˜Kšžœ!˜#Kšœžœ˜!Kšžœ
˜—šžœž˜Kš
œ˜—Kš
œ0˜0šžœ"žœ˜*Kšžœ"˜$Kšœžœ
˜K˜—K˜—K™Kš
œ˜Kšžœ˜Kš
œ˜—K˜š‘œžœžœžœ˜AK™¨
K™QKšœžœ
˜Kšœžœ;˜Sšžœ
žœž˜(šžœžœ
žœ˜Kš
œ>˜>K–[from: 
GMT, to: 
GMT]šžœ5žœ
žœ
žœ˜IK˜—Kšžœ
˜—Kšžœ
žœ˜K˜——™Kš
Ϭ
™¨
K˜K˜K˜š
œ(˜(Jš
œ`™`—J˜š‘œžœ
žœžœ˜AKš
œ―
™―
Kš	œžœžœžœ
žœ6˜jKšœ	žœ'˜6šžœ
žœ
žœ˜Kšœ	žœ˜Kš
œ˜Kšœžœ
˜Kšœžœ
˜Kš
œ'˜'Kš
œ!˜!Kšœžœ
˜Kšœžœžœ
˜-šžœ
žœ+žœŸ˜CKšœ	žœ'˜6—K˜—K˜K˜—J™Jš
œY™YJšœžœ*˜>šžœžœ
žœ˜Jšœ8žœ˜?Jš
œ5˜5J˜——K˜Kšžœ
˜™)K™—™+KšœΟr'œ¦Έ
œ¦E™Ϋ—™+Kšœ¦0™<—™*K™}Kšœ¦™—™+Kšœ¦œ¦œ¦œ¦™
—™(Kš
œu™uKšœ¦!œ™B——…—vvΤ.