DIRECTORY
BcdDefs: TYPE USING [
Base, BcdBase, Link, MTIndex, MTRecord, NameString, SGIndex, FTSelf, SGNull, VersionID, VersionStamp],
CommandUtil: TYPE USING [PairList, KeyValue],
ConvertUnsafe: TYPE USING [EqualSubStrings, SubString],
FS: TYPE USING [Create, Close, Error, Read, nullOpenFile, Open, OpenFile, SameFile],
FileParms: TYPE USING [
ActualId, BindingProc, Name, Ops, SymbolSpace, nullActual, nullSymbolSpace],
FileParmOps: TYPE USING [],
FileSegment: TYPE USING [Span, nullSpan],
Rope: TYPE USING [Cat, Equal, Find, Flatten, Length, ROPE],
VM: TYPE USING [Allocate, Free, Interval, nullInterval, AddressForPageNumber];

FileParmPack: PROGRAM
IMPORTS CommandUtil, ConvertUnsafe, FS, Rope, VM
EXPORTS FileParmOps = { 

Name: TYPE = FileParms.Name;
ActualId: TYPE = FileParms.ActualId;
nullActual: ActualId = FileParms.nullActual;

FileIndex: TYPE = NAT;
nullFileIndex: FileIndex = FileIndex.LAST;



Binding: PROC [
formalId, formalType: Name,
defaultLocator: Name,
binder: FileParms.BindingProc] = {
i: FileIndex;
name: Rope.ROPE _ FileName[formalId, defaultLocator];
type: Rope.ROPE _ formalType;
IF name = NIL THEN i _ nullFileIndex
ELSE {
file: FS.OpenFile _ FS.nullOpenFile;
FOR i IN [0 .. nextFile) DO
IF EquivalentStrings[name, fileTable[i].name] THEN {
IF EquivalentStrings[type, fileTable[i].type] THEN GO TO found;
file _ fileTable[i].file};
REPEAT
found => NULL; -- {zone.FREE[@name]; zone.FREE[@type]};
FINISHED => {
version: BcdDefs.VersionStamp;
span: FileSegment.Span;
IF file = FS.nullOpenFile THEN file _ CreateFile[name];
IF file = FS.nullOpenFile THEN i _ nullFileIndex
ELSE {
[version, span] _ ReadHeader[file, formalType];
i _ SearchCache[version];
IF i = nullFileIndex AND version # nullActual.version THEN {
i _ NewCacheEntry[];
fileTable[i] _ [
version: version, file: file, span: span, name: name, type: type]}
ELSE {
FS.Close[file]; file _ FS.nullOpenFile}}};
ENDLOOP;
IF i = nullFileIndex THEN binder[nullActual]
ELSE binder[[fileTable[i].version, fileTable[i].name]]}};


Acquire: PROC [id: Name, actual: ActualId] RETURNS [FileParms.SymbolSpace] = {
i: FileIndex _ SearchCache[actual.version];
IF i = nullFileIndex THEN {
i _ NewCacheEntry[];
fileTable[i] _ [version: actual.version, name: actual.locator, type: id]};
OpenFile[i];
RETURN [IF fileTable[i].file = FS.nullOpenFile OR fileTable[i].span = nullSpan
THEN FileParms.nullSymbolSpace
ELSE [file: fileTable[i].file, span: fileTable[i].span]]};

Release: PROC [s: FileParms.SymbolSpace] = {NULL};	-- add ref counts?

Forget: PROC [actual: ActualId] = {
i: NAT _ 0;
WHILE i < nextFile DO {
IF fileTable[i].version = actual.version THEN GO TO delete;
IF fileTable[i].name # NIL THEN {
IF Rope.Equal[fileTable[i].name, actual.locator, FALSE] THEN GO TO delete};
i _ i + 1;
EXITS
delete => {
ClearCacheEntry[i];
nextFile _ nextFile - 1;
IF i # nextFile THEN {
fileTable[i] _ fileTable[nextFile]; fileTable[nextFile] _ [nullActual.version]}}};
ENDLOOP};



outputFile: FS.OpenFile;

AcquireOutput: PUBLIC PROC [name: Rope.ROPE] RETURNS [FS.OpenFile] = {
outputFile _ FS.Open[name, write 
! FS.Error => IF error.code = notFound 
THEN {outputFile _ FS.Create[name]; CONTINUE}];
RETURN [outputFile]};

ReleaseOutput: PUBLIC PROC [file: FS.OpenFile] = {
IF outputFile = FS.nullOpenFile OR ~FS.SameFile[file, outputFile] THEN ERROR;
FS.Close[outputFile];  outputFile _ FS.nullOpenFile};



aList: CommandUtil.PairList;

SetAList: PUBLIC PROC [map: CommandUtil.PairList] = {aList _ map};

ClearAList: PUBLIC PROC = {aList _ NIL};



Initialize: PUBLIC PROC [scratchZone: UNCOUNTED ZONE] RETURNS [FileParms.Ops] = {
zone _ scratchZone;
fileTable _ NIL; AdjustFileTable[16];
nextFile _ 0;
outputFile _ FS.nullOpenFile;
RETURN [[Binding, Acquire, Release, Forget]]};

Finalize: PUBLIC PROC = {
FOR i: NAT IN [0..nextFile) DO ClearCacheEntry[i] ENDLOOP;
IF outputFile # FS.nullOpenFile THEN {FS.Close[outputFile]; outputFile _ FS.nullOpenFile};
--zone.--FREE[@fileTable]; zone _ NIL};



FileName: PROC [key: Name, default: Name] RETURNS [Rope.ROPE] = {
t: Rope.ROPE _ CommandUtil.KeyValue[key, aList];
IF t = NIL THEN t _ default;
IF t = NIL THEN t _ key;
RETURN [NormalizeFileName[t]]};

NormalizeFileName: PROC [formal: Name] RETURNS [s: Rope.ROPE] = INLINE {
IF Rope.Equal[formal, "$"] THEN s _ NIL
ELSE {
dotIndex: INT _ Rope.Find[formal, "."];
s _ IF dotIndex < 0 THEN Rope.Cat[formal, ".bcd"] ELSE formal};
RETURN};

EquivalentStrings: PROC [s1, s2: Rope.ROPE] RETURNS [BOOL] = INLINE {
RETURN [Rope.Equal[s1, s2, FALSE]]};



OpenFile: PROC [i: FileIndex] = {
IF fileTable[i].file = FS.nullOpenFile AND fileTable[i].name # NIL THEN
fileTable[i].file _ CreateFile[fileTable[i].name];
IF fileTable[i].file # FS.nullOpenFile AND fileTable[i].span = nullSpan THEN {
version: BcdDefs.VersionStamp;
[version, fileTable[i].span] _ ReadHeader[fileTable[i].file, fileTable[i].type];
IF version # fileTable[i].version THEN {
ClearCacheEntry[i];
fileTable[i].file _ FS.nullOpenFile;  fileTable[i].span _ nullSpan}}};



zone: UNCOUNTED ZONE _ NIL;

nullSpan: FileSegment.Span = FileSegment.nullSpan;

FileRecord: TYPE = RECORD[
version: BcdDefs.VersionStamp _ ,
file: FS.OpenFile _ FS.nullOpenFile,
span: FileSegment.Span _ nullSpan,
name: Name _ NIL,
type: Name _ NIL];
FileTable: TYPE = RECORD [SEQUENCE length: FileIndex OF FileRecord];

fileTable: REF FileTable;
nextFile: NAT;



SearchCache: PROC [version: BcdDefs.VersionStamp] RETURNS [i: FileIndex] = {
FOR i IN [0 .. nextFile) DO
IF fileTable[i].version = version THEN EXIT;
REPEAT
FINISHED => i _ nullFileIndex;
ENDLOOP;
RETURN};

NewCacheEntry: PROC RETURNS [i: FileIndex] = {
WHILE nextFile >= fileTable.length DO AdjustFileTable[fileTable.length + 16] ENDLOOP;
i _ nextFile;  nextFile _ nextFile + 1};

AdjustFileTable: PROC [newSize: NAT] = {
newTable: REF FileTable;
oldSize: NAT = IF fileTable = NIL THEN 0 ELSE fileTable.length;
IF newSize = 0 THEN newTable _ NIL
ELSE {
i: FileIndex;
newTable _ --zone.--NEW[FileTable[newSize]];
FOR i IN [0..MIN[oldSize, newSize]) DO newTable[i] _ fileTable[i] ENDLOOP;
FOR i IN [oldSize..newSize) DO newTable[i] _ [version: nullActual.version] ENDLOOP};
IF fileTable # NIL THEN --zone.--FREE[@fileTable];
fileTable _ newTable};

ClearCacheEntry: PROC [i: FileIndex] = {
IF fileTable[i].file # FS.nullOpenFile THEN {
FS.Close[fileTable[i].file]; fileTable[i].file _ FS.nullOpenFile};
fileTable[i].name _ fileTable[i].type _ NIL;
};



CreateFile: PROC [s: Rope.ROPE] RETURNS [file: FS.OpenFile _ FS.nullOpenFile] = {
IF s # NIL THEN
file _ FS.Open[s, read ! FS.Error => TRUSTED {CONTINUE}];
RETURN};


ReadHeader: PROC [file: FS.OpenFile, formalId: Name] RETURNS [
version: BcdDefs.VersionStamp _ nullActual.version,
span: FileSegment.Span _ nullSpan] = {
headerInterval: VM.Interval _ VM.nullInterval;

DeleteHeader: PROC = {
IF headerInterval # VM.nullInterval THEN {
VM.Free[headerInterval];
headerInterval _ VM.nullInterval}};

IF file # FS.nullOpenFile THEN {
ENABLE {
UNWIND => {NULL};
ANY => {GO TO badFile}};
BcdBase: PROC [p: LONG POINTER] RETURNS [BcdDefs.Base] = INLINE {
RETURN [LOOPHOLE[p, BcdDefs.Base]]};
bcd: BcdDefs.BcdBase;
bcdPages: CARDINAL _ 8;
mtb, ftb, sgb: BcdDefs.Base;
mti: BcdDefs.MTIndex;
sSeg: BcdDefs.SGIndex;
nString: BcdDefs.NameString;
typeId: ConvertUnsafe.SubString; 
d: ConvertUnsafe.SubString;
DO
headerInterval _ VM.Allocate[count: bcdPages];
bcd _ VM.AddressForPageNumber[headerInterval.page];
FS.Read[file: file, from: 0, nPages: bcdPages, to: bcd];
IF bcd.versionIdent # BcdDefs.VersionID THEN GO TO badFile;
IF bcdPages >= bcd.nPages THEN EXIT;
bcdPages _ bcd.nPages;
VM.Free[headerInterval];  headerInterval _ VM.nullInterval
ENDLOOP;
IF bcd.nConfigs # 0 THEN GO TO badFile;	-- no packaged bcd's (for now)
nString _ LOOPHOLE[bcd + bcd.ssOffset];
typeId.base _ LOOPHOLE[Rope.Flatten[formalId]];
typeId.offset _ 0;
typeId.length _ formalId.Length[];
d.base _ @nString.string;
ftb _ BcdBase[bcd + bcd.ftOffset];
mtb _ BcdBase[bcd + bcd.mtOffset];  mti _ BcdDefs.MTIndex.FIRST;
UNTIL mti = bcd.mtLimit DO
d.offset _ mtb[mti].name;  d.length _ nString.size[mtb[mti].name];
IF ConvertUnsafe.EqualSubStrings[typeId, d] THEN EXIT;
mti _ mti + (WITH m: mtb[mti] SELECT FROM
direct => BcdDefs.MTRecord.direct.SIZE + m.length*BcdDefs.Link.SIZE,
indirect => BcdDefs.MTRecord.indirect.SIZE,
multiple => BcdDefs.MTRecord.multiple.SIZE,
ENDCASE => ERROR);
REPEAT
FINISHED =>
IF bcd.nModules = 1 THEN mti _ BcdDefs.MTIndex.FIRST ELSE GOTO badFile;
ENDLOOP;
ftb _ BcdBase[bcd + bcd.ftOffset];
version _ IF mtb[mti].file = BcdDefs.FTSelf
THEN bcd.version
ELSE ftb[mtb[mti].file].version;
sgb _ BcdBase[bcd + bcd.sgOffset];  sSeg _ mtb[mti].sseg;
IF sSeg = BcdDefs.SGNull
OR sgb[sSeg].pages = 0 OR sgb[sSeg].file # BcdDefs.FTSelf THEN GO TO badFile;
span _ [base: sgb[sSeg].base, pages: sgb[sSeg].pages];
DeleteHeader[];
EXITS
badFile => {DeleteHeader[]; span _ nullSpan}};
RETURN};

}.

>file FileParmPack.mesa
last modified by Satterthwaite, September 15, 1982 9:15 am
Last Edited by: Maxwell, August 11, 1983 8:54 am
primary operations for read-only access
zone.FREE[@name]; zone.FREE[@type];
operations for update access
command line arguments
initialization/finalization
interpretation of file names (Pilot PreCascade conventions)
file setup
low-level file manipulation and cache management
file table management
IF fileTable[i].name # NIL THEN zone.FREE[@fileTable[i].name];
IF fileTable[i].type # NIL THEN zone.FREE[@fileTable[i].type];
file setup
NameToRope: PROC [s: LONG STRING] RETURNS [r: Rope.ROPE] = {
oldLength: CARDINAL = s.length;
IF oldLength > 1 AND s[s.length-1] = '. THEN
s.length _ s.length - 1;	-- undo Alto convention for Pilot
r _ ConvertUnsafe.ToRope[s];
s.length _ oldLength;
RETURN};

�ÊA˜Jš
œ™Jš
œ:™:J™0J˜š
Ïk	˜	šœ	�œ
�œ˜Jš
œf˜f—Jšœ
�œ
�œ˜-Jšœ�œ
�œ˜7Jš�œ�œ
�œF˜Tšœ�œ
�œ˜J˜L—Jšœ
�œ
�œ˜Jšœ
�œ
�œ˜)Jšœ�œ
�œ%�œ˜;Jš�œ�œ
�œ@˜NJ˜—šœ�˜Jš�œ�œ�˜0Jš�œ˜J˜Jšœ�œ˜Jšœ
�œ˜$J˜,J˜Jšœ�œ�œ
˜Jšœ%�œ
˜*J˜J˜Jš
œ'™'˜šÏnœ�œ˜J˜Jš
œ˜J˜"J˜
Jšœ�œ&˜5Jšœ�œ˜Jš�œ�œ
�œ˜$š�œ˜Jšœ�œ�œ˜$š�œ�œ�˜š�œ,�œ˜4Jš�œ,�œ
�œ
�œ˜?J˜—š
�˜Jšœ	�œÏc(˜7š�œ˜
Jš
œ˜J˜Jš�œ�œ�œ˜7Jš�œ�œ�œ˜0š�œ˜Jš
œ/˜/J˜š�œ�œ�œ˜<J˜˜J˜B——š�œ˜Jšœ�œ�œ™#Jš�œ�œ˜*————Jš�œ
˜——Jš�œ�œ˜,Jš�œ5˜9J˜J˜—šžœ�œ�œ˜NJ˜+š�œ�œ˜J˜J˜J—J˜š�œ�œ�œ�œ˜NJš�œ˜Jš�œ6˜:J˜——Jšžœ�œ�œŸ˜EJ˜šžœ�œ˜#Jšœ�œ˜š�œ�œ˜Jš�œ'�œ
�œ
�œ˜;š�œ�œ
�œ˜!Jš
�œ/�œ�œ
�œ
�œ	˜K—J˜
š
�˜˜J˜J˜š�œ�œ˜J˜R———Jš�œ˜	J˜J˜———Jš
œ™˜Jšœ�œ
˜J˜šž
œ�œ
�œ
�œ�œ�œ˜Fšœ
�œ˜!šœ�œ
�œ˜'Jš�œ�œ�œ˜/——Jš�œ˜J˜—šž
œ�œ
�œ�œ˜2Jš�œ�œ�œ�œ�œ
�œ
˜MJš�œ"�œ˜5J˜J˜—Jš
œ™J˜J˜J˜Jšžœ�œ
�œ-˜BJ˜Jšž
œ�œ
�œ�œ˜(J˜J˜—Jš
œ™˜šž
œ�œ
�œ�	œ
�œ�œ˜QJ˜Jšœ�œ˜%J˜
Jšœ
�œ˜Jš�œ(˜.J˜—šžœ�œ
�œ˜Jš
�œ�œ
�œ�œ�œ
˜:Jš
�œ�œ�œ�œ!�œ˜ZJšŸ	�œ�œ˜'J˜J˜——Jš
œ;™;˜šžœ�œ�œ�œ˜AJšœ�œ$˜0Jš�œ�œ
�œ
˜Jš�œ�œ
�œ	˜Jš�œ˜J˜—š
žœ�œ�œ
�œ�œ˜HJš�œ�œ�˜'š�œ˜Jšœ
�œ˜'Jšœ�œ�œ�œ	˜?—Jš�œ˜J˜—šžœ�œ�œ�œ�œ�œ˜EJš�œ�œ˜$J˜J˜——Jš
œ
™
˜šžœ�œ˜!š	�œ�œ�œ�œ
�˜GJ˜2—š�œ�œ�œ�œ˜NJš
œ˜Jš
œP˜Pš�œ �œ˜(J˜Jšœ�œ0˜FJ˜J˜————Jš
œ0™0˜Jšœ�	œ
�œ�œ
˜J˜J˜2J˜šœ�œ�œ
˜Jš
œ!˜!Jšœ�œ�œ˜$J˜"Jšœ
�œ
˜Jšœ
�œ˜—Jš	œ�œ�œ�œ�œ
˜DJ˜Jšœ�œ˜Jšœ
�œ
˜J˜J˜Jš
œ™J˜šžœ�œ!�œ˜Lš�œ�œ�˜Jš�œ �œ
�œ
˜,š
�˜Jš�œ˜—Jš�œ
˜—Jš�œ˜J˜—šž
œ�œ
�œ˜.Jš�œ�œ(�œ
˜UJ˜(J˜—šžœ�œ�œ˜(Jšœ
�œ˜Jšœ	�œ�œ
�œ
�œ�œ˜?Jš�œ
�œ�˜"š�œ˜J˜
JšœŸ	�œ˜,Jš
�œ�œ�œ�œ�œ
˜JJš�œ�œ�œ-�œ˜T—Jš	�œ
�œ
�œ
Ÿ	�œ
˜2J˜J˜—šžœ�œ˜(š�œ�œ�œ˜-Jš�œ/�œ˜B—Jšœ(�œ
˜,Jš�œ�œ
�œ�œ™>Jš�œ�œ
�œ�œ™>Jš
œ˜J˜J˜—Jš
œ
™
J˜šž
œ�œ�œ
�œ�œ
�œ™<Jšœ�œ™š�œ�œ�™,JšœŸ!™:—J™J™Jš�œ™J™—šž
œ�œ
�œ�œ�œ�œ˜Qš�œ�œ
�˜Jš	œ�œ�œ
�œ�œ˜9—Jš�œ˜J˜J˜—šž
œ�œ�œ�œ˜>Jš
œ3˜3J˜&Jšœ�œ�œ˜.J˜šžœ�œ˜š�œ�œ�œ˜*Jš�œ˜Jšœ�œ˜#J˜——š�œ�œ�œ˜ š�œ˜Jš�œ�œ˜Jš�œ�œ
�œ˜—šžœ�œ�œ
�œ�œ�œ˜AJš�œ�œ˜$—Jš
œ˜Jšœ
�œ˜J˜J˜J˜Jš
œ˜Jš
œ!˜!J˜š
�˜Jšœ�œ˜.J˜3Jš�œ6˜8Jš�œ&�œ
�œ
�œ	˜;Jš�œ�œ
�œ
˜$J˜Jš�œ)�œ
˜:Jš�œ
˜—Jš	�œ�œ
�œ
�œ
Ÿ˜FJšœ
�œ˜'Jšœ�œ˜/Jš
œ˜Jš
œ"˜"J˜J˜"Jšœ:�œ
˜@š�œ�˜J˜BJš�œ*�œ
�œ
˜6šœ
�œ
�œ
�˜)Jšœ"�œ�œ
˜DJšœ&�œ
˜+Jšœ&�œ
˜+Jš�œ�œ˜—š
�˜š�œ˜Jš
�œ�œ�œ
�œ
�œ	˜G——Jš�œ
˜—J˜"šœ
�œ˜+Jš�œ˜Jš�œ˜ —J˜9š�œ˜Jš
�œ�œ!�œ
�œ
�œ	˜M—J˜6J˜š
�˜J˜.——Jš�œ˜J˜—J˜J˜———…—"¾2=