<<>>
    <<TermCapsImpl.Mesa>>
        <<Copyright Ó 1992 by Xerox Corporation.  All rights reserved.>>
    <<Last Edited by: Spreitzer, March 13, 1985 11:21:30 pm PST>>

    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;
                <<First, look for begin of entry: a line starting with alphabetic>>
                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;
                <<Next, parse names>>
                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;
                <<Finally, parse capabilities>>
                DO
                    capName: ROPE;
                    cap: Cap;
                    cancelIt: BOOL Ź FALSE;
                    char: CHAR;
                    <<Ignore end-of-line?>>
                    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[];

        }.