<<>> <> <> <> <> <> <> <> DIRECTORY RefText, Rope, UXStrings; UXStringsImpl: CEDAR MONITOR IMPORTS RefText, Rope EXPORTS UXStrings ~ BEGIN OPEN UXStrings; ToRope: PUBLIC PROC [from: CString, maxLength: INT Ź LAST[INT]] RETURNS [r: Rope.ROPE] = TRUSTED { len, pos: INT Ź 0; PerChar: PROC RETURNS [c: CHAR] = TRUSTED { c Ź from[pos]; pos Ź pos+1; }; IF from=NIL THEN RETURN[NIL]; WHILE from[len]#'\000 AND len < maxLength DO len Ź len + 1 ENDLOOP; IF len = 0 THEN RETURN[NIL]; RETURN [Rope.FromProc[len, PerChar]]; }; CharSequence: TYPE ~ RECORD[ seq: PACKED SEQUENCE COMPUTED CARD OF CHAR ]; Create: PUBLIC PROC [from: REF] RETURNS [string: CString] = { WITH from SELECT FROM r: Rope.ROPE => { len: INT Ź Rope.Length[r]; rtn: REF CharSequence Ź NEW[CharSequence[len+1]]; TRUSTED { FOR i: INT IN [0..len) DO rtn[i] Ź r.Fetch[i] ENDLOOP; rtn[len] Ź '\000; }; string Ź LOOPHOLE[rtn]; }; r: REF TEXT => { len: INT Ź RefText.Length[r]; rtn: REF CharSequence Ź NEW[CharSequence[len+1]]; TRUSTED { FOR i: INT IN [0..len) DO rtn[i] Ź r[i] ENDLOOP; rtn[len] Ź '\000; }; string Ź LOOPHOLE[rtn]; }; ENDCASE => IF from=NIL THEN TRUSTED { rtn: REF CharSequence Ź NEW[CharSequence[1]]; rtn[0] Ź '\000; string Ź LOOPHOLE[rtn]; } ELSE ERROR; --not implemented type }; CreateSpace: PUBLIC PROC [size: INT] RETURNS [string: CString] ~ { rtn: REF CharSequence Ź NEW[CharSequence[size+1]]; string Ź LOOPHOLE[rtn]; }; CopyRefToString: PUBLIC UNSAFE PROC [ref: REF, string: CString] ~ UNCHECKED { rtn: REF CharSequence Ź LOOPHOLE[string]; WITH ref SELECT FROM r: Rope.ROPE => { len: INT Ź Rope.Length[r]; TRUSTED { FOR i: INT IN [0..len) DO rtn[i] Ź r.Fetch[i] ENDLOOP; rtn[len] Ź '\000; }; }; r: REF TEXT => { len: INT Ź RefText.Length[r]; TRUSTED { FOR i: INT IN [0..len) DO rtn[i] Ź r[i] ENDLOOP; rtn[len] Ź '\000; }; }; ENDCASE => IF ref=NIL THEN TRUSTED { rtn[0] Ź '\000; } ELSE ERROR; --not implemented type }; ViewRefText: PUBLIC UNSAFE PROC [from: REF TEXT] RETURNS [string: CString] ~ { RETURN[ LOOPHOLE[LOOPHOLE[from, CARD]+UNITS[TEXT[0]]]] }; <> StringIndex: TYPE = [0..1]; StringMaxLength: ARRAY StringIndex OF INT = [100, 512]; NStringsToAllocate: ARRAY StringIndex OF NAT = [8, 2]; available: ARRAY StringIndex OF LIST OF CString Ź ALL[NIL]; reserved: ARRAY StringIndex OF LIST OF CString Ź ALL[NIL]; InterestingQuantity: TYPE = {obtainCalled, nCharsTooLarge, availEmpty}; Counts: ARRAY InterestingQuantity OF INT Ź ALL[0]; Bump: INTERNAL PROC [q: InterestingQuantity] = INLINE { Counts[q] Ź Counts[q] + 1 }; Error: PUBLIC ERROR [ec: ErrorCode] = CODE; CreateScratch: PUBLIC PROC [from: REF] RETURNS [string: CString] ~ { WITH from SELECT FROM r: Rope.ROPE => { len: INT Ź Rope.Length[r]; rtn: POINTER TO CharSequence Ź LOOPHOLE[ObtainScratch[len]]; TRUSTED { FOR i: INT IN [0..len) DO rtn[i] Ź r.Fetch[i] ENDLOOP; rtn[len] Ź '\000; }; string Ź LOOPHOLE[rtn]; }; r: REF TEXT => { len: INT Ź RefText.Length[r]; rtn: POINTER TO CharSequence Ź LOOPHOLE[ObtainScratch[len]]; TRUSTED { FOR i: INT IN [0..len) DO rtn[i] Ź r[i] ENDLOOP; rtn[len] Ź '\000; }; string Ź LOOPHOLE[rtn]; }; ENDCASE => IF from=NIL THEN TRUSTED { rtn: POINTER TO CharSequence Ź LOOPHOLE[ObtainScratch[0]]; rtn[0] Ź '\000; string Ź LOOPHOLE[rtn]; } ELSE ERROR; --not implemented type }; <<>> ObtainScratch: PUBLIC ENTRY PROC [nChars: INT] RETURNS [CString] = TRUSTED { i: StringIndex Ź 0; avail: LIST OF CString; Bump[obtainCalled]; FOR i IN [0 .. LAST[StringIndex]] DO IF nChars <= StringMaxLength[i] THEN EXIT; REPEAT FINISHED => { <> Bump[nCharsTooLarge]; RETURN [CreateSpace[nChars]]; }; ENDLOOP; IF (avail Ź available[i].rest) = NIL THEN { <> r: LIST OF CString; Bump[availEmpty]; r Ź reserved[i]; UNTIL r.rest.rest = NIL DO r Ź r.rest ENDLOOP; avail Ź r.rest; r.rest Ź NIL; avail.first Ź CreateSpace[StringMaxLength[i]] }; <> available[i].rest Ź avail.rest; avail.rest Ź reserved[i].rest; reserved[i].rest Ź avail; IF avail.first[0] # '\000 THEN RETURN WITH ERROR Error[clientModifiedReleasedString]; RETURN [avail.first]; }; ReleaseScratch: PUBLIC ENTRY PROC [s: CString] = TRUSTED { i: StringIndex Ź 0; r, l: LIST OF CString; IF s = NIL THEN RETURN; FOR i IN [0 .. LAST[StringIndex]] DO r Ź reserved[i]; WHILE (l Ź r.rest) # NIL DO IF l.first = s THEN { r.rest Ź l.rest; l.rest Ź available[i].rest; available[i].rest Ź l; s[0] Ź '\000; RETURN; }; r Ź l; ENDLOOP; ENDLOOP; }; InitializeScratchPool: ENTRY PROC [] = { FOR i: StringIndex IN StringIndex DO reserved[i] Ź CONS[NIL, NIL]; <> FOR j: NAT IN [0..NStringsToAllocate[i]] DO available[i] Ź CONS[NIL, available[i]]; ENDLOOP; ENDLOOP; FOR i: StringIndex IN StringIndex DO <> l: LIST OF CString Ź available[i].rest; WHILE l # NIL DO l.first Ź CreateSpace[StringMaxLength[i]]; l Ź l.rest; ENDLOOP; ENDLOOP; }; InitializeScratchPool[]; END. <> <>