-- file LiteralPack.Mesa -- last modified by Satterthwaite, August 28, 1978 2:58 PM DIRECTORY AltoDefs: FROM "altodefs" USING [CharsPerWord], Literals: FROM "literals", LiteralOps: FROM "literalops", StringDefs: FROM "stringdefs" USING [ SubString, SubStringDescriptor, AppendChar, AppendSubString, EqualSubStrings, WordsForString], Table: FROM "table" USING [ Base, Finger, Notifier, Limit, AddNotify, Allocate, Bounds, DropNotify]; LiteralPack: PROGRAM IMPORTS StringDefs, Table EXPORTS LiteralOps = PUBLIC BEGIN OPEN Literals; ltb: PRIVATE Table.Base; -- literal table base stb: PRIVATE Table.Base; -- string table base UpdateBases: PRIVATE Table.Notifier = BEGIN -- called whenever the main symbol table is repacked ltb _ base[ltType]; stb _ base[stType]; RETURN END; initialized: PRIVATE BOOLEAN _ FALSE; Initialize: PROCEDURE = BEGIN -- called to set up the compiler's literal table shvi: SLitHVIndex; IF initialized THEN Finalize[]; [] _ ForgetEntries[]; FOR shvi IN SLitHVIndex DO sHashVec[shvi] _ MSTNull ENDLOOP; stLimit _ localStart _ FIRST[STIndex]; locals _ markBit _ FALSE; Table.AddNotify[UpdateBases]; initialized _ TRUE; RETURN END; Finalize: PROCEDURE = BEGIN -- closes the symbol table blocks initialized _ FALSE; Table.DropNotify[UpdateBases]; RETURN END; -- literal table management LitHVLength: PRIVATE INTEGER = 53; LitHVIndex: PRIVATE TYPE = [0..LitHVLength); hashVec: PRIVATE ARRAY LitHVIndex OF LTIndex; Find: PROCEDURE [v: WORD] RETURNS [lti: LTIndex] = BEGIN hvi: LitHVIndex = v MOD LitHVLength; FOR lti _ hashVec[hvi], ltb[lti].link UNTIL lti = LTNull DO WITH entry: ltb[lti] SELECT FROM short => IF entry.value = v THEN EXIT; ENDCASE; REPEAT FINISHED => BEGIN lti _ Table.Allocate[ltType, SIZE[short LTRecord]]; ltb[lti] _ LTRecord[datum: short[value: v], link: hashVec[hvi]]; hashVec[hvi] _ lti; END; ENDLOOP; RETURN END; FindMultiWord: PRIVATE PROCEDURE [baseP: Table.Finger, desc: LitDescriptor] RETURNS [lti: LTIndex] = BEGIN i: CARDINAL; v: WORD; hvi: LitHVIndex; lLti: Table.Base RELATIVE POINTER [0..Table.Limit/2) TO long LTRecord; v _ 0; FOR i IN [0 .. desc.length) DO v _ v + baseP^[desc.offset][i] ENDLOOP; hvi _ v MOD LitHVLength; FOR lti _ hashVec[hvi], ltb[lti].link UNTIL lti = LTNull DO WITH entry: ltb[lti] SELECT FROM long => IF desc.length = entry.length THEN FOR i IN [0 .. desc.length) DO IF entry.value[i] # baseP^[desc.offset][i] THEN EXIT; REPEAT FINISHED => GO TO found; ENDLOOP; ENDCASE; REPEAT found => NULL; FINISHED => BEGIN lLti _ Table.Allocate[ltType, SIZE[long LTRecord] + desc.length]; ltb[lLti] _ LTRecord[ link: hashVec[hvi], datum: long[codeIndex: 0, length: desc.length, value: ]]; FOR i IN [0 .. desc.length) DO ltb[lLti].value[i] _ baseP^[desc.offset][i] ENDLOOP; hashVec[hvi] _ lti _ lLti; END; ENDLOOP; RETURN END; Value: PROCEDURE [lti: LTIndex] RETURNS [WORD] = BEGIN WITH entry: ltb[lti] SELECT FROM short => RETURN [entry.value]; long => IF entry.length = 1 THEN RETURN [entry.value[0]]; ENDCASE; ERROR END; FindDescriptor: PROCEDURE [desc: DESCRIPTOR FOR ARRAY OF WORD] RETURNS [LTIndex] = BEGIN base: Table.Base _ LOOPHOLE[0]; RETURN [IF LENGTH[desc] = 1 THEN Find[desc[0]] ELSE FindMultiWord[@base, [offset:LOOPHOLE[BASE[desc]], length:LENGTH[desc]]]] END; DescriptorValue: PROCEDURE [lti: LTIndex] RETURNS [desc: LitDescriptor] = BEGIN WITH entry: ltb[lti] SELECT FROM short => desc _ [offset: LOOPHOLE[@entry.value-LOOPHOLE[ltb,CARDINAL]], length: 1]; long => desc _ [offset: LOOPHOLE[@entry.value-LOOPHOLE[ltb,CARDINAL]], length: entry.length]; ENDCASE => ERROR; RETURN END; CopyLiteral: PROCEDURE [literal: LTId] RETURNS [lti: LTIndex] = BEGIN desc: LitDescriptor; WITH entry: literal.baseP^[literal.index] SELECT FROM short => lti _ Find[entry.value]; long => BEGIN desc _ [ offset: LOOPHOLE[@entry.value-LOOPHOLE[literal.baseP^,CARDINAL]], length: entry.length]; lti _ FindMultiWord[literal.baseP, desc]; END; ENDCASE => ERROR END; ForgetEntries: PROCEDURE RETURNS [currentSize: CARDINAL] = BEGIN hvi: LitHVIndex; FOR hvi IN LitHVIndex DO hashVec[hvi] _ LTNull ENDLOOP; RETURN [Table.Bounds[ltType].size] END; -- string literal table management MSTNull: PRIVATE MSTIndex = LOOPHOLE[STNull]; SLitHVLength: PRIVATE INTEGER = 23; SLitHVIndex: PRIVATE TYPE = [0..SLitHVLength); sHashVec: PRIVATE ARRAY SLitHVIndex OF MSTIndex; stLimit, localStart: STIndex; locals: BOOLEAN; markBit: BOOLEAN; FindString: PROCEDURE [s: StringDefs.SubString] RETURNS [STIndex] = BEGIN CpW: CARDINAL = AltoDefs.CharsPerWord; hash: WORD; hvi: SLitHVIndex; i, nw: CARDINAL; sti: MSTIndex; v: STRING; desc: StringDefs.SubStringDescriptor; hash _ 0; FOR i IN [s.offset .. s.offset+s.length) DO hash _ hash + LOOPHOLE[s.base[i], CARDINAL] ENDLOOP; hvi _ hash MOD SLitHVLength; FOR sti _ sHashVec[hvi], stb[sti].link UNTIL sti = MSTNull DO v _ StringValue[sti]; desc _ [base:v, offset:0, length:v.length]; IF StringDefs.EqualSubStrings[s, @desc] THEN EXIT; REPEAT FINISHED => BEGIN nw _ StringDefs.WordsForString[s.length]; sti _ Table.Allocate[stType, SizeSTPrefix + nw]; stb[sti] _ STRecord[master[ info: 0, codeIndex: 0, local: FALSE, link: sHashVec[hvi], string: [ length: 0, maxlength: ((s.length + (CpW-1))/CpW) * CpW, text: ]]]; StringDefs.AppendSubString[@stb[sti].string, s]; FOR i IN [s.length .. stb[sti].string.maxlength) DO StringDefs.AppendChar[@stb[sti].string, 0C] ENDLOOP; stb[sti].string.length _ s.length; stLimit _ stLimit + (SizeSTPrefix + nw); sHashVec[hvi] _ sti; END; ENDLOOP; RETURN [sti] END; MasterString: PROCEDURE [sti: STIndex] RETURNS [MSTIndex] = BEGIN RETURN [WITH s: stb[sti] SELECT FROM master => LOOPHOLE[sti], copy => s.link, ENDCASE => MSTNull] END; StringReference: PROCEDURE [sti: STIndex] = BEGIN WITH s: stb[sti] SELECT FROM master => s.info _ s.info + 1; ENDCASE => NULL; RETURN END; StringValue: PROCEDURE [sti: STIndex] RETURNS [STRING] = BEGIN RETURN[@stb[MasterString[sti]].string] END; ResetLocalStrings: PROCEDURE RETURNS [key: STIndex] = BEGIN IF ~locals THEN key _ STNull ELSE BEGIN key _ localStart; markBit _ ~markBit END; locals _ FALSE; localStart _ LOOPHOLE[Table.Bounds[stType].size]; RETURN END; FindLocalString: PROCEDURE [key: STIndex] RETURNS [sti: STIndex] = BEGIN next: STIndex; master: MSTIndex = MasterString[key]; FOR sti _ localStart, next UNTIL sti = stLimit DO WITH s: stb[sti] SELECT FROM master => next _ sti + SizeSTPrefix + StringDefs.WordsForString[s.string.maxlength]; copy => BEGIN IF s.link = master THEN EXIT; next _ sti + SIZE[copy STRecord]; END; ENDCASE; REPEAT FINISHED => BEGIN sti _ Table.Allocate[stType, SIZE[copy STRecord]]; stb[sti] _ STRecord[copy[mark: markBit, link: master]]; stLimit _ stLimit + SIZE[copy STRecord]; locals _ TRUE; END; ENDLOOP; RETURN END; EnumerateLocalStrings: PROCEDURE [key: STIndex, proc: PROCEDURE [MSTIndex]] = BEGIN sti, next: STIndex; started, mark: BOOLEAN; IF key = STNull THEN RETURN; started _ FALSE; FOR sti _ key, next UNTIL sti = stLimit DO WITH s: stb[sti] SELECT FROM master => next _ sti + SizeSTPrefix + StringDefs.WordsForString[s.string.maxlength]; copy => BEGIN IF ~started THEN BEGIN mark _ s.mark; started _ TRUE END; IF s.mark # mark THEN EXIT; proc[s.link]; next _ sti + SIZE[copy STRecord]; END; ENDCASE => ERROR; ENDLOOP; END; EnumerateMasterStrings: PROCEDURE [proc: PROCEDURE [MSTIndex]] = BEGIN sti, next: STIndex; FOR sti _ FIRST[STIndex], next UNTIL sti = stLimit DO WITH s: stb[sti] SELECT FROM master => BEGIN proc[LOOPHOLE[sti]]; next _ sti + SizeSTPrefix + StringDefs.WordsForString[s.string.maxlength]; END; copy => next _ sti + SIZE[copy STRecord]; ENDCASE => ERROR; ENDLOOP; RETURN END; END.