DIRECTORY
Basics USING [LowByte, LowHalf],
Convert USING [AppendCard, AppendInt, AppendReal, CardFromRope, Error],
TJaMBasic USING [Object, StringLength, Tag],
TJaMInternal USING [Frame],
TJaMOps USING [Error, Install, InstallReason, NameToString, Pop, PopCardinal, PopInteger, PopString, Push, PushBoolean, PushInteger, rangechk, RegisterExplicit, Text],
TJaMVM USING [AllocString, CopyString, GetChar, GetText, PutChar, PutText];

TJaMStringImpl: PROGRAM
IMPORTS Basics, Convert, TJaMOps, TJaMVM
EXPORTS TJaMOps = {

lengthLimit: CARDINAL = LAST[TJaMBasic.StringLength];
true,false,novalue: string TJaMBasic.Object;
Head: PROC[s: string TJaMBasic.Object, n: CARDINAL] RETURNS[string TJaMBasic.Object] = INLINE {
IF n<s.length THEN s.length _ n; RETURN[s] 
};
Tail: PROC[s: string TJaMBasic.Object, n: CARDINAL] RETURNS[string TJaMBasic.Object] = INLINE {
IF n>s.length THEN n _ s.length; s.length _ s.length - n; n _ s.offset + n;
s.text _ s.text + n/2; s.offset _ n MOD 2; RETURN[s] 
};

String: PUBLIC PROC[length: TJaMBasic.StringLength] RETURNS[string TJaMBasic.Object] = {
s: string TJaMBasic.Object _ TJaMVM.AllocString[length];
s.tag _ L; RETURN[s];
};

SCopy: PUBLIC PROC[string: string TJaMBasic.Object, expand: CARDINAL _ 0]
RETURNS[string TJaMBasic.Object] = {
oldlen: CARDINAL = string.length;
newlen: CARDINAL = oldlen + MIN[expand,lengthLimit-oldlen];
new: string TJaMBasic.Object _ TJaMVM.AllocString[newlen];
TJaMVM.CopyString[src: string, dst: new]; RETURN[new];
};

SubString: PUBLIC PROC[s: string TJaMBasic.Object, beg,len: CARDINAL]
RETURNS[string TJaMBasic.Object] = {
IF beg>s.length OR len>(s.length-beg) THEN ERROR TJaMOps.Error[TJaMOps.rangechk];
RETURN[Head[Tail[s,beg],len]];
};

PutString: PUBLIC PROC[from: string TJaMBasic.Object, beg: CARDINAL, into: string TJaMBasic.Object] = {
IF beg>into.length OR from.length>(into.length-beg) THEN ERROR TJaMOps.Error[TJaMOps.rangechk];
TJaMVM.CopyString[from,Tail[into,beg]];
};

StringCompare: PUBLIC PROC[a,b: string TJaMBasic.Object] RETURNS[INTEGER] = {
FOR i: CARDINAL IN[0..MIN[a.length,b.length]) DO
ca: CHARACTER _ TJaMVM.GetChar[a,i];
cb: CHARACTER _ TJaMVM.GetChar[b,i];
IF ca#cb THEN RETURN[IF ca<cb THEN -1 ELSE 1];
ENDLOOP;
IF a.length=b.length THEN RETURN[0]
ELSE RETURN[IF a.length<b.length THEN -1 ELSE 1];
};

StringMatch: PROC[s,t: string TJaMBasic.Object, j: CARDINAL] RETURNS[BOOLEAN] = INLINE {
FOR i: CARDINAL IN[0..s.length) DO
IF TJaMVM.GetChar[s,i] # TJaMVM.GetChar[t,j+i] THEN RETURN[FALSE];
ENDLOOP;
RETURN[TRUE];
};

MakeString: PUBLIC PROC[text: TJaMOps.Text, tag: TJaMBasic.Tag _ L] RETURNS[string TJaMBasic.Object] = {
string: string TJaMBasic.Object _ String[text.length];
TJaMVM.PutText[string,text]; string.tag _ tag;
RETURN[string];
};

StringText: PUBLIC PROC[string: string TJaMBasic.Object, text: TJaMOps.Text] = {
TJaMVM.GetText[string,text];
};

StringForAll: PUBLIC PROC[string: string TJaMBasic.Object,
proc: PROC[CHARACTER] RETURNS[BOOLEAN]] = {
FOR i: CARDINAL IN[0..string.length) DO
c: CHARACTER _ TJaMVM.GetChar[string,i];
IF proc[c] THEN EXIT;
ENDLOOP;
};

JString: PUBLIC PROC[frame: TJaMInternal.Frame] = {
n: CARDINAL _ TJaMOps.PopCardinal[frame.opstk,lengthLimit];
TJaMOps.Push[frame.opstk,String[n]];
};

JCopyString: PUBLIC PROC[frame: TJaMInternal.Frame] = {
s: string TJaMBasic.Object _ TJaMOps.PopString[frame.opstk];
TJaMOps.Push[frame.opstk,SCopy[s]];
};

JSubString: PUBLIC PROC[frame: TJaMInternal.Frame] = {
len: CARDINAL _ TJaMOps.PopCardinal[frame.opstk];
beg: CARDINAL _ TJaMOps.PopCardinal[frame.opstk];
s: string TJaMBasic.Object _ TJaMOps.PopString[frame.opstk];
t: string TJaMBasic.Object _ SubString[s,beg,len];
TJaMOps.Push[frame.opstk,t];
};

JPutString: PUBLIC PROC[frame: TJaMInternal.Frame] = {
s: string TJaMBasic.Object _ TJaMOps.PopString[frame.opstk];
beg: CARDINAL _ TJaMOps.PopCardinal[frame.opstk];
t: string TJaMBasic.Object _ TJaMOps.PopString[frame.opstk];
PutString[s,beg,t];
TJaMOps.Push[frame.opstk,t];
};

JSGet: PUBLIC PROC[frame: TJaMInternal.Frame] = {
i: CARDINAL _ TJaMOps.PopCardinal[frame.opstk];
s: string TJaMBasic.Object _ TJaMOps.PopString[frame.opstk];
item: INTEGER;
IF i NOT IN[0..s.length) THEN ERROR TJaMOps.Error[TJaMOps.rangechk];
item _ LOOPHOLE[TJaMVM.GetChar[s,i]];
TJaMOps.PushInteger[frame.opstk,item];
};

JSPut: PUBLIC PROC[frame: TJaMInternal.Frame] = {
item: INTEGER _ Basics.LowHalf[TJaMOps.PopInteger[frame.opstk]];
i: CARDINAL _ TJaMOps.PopCardinal[frame.opstk];
s: string TJaMBasic.Object _ TJaMOps.PopString[frame.opstk];
c: CHARACTER;
IF i NOT IN[0..s.length) THEN ERROR TJaMOps.Error[TJaMOps.rangechk];
c _ LOOPHOLE[Basics.LowByte[item]];
TJaMVM.PutChar[s,i,c];
};

StringSearch: PUBLIC PROC[frame: TJaMInternal.Frame] = {
s: string TJaMBasic.Object _ TJaMOps.PopString[frame.opstk];
t: string TJaMBasic.Object _ TJaMOps.PopString[frame.opstk];
FOR j: CARDINAL IN[0..t.length) WHILE (t.length - j) < s.length DO
IF StringMatch[s,t,j] THEN { -- j is match position in t
r: string TJaMBasic.Object _ Tail[t,j];
TJaMOps.Push[frame.opstk,Tail[r,s.length]]; -- part of t following match
TJaMOps.Push[frame.opstk,Head[r,s.length]]; -- part of t matching s
TJaMOps.Push[frame.opstk,Head[t,j]]; -- part of t preceding match
TJaMOps.PushBoolean[frame.opstk,TRUE];
RETURN 
};
ENDLOOP;
TJaMOps.Push[frame.opstk,t]; -- no match, just push t
TJaMOps.PushBoolean[frame.opstk,FALSE];
};

StringAnchorSearch: PUBLIC PROC[frame: TJaMInternal.Frame] = {
s: string TJaMBasic.Object _ TJaMOps.PopString[frame.opstk];
t: string TJaMBasic.Object _ TJaMOps.PopString[frame.opstk];
IF (t.length >= s.length) AND StringMatch[s,t,0] THEN {
TJaMOps.Push[frame.opstk,Tail[t,s.length]]; -- remainder of t following match
TJaMOps.Push[frame.opstk,Head[t,s.length]]; -- part of t matching s
TJaMOps.PushBoolean[frame.opstk,TRUE] 
}
ELSE {
TJaMOps.Push[frame.opstk,t]; -- no match, just push t
TJaMOps.PushBoolean[frame.opstk,FALSE] 
};
};

AppendInteger: PROC[s: LONG STRING, i: INT, rdx: CARDINAL _ 10] = {
IF rdx=10
THEN [] _ Convert.AppendInt[LOOPHOLE[s], i, 10]
ELSE [] _ Convert.AppendCard[LOOPHOLE[s], LOOPHOLE[i], 8];
};

AppendChar: PROC[s: LONG STRING, c: CHAR] = {
s[s.length] _ c;
s.length _ s.length + 1;
};

AppendReal: PROC[s: LONG STRING, r: REAL] = {
[] _ Convert.AppendReal[LOOPHOLE[s], r];
};

ConvertToString: PUBLIC PROC[frame: TJaMInternal.Frame] = {
ob: TJaMBasic.Object _ TJaMOps.Pop[frame.opstk];
string: string TJaMBasic.Object _ novalue;
s: STRING _ [50];
WITH ob:ob SELECT FROM
integer => { AppendInteger[s,ob.ivalue]; string _ MakeString[s] };
real => { AppendReal[s,ob.rvalue]; string _ MakeString[s] };
boolean => string _ (IF ob.bvalue THEN true ELSE false);
string => string _ ob;
name => string _ SCopy[TJaMOps.NameToString[ob]]; -- make a copy!
ENDCASE;
TJaMOps.Push[frame.opstk,string];
};

ConvertToRadixString: PUBLIC PROC[frame: TJaMInternal.Frame] = {
rdx: CARDINAL _ TJaMOps.PopCardinal[frame.opstk];
ob: TJaMBasic.Object _ TJaMOps.Pop[frame.opstk];
string: string TJaMBasic.Object _ novalue;
s: STRING _ [50];
IF rdx NOT IN[2..36] THEN ERROR TJaMOps.Error[TJaMOps.rangechk];
WITH ob:ob SELECT FROM
integer => { AppendInteger[s,ob.ivalue,rdx]; string _ MakeString[s] };
real => { AppendInteger[s,LOOPHOLE[ob.rvalue],rdx]; string _ MakeString[s] };
ENDCASE;
TJaMOps.Push[frame.opstk,string];
};

TextIntoString: PROC[from: TJaMOps.Text, into: string TJaMBasic.Object] RETURNS[string TJaMBasic.Object] = {
IF from.length>into.length THEN ERROR TJaMOps.Error[TJaMOps.rangechk];
into.length _ from.length; TJaMVM.PutText[into,from]; RETURN[into] 
};

StringIntoString: PROC[from,into: string TJaMBasic.Object] RETURNS[string TJaMBasic.Object] = {
PutString[from,0,into]; into.length _ from.length; RETURN[into] 
};

ConvertIntoString: PUBLIC PROC[frame: TJaMInternal.Frame] = {
string: string TJaMBasic.Object _ TJaMOps.PopString[frame.opstk];
ob: TJaMBasic.Object _ TJaMOps.Pop[frame.opstk];
result: string TJaMBasic.Object _ novalue;
s: STRING _ [50];
WITH ob:ob SELECT FROM
integer => { AppendInteger[s,ob.ivalue]; result _ TextIntoString[s,string] };
real => { AppendReal[s,ob.rvalue]; result _ TextIntoString[s,string] };
boolean => result _ (IF ob.bvalue THEN true ELSE false);
string => result _ ob;
name => result _ StringIntoString[TJaMOps.NameToString[ob],string];
ENDCASE;
TJaMOps.Push[frame.opstk,result];
};

ConvertIntoRadixString: PUBLIC PROC[frame: TJaMInternal.Frame] = {
string: string TJaMBasic.Object _ TJaMOps.PopString[frame.opstk];
rdx: CARDINAL _ TJaMOps.PopCardinal[frame.opstk];
ob: TJaMBasic.Object _ TJaMOps.Pop[frame.opstk];
result: string TJaMBasic.Object _ novalue;
s: STRING _ [50];
IF rdx NOT IN[2..36] THEN ERROR TJaMOps.Error[TJaMOps.rangechk];
WITH ob:ob SELECT FROM
integer => { AppendInteger[s,ob.ivalue,rdx]; result _ TextIntoString[s,string] };
real => { AppendInteger[s,LOOPHOLE[ob.rvalue],rdx]; result _ TextIntoString[s,string] };
ENDCASE;
TJaMOps.Push[frame.opstk,result];
};

ConvertOctalString: PUBLIC PROC[frame: TJaMInternal.Frame] = {
string: string TJaMBasic.Object _ TJaMOps.PopString[frame.opstk];
s: LONG STRING _ [20];
c: LONG CARDINAL;
IF string.length>s.maxlength THEN ERROR TJaMOps.Error[TJaMOps.rangechk];
TJaMVM.GetText[string,s];
c _ Convert.CardFromRope[LOOPHOLE[s], 8 ! Convert.Error => GO TO err];
EXITS
err => ERROR TJaMOps.Error[TJaMOps.rangechk]
};

InstallString: PROC[why: TJaMOps.InstallReason, frame: TJaMInternal.Frame] = { SELECT why FROM
register => {
true _ MakeString[".true"L];
false _ MakeString[".false"L];
novalue _ MakeString["--nostringval--"L];
TJaMOps.RegisterExplicit[frame,".string"L,JString];
TJaMOps.RegisterExplicit[frame,".copystring"L,JCopyString];
TJaMOps.RegisterExplicit[frame,".substring"L,JSubString];
TJaMOps.RegisterExplicit[frame,".putstring"L,JPutString];
TJaMOps.RegisterExplicit[frame,".sget"L,JSGet];
TJaMOps.RegisterExplicit[frame,".sput"L,JSPut];
TJaMOps.RegisterExplicit[frame,".search"L,StringSearch];
TJaMOps.RegisterExplicit[frame,".asearch"L,StringAnchorSearch];
TJaMOps.RegisterExplicit[frame,".cvs"L,ConvertToString];
TJaMOps.RegisterExplicit[frame,".cvis"L,ConvertIntoString];
TJaMOps.RegisterExplicit[frame,".cvrs"L,ConvertToRadixString];
TJaMOps.RegisterExplicit[frame,".cvos"L,ConvertOctalString];
TJaMOps.RegisterExplicit[frame,".cvirs"L,ConvertIntoRadixString];
};
ENDCASE;
};

TJaMOps.Install[InstallString];
}.


ΈTJaMStringImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Original version John Warnock, January, 1979
Bill Paxton, February 6, 1981  9:31 AM
Doug Wyatt,  7-Oct-81 17:17:49
McGregor, September 10, 1982 11:22 am
Russ Atkinson, September 26, 1983 1:04 pm
Michael Plass, February 14, 1985 12:59:21 pm PST
Constants
Globals
The following routines implement a set of string manipulations.
Intrinsics
Initialization
Κ

˜š
œ™Icodešœ
Οm
œ1™<Jš
œ,™,Jš
œ&™&Jš
œ™Jš
œ%™%Jš
œ)™)Jš
œ0™0—J˜š
Οk	˜	Jšœžœ˜ Jšœžœ:˜GJšœ
žœ˜,Jšœ
žœ	˜Jšœžœš
˜§
Jšœžœ?˜K—J˜šœž˜Jšžœ!˜(Jšžœ˜J˜Jš
œ	™	Jšœ
žœžœ˜5Jš
œ™J˜,Jš
œ?™?š
Οnœžœ žœžœžœ˜_Jšžœžœžœ˜+J˜—š
Ÿœžœ žœžœžœ˜_Jšžœžœ9˜KJšœ$žœžœ˜5J˜J˜—šŸœžœ
žœ!žœ˜XJ˜8Jšœž
œžœ˜J˜J˜—šŸœžœ
žœ*žœ˜IJšžœ˜$Jšœžœ˜!Jšœžœžœ˜;J˜:Jšœ*žœ˜6J˜J˜—JšŸ	œžœ
žœ&žœ
˜Ešžœ˜$Jšžœžœžœ
žœ!˜QJšžœ˜J˜J˜—šŸ	œžœ
žœ%žœ$˜gJšžœžœžœ
žœ!˜_J˜'J˜J˜—š
Ÿ
œžœ
žœžœ
žœ˜Mš	žœžœ
žœžœž˜0Jšœž	œ˜$Jšœž	œ˜$Jšžœžœ
žœ
žœžœžœ˜.Jšžœ
˜—Jšžœžœ
žœ˜#Jš
žœ
žœ
žœžœžœ˜1J˜J˜—šŸœžœ"žœžœ
žœžœ˜Xšžœžœ
žœž˜"Jšžœ-žœ
žœ
žœ˜BJšžœ
˜—Jšžœ
žœ˜
J˜J˜—š
Ÿ
œžœ
žœ*ž
œžœ˜hJ˜6J˜.Jšžœ	˜J˜J˜—šŸ
œžœ
žœ9˜PJ˜J˜J˜—šŸœžœ
žœ!˜:Jš	œžœ
ž	œžœ
žœ˜+šžœžœ
žœž˜'Jšœž	œ˜(Jšžœ	žœ
žœ
˜Jšžœ
˜—J˜J˜—Jš
œ
™
šŸœžœ
žœ˜3Jšœžœ0˜;J˜$J˜J˜—šŸœžœ
žœ˜7J˜<J˜#J˜J˜—šŸ
œžœ
žœ˜6Jšœžœ$˜1Jšœžœ$˜1J˜<J˜2J˜J˜J˜—šŸ
œžœ
žœ˜6J˜<Jšœžœ$˜1J˜<J˜J˜J˜J˜—šŸœžœ
žœ˜1Jšœžœ$˜/J˜<Jšœžœ
˜Jš
žœžœ
žœžœ
žœ!˜DJšœžœ˜%J˜&J˜J˜—šŸœžœ
žœ˜1Jšœžœ3˜@Jšœžœ$˜/J˜<Jšœž	œ
˜
Jš
žœžœ
žœžœ
žœ!˜DJšœžœ˜#J˜J˜J˜—šŸœžœ
žœ˜8J˜<J˜<š	žœžœ
žœžœž˜BšžœžœΟc˜8J˜'Jšœ, ˜HJšœ, ˜CJšœ% ˜AJšœ žœ˜&Jšžœ
˜J˜—Jšžœ
˜—Jšœ ˜5Jšœ žœ˜'J˜J˜—šŸœžœ
žœ˜>J˜<J˜<šžœžœžœ˜7Jšœ, !˜MJšœ, ˜CJšœ žœ˜&J˜
—šžœ˜Jšœ ˜5Jšœ žœ˜'J˜—J˜J˜—šŸ
œžœžœ
žœžœžœ
˜CJšžœ˜	šžœžœ˜/Jšžœžœžœ˜:—J˜J˜—š
Ÿ
œžœžœ
žœžœ˜-J˜J˜J˜J˜—š
Ÿ
œžœžœ
žœžœ˜-Jšœžœ˜(J˜J˜—šŸœžœ
žœ˜;J˜0J˜*Jšœžœ˜šžœžœ
ž˜J˜BJ˜<Jšœžœžœžœ˜8J˜Jšœ2 ˜AJšžœ
˜—J˜!J˜J˜—šŸœžœ
žœ˜@Jšœžœ$˜1J˜0J˜*Jšœžœ˜Jš
žœžœ
žœžœ
žœ!˜@šžœžœ
ž˜J˜FJšœžœ+˜MJšžœ
˜—J˜!J˜J˜—šŸœžœ4žœ˜lJšžœžœ
žœ!˜FJšœ6žœ˜CJ˜J˜—šŸœžœ%žœ˜_Jšœ3žœ˜@J˜J˜—šŸœžœ
žœ˜=J˜AJ˜0J˜*Jšœžœ˜šžœžœ
ž˜J˜MJ˜GJšœžœžœžœ˜8J˜J˜CJšžœ
˜—J˜!J˜J˜—šŸœžœ
žœ˜BJ˜AJšœžœ$˜1J˜0J˜*Jšœžœ˜Jš
žœžœ
žœžœ
žœ!˜@šžœžœ
ž˜J˜QJšœžœ6˜XJšžœ
˜—J˜!J˜J˜—šŸœžœ
žœ˜>J˜AJšœžœ
žœ˜Jšœžœ
žœ
˜Jšžœžœ
žœ!˜HJ˜Jšœžœžœ
žœ˜FJš
ž˜Jšœžœ ˜,J˜J˜—Jš
œ™šŸ
œžœ<žœž˜^˜
J˜J˜J˜)J˜3J˜;J˜9J˜9J˜/J˜/J˜8J˜?J˜8J˜;J˜>J˜<J˜AJ˜—Jšžœ
˜J˜J˜—J˜J˜J˜——…—(`4%