
DIRECTORY Ascii, Basics, BasicTime, Convert, FS, IO, OrderedSymbolTableRef, Real, Rope, TermCaps;

TermCapsImpl: CEDAR PROGRAM
IMPORTS Ascii, BasicTime, Convert, FS, IO, OrderedSymbolTableRef, Real, Rope
EXPORTS TermCaps

 = {OPEN TermCaps;

cancel: PUBLIC Val м NEW [ROPE м "cancel"];

Bitch: SIGNAL [fmt: ROPE, v1: IO.Value м [null[]]] = CODE;
Busted: ERROR = CODE;

termCaps: SymbolTable м NIL;
defaultTerm: Term м NIL;

EnumerateCaps: PUBLIC PROC [term: Term, consume: PROC [cap: Cap] RETURNS [stop: BOOL]] = {
ExceptNone: PROC [cap: Cap] RETURNS [e: BOOL] = {e м FALSE};
Work: PROC [term: Term, except: PROC [cap: Cap] RETURNS [BOOL]] = {
ExceptMine: PROC [cap: Cap] RETURNS [e: BOOL] = {
IF term.caps.Lookup[cap] # NIL THEN RETURN [TRUE];
e м except[cap]};
PerCap: PROC [ra: REF ANY] RETURNS [stop: BOOL] = {
cap: Cap м NARROW[ra];
stop м FALSE;
IF cap.val = cancel THEN RETURN;
IF except[cap] THEN RETURN;
stop м consume[cap];
};
term.caps.EnumerateIncreasing[PerCap];
IF term.default # NIL THEN Work[term.default, ExceptMine];
};
Work[term, ExceptNone];
};

GetCap: PUBLIC PROC [term: Term, name: ROPE, default: Val м NIL] RETURNS [val: Val] = {
cap: Cap м NARROW[term.caps.Lookup[name]];
IF cap # NIL THEN RETURN [IF cap.val = cancel THEN default ELSE cap.val];
IF term.default # NIL THEN val м GetCap[term.default, name, default] ELSE val м default;
};

GetTerm: PUBLIC PROC [tc: TermCap, name: ROPE] RETURNS [term: Term] = {
term м AntiAlias[tc.contents.Lookup[name]];
};

TCTerm: PROC [tc: TermCap, name: ROPE] RETURNS [term: Term] = {
term м AntiAlias[tc.contents.Lookup[name]];
IF term = NIL THEN {
a: Alias м NEW [AliasRep м [
name: name,
val: term м NEW [TermRep м [
names: LIST[name],
caps: OrderedSymbolTableRef.CreateTable[CompareCaps],
default: defaultTerm]]
]];
tc.contents.Insert[a];
};
};

EnumerateTerms: PUBLIC PROC [tc: TermCap, consume: PROC [term: Term] RETURNS [stop: BOOL]] = {
PerAlias: PROC [ra: REF ANY] RETURNS [stop: BOOL] = {
a: Alias м NARROW[ra];
IF NOT (a.name = a.val.names.first) THEN RETURN [FALSE];
stop м consume[a.val];
};
tc.contents.EnumerateIncreasing[PerAlias];
};

GetTermCap: PUBLIC PROC [fileName: ROPE, wDir: ROPE м NIL] RETURNS [tc: TermCap] = {
gName: ROPE;
created: GMT;
exists: BOOL м TRUE;
rfi: REF FileID;
from: IO.STREAM;
[fullFName: gName, created: created] м FS.FileInfo[name: fileName, wDir: wDir !FS.Error => {exists м FALSE; CONTINUE}];
IF NOT exists THEN RETURN [NIL];
rfi м NEW [FileID м [gName, created]];
tc м NARROW[termCaps.Lookup[rfi]];
IF tc # NIL THEN RETURN [tc];
tc м NEW [TermCapRep м [
fileID: rfiн,
contents: OrderedSymbolTableRef.CreateTable[CompareTerms]
]];
from м FS.StreamOpen[gName];
termCaps.Insert[tc];
ParseTermCap[from, tc !
Bitch => {
tc.complaints м tc.complaints.Cat[
IO.PutFR[
Rope.Cat["At %g[%g]: ", fmt, "\n"],
IO.rope[gName],
IO.int[from.GetIndex[]],
v1]
];
RESUME;
};
IO.EndOfStream => CONTINUE;
];
};

ParseTermCap: PROC [from: IO.STREAM, tc: TermCap] = {
atStart: BOOL м TRUE;
DO
ENABLE Busted => {Bitch["busted"]; LOOP};
term: Term м NIL;
names: RopeList м NIL;
nameCount: NAT м 0;
bestName: ROPE м NIL;
DO
char: CHAR;
IF atStart THEN atStart м FALSE ELSE [] м from.GetLineRope[];
char м from.PeekChar[];
SELECT char FROM
IN ['a .. 'z], IN ['A .. 'Z] => EXIT;
ENDCASE;
ENDLOOP;
DO
name, sep: ROPE;
namedTerm: Term;
name м from.GetTokenRope[TermNameBuster].token;
IF name.Equal["|"] THEN {Bitch["empty name"]; LOOP};
IF name.Equal[":"] THEN {Bitch["empty name"]; EXIT};
nameCount м nameCount + 1;
IF nameCount <= 2 THEN bestName м name;
namedTerm м GetTerm[tc, name];
IF namedTerm = term THEN NULL
ELSE IF term = NIL THEN term м namedTerm
ELSE IF namedTerm # NIL THEN Bitch["term name collision on %g", IO.rope[name]];
IF namedTerm = NIL THEN names м CONS[name, names];
sep м from.GetTokenRope[TermNameBuster].token;
IF sep.Equal[":"] THEN EXIT;
IF NOT sep.Equal["|"] THEN ERROR;
ENDLOOP;
IF term = NIL THEN term м NEW [TermRep м [
caps: OrderedSymbolTableRef.CreateTable[CompareCaps],
default: defaultTerm
]];
term.bestName м bestName;
FOR names м names, names.rest WHILE names # NIL DO
a: Alias м NEW [AliasRep м [names.first, term]];
term.names м CONS[names.first, term.names];
tc.contents.Insert[a !OrderedSymbolTableRef.DuplicateKey => {
CONTINUE--can only collide with same term--}];
ENDLOOP;
DO
capName: ROPE;
cap: Cap;
cancelIt: BOOL м FALSE;
char: CHAR;
IF from.PeekChar[] = '\\ THEN {
char: CHAR;
IF (char м from.GetChar[]) # '\\ THEN ERROR;
IF NOT White[from.PeekChar[]] THEN Busted[];
[] м from.SkipWhitespace[];
IF (char м from.GetChar[]) # ': THEN Busted[];
LOOP;
};
IF White[from.PeekChar[]] THEN EXIT--done with caps--;
capName м from.GetTokenRope[CapNameBuster].token;
IF capName.Length[] = 1 THEN Busted[];
cap м NEW [CapRep м [capName, NIL]];
char м from.GetChar[];
IF char = '@ THEN {
cancelIt м TRUE;
char м from.GetChar[];
};
SELECT char FROM
': => cap.val м NEW [BOOL м TRUE];
'# => {
cap.val м NEW [INT м from.GetInt[!IO.Error => Busted[]]];
IF from.GetChar[] # ': THEN Busted[];
};
'= => cap.val м ParseString[from];
ENDCASE => Busted[];
IF cancelIt THEN cap.val м cancel;
IF cap.name.Equal["tc"] THEN {
defName: String м NIL;
default: Term;
WITH cap.val SELECT FROM
s: String => defName м s;
ENDCASE => defName м NIL;
IF defName = NIL THEN Bitch["tc not a string"]
ELSE {
default м defaultTerm;
IF defName.str.Length[] > 0 THEN default м TCTerm[tc, defName.str]
ELSE {
i: INT м Real.RoundLI[defName.pad];
IF i # 0 THEN {
name: ROPE м Convert.RopeFromInt[i];
default м TCTerm[tc, name]
};
};
term.default м default
};
}
ELSE {
term.caps.Insert[cap !OrderedSymbolTableRef.DuplicateKey =>
CONTINUE --left value overrides right--];
};
ENDLOOP;
ENDLOOP;
};

TermNameBuster: PROC [char: CHAR] RETURNS [cc: IO.CharClass] --IO.BreakProc-- = {
cc м SELECT char FROM
'|, ': => break,
ENDCASE => other};

CapNameBuster: PROC [char: CHAR] RETURNS [cc: IO.CharClass] --IO.BreakProc-- = {
cc м SELECT char FROM
':, '#, '=, '@ => break,
IN [0C .. Ascii.SP] => sepr,
ENDCASE => other};

White: PROC [c: CHAR] RETURNS [white: BOOL] =
{white м c IN [0C .. Ascii.SP]};

Numeric: PROC [c: CHAR] RETURNS [numeric: BOOL] =
{numeric м (c IN ['0 .. '9]) OR (c = '.)};

ParseString: PROC [from: IO.STREAM] RETURNS [s: String] = {
padChars, strVal: ROPE м NIL;
char: CHAR;
dotSeen, proportional: BOOL м FALSE;
FOR char м from.PeekChar[], from.PeekChar[] WHILE Numeric[char] DO
IF from.GetChar[] # char THEN ERROR;
IF char = '. THEN dotSeen м TRUE;
padChars м padChars.Cat[Rope.FromChar[char]];
ENDLOOP;
IF from.PeekChar[] = '* THEN {
IF from.GetChar[] # '* THEN ERROR;
proportional м TRUE};
DO
char м from.GetChar[];
IF char = ': THEN EXIT;
SELECT char FROM
'^ => {char м from.GetChar[];
char м Ascii.Control[char]};
'\\ => {char м from.GetChar[];
SELECT char FROM
'E => char м Ascii.ESC;
'n => char м '\012;
'r => char м '\015;
't => char м '\t;
'b => char м '\010;
'f => char м '\014;
IN ['0 .. '7] => {
octChars: ROPE м Rope.FromChar[char];
IF from.PeekChar[] IN ['0 .. '7] THEN {
octChars м octChars.Concat[Rope.FromChar[from.GetChar[]]];
IF from.PeekChar[] IN ['0 .. '7] THEN {
octChars м octChars.Concat[Rope.FromChar[from.GetChar[]]];
};
};
char м '\000 + Convert.CardFromRope[octChars, 8];
};
'^, '\\ => char м char;
ENDCASE => char м char --really should Bitch, but UNIX is so sloppy, this saves a lot of headaches--;
};
ENDCASE;
strVal м strVal.Cat[Rope.FromChar[char]];
ENDLOOP;
s м NEW [StringRep м [
pad: IF padChars = NIL THEN 0.0 ELSE IF dotSeen THEN Convert.RealFromRope[padChars] ELSE REAL[Convert.IntFromRope[padChars]],
proportional: proportional,
str: strVal]];
};

CompareCaps: PROC [r1, r2: REF ANY] RETURNS [c: Basics.Comparison] = {
Key: PROC [r: REF ANY] RETURNS [name: ROPE] = {
WITH r SELECT FROM
c: Cap => name м c.name;
r: ROPE => name м r;
ENDCASE => ERROR};
c м Key[r1].Compare[Key[r2]];
};

CompareTerms: PROC [r1, r2: REF ANY] RETURNS [c: Basics.Comparison] = {
Key: PROC [r: REF ANY] RETURNS [name: ROPE] = {
WITH r SELECT FROM
a: Alias => name м a.name;
r: ROPE => name м r;
ENDCASE => ERROR};
c м Key[r1].Compare[Key[r2]];
};

CompareTermCaps: PROC [r1, r2: REF ANY] RETURNS [c: Basics.Comparison] = {
Key: PROC [r: REF ANY] RETURNS [fi: FileID] = {
WITH r SELECT FROM
tc: TermCap => fi м tc.fileID;
rfi: REF FileID => fi м rfiн;
ENDCASE => ERROR};
fi1: FileID м Key[r1];
fi2: FileID м Key[r2];
c м fi1.gName.Compare[fi2.gName, FALSE];
IF c = equal THEN c м SELECT BasicTime.Period[from: fi2.create, to: fi1.create] FROM
<0 => less,
=0 => equal,
>0 => greater,
ENDCASE => ERROR;
};

AntiAlias: PROC [ra: REF ANY] RETURNS [t: Term] = {
IF ra = NIL THEN RETURN [NIL];
WITH ra SELECT FROM
a: Alias => RETURN [a.val];
ENDCASE => ERROR};

Add: PROC [name: ROPE, val: Val] = {
c: Capм NEW [CapRep м [name, val]];
defaultTerm.caps.Insert[c];
};

Start: PROC = {
termCaps м OrderedSymbolTableRef.CreateTable[CompareTermCaps];
defaultTerm м NEW [TermRep м [
names: NIL,
caps: OrderedSymbolTableRef.CreateTable[CompareCaps]
]];
Add["cr", NEW [StringRep м [str: "\015"]]];
Add["ff", NEW [StringRep м [str: "\014"]]];
Add["nl", NEW [StringRep м [str: "\012"]]];
Add["pc", NEW [StringRep м [str: "\000"]]];
};

Start[];

}.
     
TermCapsImpl.Mesa
Copyright ╙ 1992 by Xerox Corporation.  All rights reserved.
Last Edited by: Spreitzer, March 13, 1985 11:21:30 pm PST
First, look for begin of entry: a line starting with alphabetic
Next, parse names
Finally, parse capabilities
Ignore end-of-line?
Э╩  ХNewlineDelimiter
Ц(cedarcode) styleЩ codeЩKЪЬ
╧eЬ1Щ<JЩ9ЧKШ KЪ╧k	Ь$ЮЬЮЬ.ШaKШ Ъ╨bxЬЮЬЮШKЪЮЬЮЬЮЬ#ШLKЪЮЬ	ШKШ KЪЬЮЬ
ШKШ KЪЬЮЬЮЬЮЬШ+KШ KЪ	ЬЮЬЮЬЮЬЮЬШ:KЪЬЮЬЮЬШKШ KЪЬЮЬШKЪЬЮЬШKШ Ъ╧nЬЮЬЮЬЮЬЮЬЮЬШZKЪ
а
ЬЮЬЮЬЮЬ	ЮЬШ<Ъ
аЬЮЬЮЬЮЬЮЬШCЪа
ЬЮЬЮЬЮЬШ1KЪ
ЮЬЮЬЮЬЮЬЮЬШ2KШЧЪаЬЮЬЮЬЮЬЮЬЮЬШ3KЪЬЮЬШKЪЬЮЬШKЪЮЬЮЬЮЬШ KЪЮЬЮЬЮЬШKШKШЧKШ&KЪЮЬЮЬЮЬ Ш:KШЧKШKШЧKШ ЪаЬЮЬЮЬЮЬЮЬЮЬШWKЪЬЮЬШ*KЪЮЬЮЬЮЬЮЬЮЬЮЬ	ЮЬ
ШIKЪЮЬЮЬЮЬ+ЮЬШXKШЧKШ Ъ
аЬЮЬЮЬЮЬЮЬШGKШ+KШЧKШ ЪаЬЮЬЮЬЮЬШ?KШ+ЪЮЬЮЬЮЬШЪЬЮЬШKШЪЬЮЬШKЪЬЮЬШKЪЬ5Ш5KШЧKШЧKШKШЧKШЧKШ ЪаЬЮЬЮЬЮЬЮЬЮЬШ^ЪаЬЮЬЮЬЮЬЮЬЮЬШ5KЪЬЮЬШKЪ
ЮЬЮЬЮЬЮЬЮЬШ8KШKШЧKШ*KШЧKШ Ъа
ЬЮЬЮЬЮЬЮЬЮЬЮЬШTKЪЬЮЬШKЪЬ	ЮЬШKЪЬЮЬЮЬШKЪЬЮЬШKЪЬЮЬЮЬШKЪ	Ь'ЮЬ&ЮЬЮЬЮЬШwKЪ
ЮЬЮЬЮЬЮЬЮЬШ KЪЬЮЬШ&KЪЬЮЬШ"KЪЮЬЮЬЮЬЮЬШЪЬЮЬШKШKЪЬ9Ш9KШЧKЪЬЮЬШKЪЬШЪЬШЪЬ
Ш
Ш"ЪЮЬШ	KЪЬ#Ш#KЪЮЬШKЪЮЬШKЪЬШЧKЪЬШЧKЪЮЬШKЪЬШЧKЪЮЬЮЬШKЪЬШЧKШЧKШ ЪаЬЮЬЮЬЮЬШ5KЪЬ	ЮЬЮЬШЪЮШKЪЮЬЮЬШ)KЪЬЮЬШKЪЬЮЬШKЪЬЮЬШKЪЬ
ЮЬЮЬШKЩ?ЪЮШKЪЬЮЬШKЪЮЬ	ЮЬЮЬЮЬШ=KШЪЮЬЮШKЪЮЬЮЬЮЬШ%KЪЮЬШЧKЪЮЬШЧKЩЪЮШKЪЬЮЬШKШKШ/KЪЮЬЮЬЮЬШ4KЪЮЬЮЬЮЬШ4KШKЪЮЬЮЬШ'KШKЪЮЬЮЬЮШKЪЮЬЮЬЮЬЮЬШ(KЪ
ЮЬЮЬЮЬЮЬ$ЮЬШOKЪЮЬЮЬЮЬ	ЮЬШ2KШ.KЪЮЬЮЬЮЬШKЪЮЬЮЬЮЬЮЬШ!KЪЮЬШЧЪЮЬЮЬЮЬЮЬШ*KЪЬ5Ш5KШKЪЬШЧKШЪЮЬЮЬ	ЮЬЮШ2KЪЬЮЬ"Ш0KЪЬЮЬШ+ЪЬ=Ш=KЪЮ╧c#ЬШ.ЧKЪЮЬШЧKЩЪЮШKЪЬ	ЮЬШKЪЬ	Ш	KЪЬ
ЮЬЮЬШKЪЬЮЬШKЩЪЮЬЮЬШKЪЬЮЬШKЪЮЬЮЬЮЬШ,KЪЮЬЮЬЮЬ
Ш,KШKЪЮЬЮЬ
Ш.KЪЮЬШKШЧKЪЮЬЮЬЮбЬШ6KШ1KЪЮЬЮЬ
Ш&KЪЬЮЬЮЬШ$KШЪЮЬЮЬШKЪЬЮЬШKШKШЧЪЮЬЮШKЪЬЮЬЮЬЮЬШ"ЪЬШKЪЬ
ЮЬЮЬЮЬШ9KЪЮЬЮЬ
Ш%KШЧKШ"KЪЮЬШЧKЪЮЬ
ЮЬШ"ЪЮЬЮЬШKЪЬЮЬШKШЪЮЬ	ЮЬЮШKШKЪЮЬЮЬШЧKЪЮЬЮЬЮЬШ.ЪЮЬШKШKЪЮЬЮЬ"ШBЪЮЬШKЪЬЮЬШ#ЪЮЬЮЬШKЪЬЮЬШ$KШKШЧKШЧKШKШЧKШЧЪЮЬШЪЬ;Ш;KЪЮЬбЬШ)ЧKЪЬШЧKЪЮЬШЧKЪЮЬШЧKШЧKШ ЪаЬЮЬЮЬЮЬЮЬбЬШQЪЬЮЬЮШKЪЬШKЪЮЬШЧЧKШ ЪаЬЮЬЮЬЮЬЮЬбЬШPЪЬЮЬЮШKЪЬШKЪЮЬЮЬ
ШKЪЮЬШЧЧKШ Ъ
аЬЮЬЮЬЮЬ	ЮЬШ-KЪЬЮЬЮЬШ ЧKШ Ъ
аЬЮЬЮЬЮЬЮЬШ1KЪЬЮЬЮЬШ*ЧKШ Ъ
аЬЮЬЮЬЮЬЮЬШ;KЪЬЮЬЮЬШKЪЬЮЬШKЪЬЮЬЮЬШ$ЪЮЬ)ЮЬЮШBKЪЮЬЮЬЮЬШ$KЪЮЬЮЬЮЬШ!KШ-KЪЮЬШЧЪЮЬЮЬШKЪЮЬЮЬЮЬШ"KЪЬЮЬШЧЪЮШKШKЪЮЬЮЬЮЬШЪЮЬЮШШKШЧШЪЮЬЮШKЪЬЮЬШKШKШKШKШKШЪЮЬШKЪЬ
ЮЬШ%ЪЮЬЮЬЮЬШ'KШ:ЪЮЬЮЬЮЬШ'KШ:KШЧKШЧKШ1KШЧKШKЪЮЬбMЬШeЧKШЧKЪЮЬШЧKШ)KЪЮЬШЧЪЬЮЬШKЪЬЮЬЮЬЮЬЮЬЮЬ	ЮЬ ЮЬЮЬ Ш}KЪЬШKЪЬШЧKШЧKШ Ъ
аЬЮЬ
ЮЬЮЬЮЬШFЪаЬЮЬЮЬЮЬЮЬЮЬШ/ЪЮЬЮЬЮШKШKЪЬЮЬШKЪЮЬЮЬШЧЧKШKШЧKШ Ъ
аЬЮЬ
ЮЬЮЬЮЬШGЪаЬЮЬЮЬЮЬЮЬЮЬШ/ЪЮЬЮЬЮШKШKЪЬЮЬШKЪЮЬЮЬШЧЧKШKШЧKШ Ъ
аЬЮЬ
ЮЬЮЬЮЬШJЪ
аЬЮЬЮЬЮЬЮЬШ/ЪЮЬЮЬЮШKШKЪЬЮЬШKЪЮЬЮЬШЧЧKШKШKЪЬ!ЮЬШ(ЪЮЬЮЬЮЬ4ЮШTKШKШKШKЪЮЬЮЬШЧKШЧKШ Ъ
а	ЬЮЬЮЬЮЬЮЬШ3KЪ
ЮЬЮЬЮЬЮЬЮЬШЪЮЬЮЬЮШKЪЬЮЬ	ШKЪЮЬЮЬШЧЧKШ ЪаЬЮЬЮЬШ$KЪЬЮЬШ#KШKШЧKШ ЪаЬЮЬШKШ>ЪЬЮЬШKЪЬЮЬШKЪЬ4Ш4KШЧKЪЬ
ЮЬШ+KЪЬ
ЮЬШ+KЪЬ
ЮЬШ+KЪЬ
ЮЬШ+KШЧKШ KШKШ KШЧЧ ЕЧ    #╝  2╧  