<<>>
    <<SpellingTestImpl.mesa>>
        <<Copyright Ó 1983, 1987, 1990, 1992 by Xerox Corporation.  All rights reserved.>>
        <<Created by Nix on September 8, 1983 11:17 am>>
        <<Last Edited by: Nix, November 17, 1983 1:36 pm>>
        <<Jack Kent July 24, 1987 1:26:36 pm PDT>>
        <<Tim Diebert: January 26, 1987 5:06:53 pm PST>>
        <<Rick Beach, May 2, 1985 3:21:23 pm PDT>>
        <<Bill Jackson (bj), March 7, 1990 9:50 pm PST>>
        <<Doug Terry, March 4, 1991 12:45 pm PST>>
        <<Willie-s, May 22, 1992 2:28 pm PDT>>

    DIRECTORY
        PFS USING [PathFromRope, StreamOpen],
        IO,
        Random USING [Create, ChooseInt, RandomStream],
        BitTableLookup USING [Read, Lookup, Table],
        RefText USING [TrustTextAsRope],
        SpellingToolServices USING [BruteForceCorrection],
        Rope USING [ROPE];

    SpellingTestImpl: CEDAR PROGRAM
        IMPORTS PFS, IO, BitTableLookup, Random, RefText, SpellingToolServices = BEGIN
        ROPE: TYPE = Rope.ROPE;

        experimental: ROPE Ź "Experimental.BitTable";
        web2: ROPE Ź "Web2.dic";

        Garbage: PROC [minLength, maxLength: CARDINAL, number: INT, file: ROPE]
        RETURNS [passed, failed: INT Ź 0] = {
            s: IO.STREAM Ź PFS.StreamOpen[PFS.PathFromRope[experimental]];
            trouble: IO.STREAM Ź PFS.StreamOpen[PFS.PathFromRope[file], create];
            globalBitTable: BitTableLookup.Table Ź NIL;
            length: INT;
            randomSequence: Random.RandomStream Ź Random.Create[-1, 0];
            word: REF TEXT Ź NEW[TEXT[maxLength]];
            globalBitTable Ź BitTableLookup.Read[s];
            s.Close[];
            FOR i: INT IN [0..number) DO
                length Ź Random.ChooseInt[randomSequence, minLength, maxLength];
                word.length Ź length;
                FOR j: INT IN [0..length) DO
                    word[j] Ź 'a + Random.ChooseInt[randomSequence, 0, 25];
                    ENDLOOP;
                IF globalBitTable.Lookup[word] THEN {
                    trouble.Put1[IO.text[word]];
                    trouble.PutChar['\n];
                    passed Ź passed + 1;
                    }
                ELSE 
                    failed Ź failed + 1;
                ENDLOOP;
            trouble.Close[];
            };

        Garbage4: PROC [file: ROPE] RETURNS [passed, failed: INT Ź 0] = {
            s: IO.STREAM Ź PFS.StreamOpen[PFS.PathFromRope[experimental]];
            trouble: IO.STREAM Ź PFS.StreamOpen[PFS.PathFromRope[file], create];
            globalBitTable:  BitTableLookup.Table Ź NIL;
            word: REF TEXT Ź NEW[TEXT[4]];
            globalBitTable Ź BitTableLookup.Read[s];
            s.Close[];
            word.length Ź 4;
            FOR c0: CHAR IN ['a..'z] DO
                FOR c1: CHAR IN ['a..'z] DO
                    FOR c2: CHAR IN ['a..'z] DO
                        FOR c3: CHAR IN ['a..'z] DO
                            word[0] Ź c0; 
                            word[1] Ź c1;
                            word[2] Ź c2;
                            word[3] Ź c3;
                            IF globalBitTable.Lookup[word] THEN {
                                trouble.PutText[word];
                                trouble.PutChar['\n];
                                passed Ź passed + 1;
                                }
                            ELSE 
                                failed Ź failed + 1;
                            ENDLOOP;
                        ENDLOOP;
                    ENDLOOP;
                ENDLOOP;
            trouble.Close[];
            };

        Garbage3: PROC [file: ROPE] RETURNS [passed, failed: INT Ź 0] = {
            s: IO.STREAM Ź PFS.StreamOpen[PFS.PathFromRope[experimental]];
            trouble: IO.STREAM Ź PFS.StreamOpen[PFS.PathFromRope[file], create];
            globalBitTable:  BitTableLookup.Table Ź NIL;
            word: REF TEXT Ź NEW[TEXT[3]];
            globalBitTable Ź BitTableLookup.Read[s];
            s.Close[];
            word.length Ź 3;
            FOR c0: CHAR IN ['a..'z] DO
                FOR c1: CHAR IN ['a..'z] DO
                    FOR c2: CHAR IN ['a..'z] DO
                        word[0] Ź c0; 
                        word[1] Ź c1;
                        word[2] Ź c2;
                        IF globalBitTable.Lookup[word] THEN {
                            trouble.PutText[word];
                            trouble.PutChar['\n];
                            passed Ź passed + 1;
                            }
                        ELSE 
                            failed Ź failed + 1;
                        ENDLOOP;
                    ENDLOOP;
                ENDLOOP;
            trouble.Close[];
            };

        Garbage2: PROC [file: ROPE] RETURNS [passed, failed: INT Ź 0] = {
            s: IO.STREAM Ź PFS.StreamOpen[PFS.PathFromRope[experimental]];
            trouble: IO.STREAM Ź PFS.StreamOpen[PFS.PathFromRope[file], create];
            globalBitTable:  BitTableLookup.Table Ź NIL;
            word: REF TEXT Ź NEW[TEXT[2]];
            globalBitTable Ź BitTableLookup.Read[s];
            s.Close[];
            word.length Ź 2;
            FOR c0: CHAR IN ['a..'z] DO
                FOR c1: CHAR IN ['a..'z] DO
                    word[0] Ź c0; 
                    word[1] Ź c1;
                    IF globalBitTable.Lookup[word] THEN {
                        trouble.PutText[word];
                        trouble.PutChar['\n];
                        passed Ź passed + 1;
                        }
                    ELSE 
                        failed Ź failed + 1;
                    ENDLOOP;
                ENDLOOP;
            trouble.Close[];
            };

        Garbage1: PROC [file: ROPE] RETURNS [passed, failed: INT Ź 0] = {
            s: IO.STREAM Ź PFS.StreamOpen[PFS.PathFromRope[experimental]];
            trouble: IO.STREAM Ź PFS.StreamOpen[PFS.PathFromRope[file], create];
            globalBitTable: BitTableLookup.Table Ź NIL;
            word: REF TEXT Ź NEW[TEXT[2]];
            globalBitTable Ź BitTableLookup.Read[s];
            s.Close[];
            word.length Ź 2;
            FOR c0: CHAR IN ['a..'z] DO
                word[0] Ź c0; 
                IF globalBitTable.Lookup[word] THEN {
                    trouble.PutText[word];
                    trouble.PutChar['\n];
                    passed Ź passed + 1;
                    }
                ELSE 
                    failed Ź failed + 1;
                ENDLOOP;
            trouble.Close[];
            };

        CloseOnes: PROC [outFile: ROPE Ź "Spelling.CloseOnes"]
        RETURNS [passed, failed: INT Ź 0] = {
            bitStream: IO.STREAM Ź PFS.StreamOpen[PFS.PathFromRope[experimental]];
            listStream: IO.STREAM Ź PFS.StreamOpen[PFS.PathFromRope[web2]];
            outStream: IO.STREAM Ź PFS.StreamOpen[PFS.PathFromRope[outFile], create];
            buffer: REF TEXT Ź NEW[TEXT[100]];
            wordBuffer: REF TEXT Ź NEW[TEXT[100]];
            correctionList: LIST OF ROPE Ź NIL;
            globalBitTable: BitTableLookup.Table Ź BitTableLookup.Read[bitStream];
            WordChecker: PROC [w: REF TEXT] RETURNS [inTable: BOOL] = {
                inTable Ź globalBitTable.Lookup[w];
                };
            bitStream.Close[];
            DO 
                wordBuffer Ź GetToken[listStream, wordBuffer ! IO.EndOfStream => EXIT];
                [correctionList, buffer] Ź SpellingToolServices.BruteForceCorrection [RefText.TrustTextAsRope[wordBuffer], WordChecker, buffer];
                FOR l: LIST OF ROPE Ź correctionList, l.rest UNTIL l = NIL DO
                    outStream.PutRope[l.first];
                    outStream.PutChar['\n];
                    ENDLOOP;
                ENDLOOP;
            outStream.Close[];
            listStream.Close[];
            };


        GetToken: PROC [s: IO.STREAM, word: REF TEXT] RETURNS [w: REF TEXT] = {
            <<Utility for reading a token from the given stream into the given buffer.>>
            UnPrintable: PROC [c: CHAR] RETURNS [unPrintable: BOOL] = INLINE {
                <<How's this for device independence?>>
                unPrintable Ź c IN ['\000 .. '\040];
                };
            c: CHAR;
            w Ź word;
            WHILE UnPrintable[c Ź s.GetChar[]] DO ENDLOOP; 
            s.Backup[c];
            w.length Ź w.maxLength;
            FOR i: CARDINAL Ź 0, i+1 DO
                c Ź s.GetChar[ ! IO.EndOfStream => GOTO done];
                IF UnPrintable[c] THEN GOTO done;
                IF i >= w.maxLength THEN {
                    w Ź NEW[TEXT[2*w.maxLength+1]];
                    w.length Ź w.maxLength;
                    };
                w[i] Ź c;
                REPEAT
                    done => w.length Ź i;
                ENDLOOP;
            };

        END.
        <<>>