(FILECREATED "22-JUL-83 14:00:13" <NEWLISP>SPELL.;1 47978
changes to: (FNS FIXSPELL)
previous date: "10-MAR-83 21:35:14" <LISP>SPELL.;157)
(PRETTYCOMPRINT SPELLCOMS)
(RPAQQ SPELLCOMS [(FNS ADDSPELL ADDSPELL1 ADDSPELL2 MISSPELLED? FIXSPELL FIXSPELL1 FIXSPELL2 CHOOZ
CHOOZ1 SKOR0 SKOR MOVETOP)
(INITVARS (USERWORDS)
(SPELLINGS1 (QUOTE (DEFINEQ ARGLIST MOVD GETD FNTYP BREAK UNBREAK REBREAK TRACE
BREAKIN MAKEFILE MAKEFILES LISTFILES FILES? WHEREIS
CLEANUP PP PF EDITF EDITV EDITP ADVISE UNADVISE
UNSAVEDEF RECOMPILE TCOMPL COMPILE BRECOMPILE BCOMPL
MAPCAR MAPC LOAD LOADFROM LOADFNS TIME CLOSEF CLOSEALL
OPENP OUTPUT INPUT OUTFILE INFILE LOGOUT PUTPROP
REMPROP GETPROP SYSOUT CLISPIFY DWIMIFY EDITCALLERS
FREEVARS CALLS)))
(SPELLINGS2 (QUOTE (GETPROP ADD1 AND APPEND ASSOC ATOM COND CONS COPY ELT EQ EQUAL
ERROR ERSETQ EVAL FASSOC FMEMB FRPLACA FRPLACD FUNCTION
GO IDIFFERENCE IGREATERP ILESSP IMINUS IPLUS ITIMES
LENGTH LIST LISTP MAPC MAPCAR MAPCONC MEMB MEMBER NCONC
NCONC1 NEQ NLISTP NLSETQ NULL NUMBERP OR PRINT PRIN1
PROG PROGN PUTPROP QUOTE READ RETURN RPLACA RPLACD
SELECTQ SETA SETQ SPACES SUB1 TERPRI ZEROP IF F/L
VALUEOF FOR FETCH REPLACE CREATE GETPROP PUTPROP
DIFFERENCE GREATERP LESSP PLUS)))
(SPELLINGS3 (QUOTE (BROKENFNS ADVISEDFNS NOTLISTEDFILES FILELST NOTCOMPILEDFILES
PROMPT#FLG CLISPIFYPRETTYFLG DWIMIFYCOMPFLG FILERDTBL
EDITRDTBL SYSPRETTYFLG NOSPELLFLG INITIALS NIL)))
(SPELLSTR1 "{spellseparator}")
(SPELLSTR2 "{spellignore}")
(FIXSPELLREL 70)
(FIXSPELLDEFAULT (QUOTE y))
(SKORLST1 (QUOTE (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL
NIL NIL NIL NIL)))
(SKORLST2 (QUOTE (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL
NIL NIL NIL NIL)))
DWIMKEYLST FIXSPELLKEYLST (FASTYPEFLG)
(RUNONFLG T)
(#USERWORDS 60)
(#SPELLINGS1 60)
(#SPELLINGS2 60)
(#SPELLINGS3 60)
(DWIMWAIT 10)
(RESPELLS)
(MODEL33FLG))
(P (NCONC1 SPELLINGS1 SPELLSTR1)
(NCONC1 SPELLINGS2 SPELLSTR1)
(ATTACH SPELLSTR1 SPELLINGS3))
(BLOCKS (FIXSPELLBLOCK MISSPELLED? FIXSPELL CHOOZ CHOOZ1 SKOR SKOR0 MOVETOP
(ENTRIES MISSPELLED? FIXSPELL CHOOZ SKOR0 SKOR MOVETOP)
(LOCALFREEVARS NCXWORD NCTWORD TAIL ALTFLG)
(GLOBALVARS CLISPCHARS CLISPFLG DWIMFLG EDITQUIETFLG FASTYPEFLG
FCHARAR LASTWORD MODEL33FLG NOSPELLFLG RUNONFLG SKORLST1
SKORLST2 SPELLINGS1 SPELLINGS2 SPELLSTATS1 SPELLSTR1
SPELLSTR2))
(FIXSPELL1 FIXSPELL1 FIXSPELL2
(GLOBALVARS APPROVEFLG COMMENTFLG CUTEFLG DWIMKEYLST DWIMWAIT REREADFLG
RESPELLS RUNONSTATS SPELLSTATS SPELLSTATS1 VETOSTATS))
(ADDSPELLBLOCK ADDSPELL ADDSPELL1 (ENTRIES ADDSPELL ADDSPELL1)
(GLOBALVARS #SPELLINGS2 #SPELLINGS3 #USERWORDS LASTWORD SPELLINGS1
SPELLINGS2 SPELLINGS3 SPELLSTR1 SPELLSTR2 USERWORDS))
(NIL ADDSPELL2 (GLOBALVARS SPELLSTR2])
(DEFINEQ
(ADDSPELL
[LAMBDA (X SPLST N)
(* Updates appropriate spellings lists as follows: if SPLST is NIL, adds to
USERWORDS and SPELLINGS2; -
if SPLST is 0, just adds to USERWORDS; -
if SPLST is 1, adds to SPELLINGS1; -
if SPLST is 2, adds to SPELLINGS2; -
if SPLST is 3, adds to USERWORDS and SPELLINGS3.
-
-
SPELLINGS1 is the list of functions used in an APPLY context, e.g. MAKEFILE,
TCOMPL, DEFINEQ. SPELLINGS2 is the list of functions used in an EVAL
context, e.g. CONS, AND, RETURN. SPELLINGS3 is a list of variables.
USERWORDS is a list of both functions and variables that the user
references.)
(AND (LITATOM X)
(SELECTQ SPLST
((NIL 0)
(* DEFINE uses SPLST NIL, adds word to SPELLINGS2 because some user function
must call it. However, it might not be a top-level function, so it isn't
added to SPELLINGS1 until used in that way.
-
SPLST 0 is for LOAD/PROP, and for use from EDITA, PRINTSTRUCTURE, etc.
doesn't add it to SPELLINGS2 since have no indication that the function will
be called by the user.)
(SETQ USERWORDS (ADDSPELL1 X USERWORDS #USERWORDS))
(AND (NULL SPLST)
(SETQ SPELLINGS2 (ADDSPELL1 X SPELLINGS2 #SPELLINGS2)))
(SETQ LASTWORD X))
(1
(* Called from LISPX on APPLY inputs, add to permanent section, i.e. never
forgets X.)
(SETQ SPELLINGS1 (ADDSPELL1 X SPELLINGS1)))
(2
(* Called from LISPX on EVAL inputs, never forgets X.
Not however that words are added to temporary section of SPELLINGS2 for
TYPE=NIL or TYPE=0.)
(SETQ SPELLINGS2 (ADDSPELL1 X SPELLINGS2)))
((T 3)
(* Called from LISPX inputs consisting of just a variable, or from SAVESET,
i.e. any call to RPAQ or RPAQQ, or any call to SET or SETQ via LISPX, or
from EDITV.)
(SETQ USERWORDS (ADDSPELL1 X USERWORDS #USERWORDS))
(SETQ SPELLINGS3 (ADDSPELL1 X SPELLINGS3 #SPELLINGS3))
(SETQ LASTWORD X))
(COND
((LISTP SPLST)
(ADDSPELL1 X SPLST N))
(T (ERROR (QUOTE "bad addspell type:")
SPLST T])
(ADDSPELL1
[LAMBDA (WORD SPLST N) (* wt: " 9-OCT-78 00:37")
(* SPLST is divided into two sections, permanent and temporary, separated by NIL. Words are never forgotten from the
permanent section. A maximum of N words are allowed in the temporary section. When a correction occurs, the word is
moved to the front of the list, hence putting it in the permanent section. -
When ADDSPELL1 is called with N=NIL, words are added at the end of the permanent section, i.e. just before the NIL.
Otherwise they are added at the beginning of the temporary section, and if there are more than N words in the
temporary list, the last is deleted.)
[COND
((NULL SPLST)
(SETQ SPLST (LIST SPELLSTR1 WORD)))
((AND (NEQ WORD (CAR SPLST))
(NEQ WORD (CADR SPLST)))
(* Loop begins with third element.)
(PROG ((L1 SPLST)
(L2 (CDDR SPLST))
L3 M)
(* L1 stays two behind L2 so that the last element of SPLST can be deleted.)
(COND
((EQ (CAR SPLST)
SPELLSTR1)
(SETQ L3 SPLST)
(SETQ M 1)
(* L2 has already skipped one of the
temporary words.))
((EQ (CADR SPLST)
SPELLSTR1)
(SETQ L3 SPLST)
(SETQ M 0)))
(* Special check necessary because USERWORDS starts off with NIL first, i.e.
no permanent USERWORDS. If NIL not noticed, length won't be counted and
nothing will ever be deleted.)
LP (COND
((NULL L2)
(GO OUT))
((EQ WORD (CAR L2))
(COND
((NULL L3)
(* WORD is already in permanent
section.))
((NULL N)
(* WORD is in temporary section and would have been added to permanent
section. Add it to permanent and erase from temporary.)
(FRPLACD (CDR L1)
(CDR L2))
(FRPLACD L2 (CDR L3))
(FRPLACD L3 L2))
(T
(* WORD is in temporary section and would have been added to temporary
section. MOVE it to front of temporary section.)
(FRPLACD (CDR L1)
(CDR L2))
(SETQ L3 (CDR L3))
(FRPLACD L2 (CDR L3))
(FRPLACD L3 L2)))
(RETURN))
((EQ (CAR L2)
SPELLSTR1)
(SETQ L3 (CDR L1))
(* CAR of L3 is the last member of
the permanent section.)
(SETQ M 0)))
(SETQ L1 (CDR L1))
(SETQ L2 (CDR L2))
(AND M (ADD1VAR M)) (* M will be the length of temporary
section)
(GO LP)
OUT (COND
((NULL L3)
(* NIL not found. Occurs if user is maintaining own
|
spelling list and not using temporary/permanent
|
conventions.)
(NCONC1 L1 WORD))
[(NULL N)
(* Add at end of permanent section.)
(RPLNODE L3 (CAR L3)
(CONS WORD (CDR L3]
((IGREATERP M N)
(* Add at beginning of temporary section, delete
|
(AND REUSE) last element of temporary section.)
(RPLNODE (CDR L1)
WORD
(CDDR L3))
(RPLNODE (CDR L3)
(CADR L3)
(CDR L1))
(FRPLACD L1 NIL)
(* Not worth while to make the deletion of last elemetn
|
undoable.))
(T (RPLNODE (CDR L3)
(CADR L3)
(CONS WORD (CDDR L3)))
(* Add at beginning of temporary section.)))
(AND LISPXHIST (UNDOSAVE (LIST (QUOTE ADDSPELL2)
WORD SPLST)
LISPXHIST]
SPLST])
(ADDSPELL2
[LAMBDA (WORD SPLST) (* wt: " 8-OCT-78 23:19")
(PROG (TEM)
(AND (SETQ TEM (FMEMB WORD SPLST))
(/RPLACA TEM SPELLSTR2])
(MISSPELLED?
[LAMBDA (XWORD REL SPLST FLG TAIL FN) (* wt: "25-APR-78 12:26")
(* MISSPELLED? can be used when XWORD may in fact be all
right. FIXSPELL should be used if you know XWORD is
wrong.)
(PROG NIL (* REL is between 0 and 100 and indicates percentage.)
(RETURN (COND
((OR (NULL XWORD)
(EQ XWORD (QUOTE )))
(LISPXWATCH SPELLSTATS1)
(PRIN1 (QUOTE =)
T)
(PRINT LASTWORD T T))
((COND
((NULL FN)
(FMEMB XWORD SPLST))
(T (APPLY* FN XWORD)))
XWORD)
(T (FIXSPELL XWORD REL SPLST FLG TAIL FN])
(FIXSPELL
[LAMBDA (XWORD REL SPLST FLG TAIL FN TIEFLG DONTMOVETOPFLG FROMDWIM APPROVALFLG)
(* lmm "22-JUL-83 13:55")
(* If FLG is T, XWORD is printed to left of = sign. -
CLST is used when FIXSPELL is called from WTFIX. In this case, if TYPE-IN? is NIL, XWORD is printed, and a -> is
used instead of =. In addition, if FAULTFN is not NIL, (IN FAULTFN) is also printed as part of the message.
If CLST is a list, it is a DUNPACK of XWORD, since in most cases WTFIX will already have computed this list.
FLG is used to specify other types of messages besides ->. If TAIL is supplied, and word is equal to CAR of it, the
correction will be smahed into TAIL. If TAIL is non NIL, runon corrections will be attempted.
(If TAIL=T, and a runon corection is approved, the dotted pair is returned as the value.) If FLG=NO-MESSAGE, the
correction is returned without asking for approval.)
(AND DWIMFLG (NEQ NOSPELLFLG T)
(OR (NULL NOSPELLFLG)
(NULL FROMDWIM)
(EVQ TYPE-IN?))
(OR (LISTP SPLST)
(ARRAYP SPLST))
(OR (LITATOM XWORD)
(STRINGP XWORD))
(PROG ((TLST (DCHCON XWORD SKORLST1))
X TEM (NDBLS 0))
(COND
((NULL REL)
(SETQ REL FIXSPELLREL)))
[COND
((NULL XWORD)
(RETURN NIL))
([AND (LISTP SPLST)
(NOT (STACKP (CAR SPLST]
(COND
((SETQ TEM (ASSOC XWORD SPLST))
(SETQ X (LIST (CAR TEM)
(CDR TEM)))
(GO LP2))
((NOT (U-CASEP XWORD))
(SETQ TEM (U-CASE XWORD))
(COND
[(OR (AND (OR (EQ FN (QUOTE GETD))
(EQ SPLST SPELLINGS1)
(EQ SPLST SPELLINGS2))
(FGETD TEM))
(FMEMB TEM SPLST))
(SETQ X TEM)
(COND
((AND FROMDWIM (NULL TYPE-IN?))
(GO OUT))
(T (GO OUT1]
((LISTP (SETQ TEM (FASSOC TEM SPLST)))
(* reason for listp is that some entries on splst will not be lists, and is possible to get a match on the first
entry of their property list, especially when misspelling NIL. the "right" way to do this would be with a SOME but
is much less efficient.)
(SETQ X (LIST (CAR TEM)
(CDR TEM)))
(COND
((NOT (AND FROMDWIM (NULL TYPE-IN?)))
(SETQQ FLG NO-MESSAGE)))
(GO LP2]
(COND
((AND (EQ XWORD (QUOTE ))
(OR (NULL FROMDWIM)
(EVQ TYPE-IN?)))
(* TYPE-iIN? is bound in WTFIX.)
(SETQ X LASTWORD)
(FIXSPELL1 XWORD LASTWORD NIL FROMDWIM)
(GO OUT1))
((AND [SETQ TEM (FASSOC XWORD (LISTGET1 LISPXHIST (QUOTE RESPELLS]
(FMEMB (CDR TEM)
SPLST))
(* Already made this correctionthis event.)
(SETQQ APPROVALFLG NEEDNOTAPPROVE)
(SETQ X (CDR TEM))
(GO LP2)))
(SETQ X TLST)
LP (COND
((NULL X)
(GO A))
((AND (EQ (CAR X)
27)
(SETQ TEM (CDR X)))
(* 27 Is alt-mode. for terminal alt modes, we call CHOOZ since this also handles the case where ther are
misspellings in the leading characters.)
(SETQ TLST (DUNPACK XWORD SKORLST1))
(GO ALT))
((EQ (CAR X)
TEM)
(SETQ NDBLS (ADD1 NDBLS)))
(T (SETQ TEM (CAR X))
(* TEM keeps track of the previous character.)
))
(SETQ X (CDR X))
(GO LP)
A (COND
((NULL MODEL33FLG)
(* P,L,N,and O are on the same keys as @ \ ↑ and ← only on model 33's.)
(GO LP1)))
(SETQ X (SELECTQ (CAR TLST)
(64
(* @)
(QUOTE P))
(92
(* \)
(QUOTE L))
(94
(* ↑)
(QUOTE N))
(95
(* ←)
(QUOTE O))
(GO LP1)))
[SETQ X (PACK (CONS X (CDR (DUNPACK XWORD SKORLST2]
(COND
([AND FN (NULL (COND
((EQ FN (QUOTE GETD))
(FGETD X))
(T (APPLY* FN X]
(GO LP1))
((OR (NLISTP SPLST)
(FMEMB X SPLST))
(GO OUT))
(FN
(* Thus if a XWORD is misspelled by having its first character changed from p to @, l to \, n to or o to ←, and
satisfies FN, it will be corrected even if not on the spelling list, and added to the list.)
(ATTACH X SPLST)
(GO OUT)))
LP1 (SETQ X (CHOOZ TLST REL SPLST TAIL FN TIEFLG NDBLS FROMDWIM))
LP2 [COND
((NULL X)
(RETURN NIL))
((OR (EQ TIEFLG (QUOTE ALL))
(EQ TIEFLG (QUOTE LIST))
(EQ TIEFLG (QUOTE EVERYTHING)))
(RETURN X))
((LISTP X)
(RETURN (COND
[(LISTP (CDR X))
(* synonym correction. XWORD is identical with CAR of X.)
(COND
((OR (EQ XWORD (CAR X))
(EQ FLG (QUOTE NO-MESSAGE)))
(* no approval necessary)
(SETQ X (CADR X))
(GO OUT1))
((SETQ TEM (FIXSPELL1 XWORD (CAR X)
FLG FROMDWIM APPROVALFLG))
(* e.g. synonym is S.T. but XWORD is S.TT.)
[SETQ X (COND
((LISTP TEM)
(* user specified new value via USING)
(CAR TEM))
(T (CADR X]
(GO OUT1]
((NULL TAIL)
(* value of form (a . b) returned by chooz means runon correction)
NIL)
((EQ FLG (QUOTE NO-MESSAGE))
X)
([SETQ TEM (FIXSPELL1 XWORD (COND
((LISTP (CAR X))
(* both a runon and synonym involved, e.g. user types WHERE, and
(WHE . SY) on spelling list. fixpsspell1 asks WHERE= WHE RE?)
(CONS (CAAR X)
(CDR X)))
(T X))
FLG FROMDWIM (OR APPROVALFLG (QUOTE MUSTAPPROVE]
(* Runon correction.)
(COND
((LISTP TEM)
(* user typed in a value. no run on)
(SETQ X (CAR TEM))
(GO OUT1))
((AND (LISTP TAIL)
(EQ XWORD (CAR TAIL)))
(* Smash TAIL and eturn the first word)
(/RPLNODE TAIL (COND
((LISTP (CAR X))
(CADAR X))
(T (CAR X)))
(CONS (CDR X)
(CDR TAIL)))
(CAR TAIL))
[(LISTP TEM)
(COND
((CDR TEM)
(CONS (CAR TEM)
(CADR TEM)))
(T (CAR TEM]
(T
(* Return the dotted pair)
X)))
((IGREATERP (CHOOZ1 (NCHARS XWORD)
[NCHARS (COND
((LISTP (CAR X))
(CAAR X))
(T (CAR X]
(NCHARS (CDR X)))
REL)
(* e.g. the correction (BREAK . X) is offered for BREAKX this asks whether BREAK
is a valid correction for BREAKX)
(SETQ X (CAR X))
(GO LP2]
OUT (COND
((EQ FLG (QUOTE NO-MESSAGE))
(RETURN X))
[(SETQ TEM (FIXSPELL1 XWORD X FLG FROMDWIM APPROVALFLG))
(* Prints appropriate message to user.)
(COND
((LISTP TEM)
(SETQ X (CAR TEM))
(ADDSPELL X SPLST))
([AND (NULL DONTMOVETOPFLG)
(LISTP (CDR (LISTP SPLST]
(MOVETOP X SPLST]
(T (RETURN NIL)))
OUT1(AND (LISTP TAIL)
(EQ XWORD (CAR TAIL))
(/RPLNODE TAIL X (CDR TAIL)))
(RETURN X)
ALT (* Alt-mode matching.)
[RESETVARS ((EDITQUIETFLG T))
(RETURN (PROG ((L SPLST)
(GENFN (AND (ARRAYP SPLST)
(ELT SPLST 1)))
(GENERATOR (AND (STACKP (CAR SPLST))
SPLST)))
(SETQ X NIL)
LP3 [COND
[GENFN (COND
((NULL (SETQ TEM (APPLY* GENFN SPLST)))
(RETURN]
[GENERATOR (COND
((EQ (SETQ TEM (GENERATE GENERATOR))
GENERATOR)
(RELSTK (CDR GENERATOR))
(RETURN]
((NULL L)
(RETURN))
((NULL (SETQ TEM (CAR L)))
(SETQ L (CDR L))
(GO LP3))
(T (SETQ L (CDR L]
[COND
([AND (EDIT4E1 TLST (DUNPACK TEM SKORLST2))
(OR (NULL FN)
(COND
((EQ FN (QUOTE GETD))
(FGETD TEM))
(T (APPLY* FN TEM]
(AND GENFN (STRINGP TEM)
(SETQ TEM (MKATOM TEM)))
(* because the generator function may (frequently does) reuse the string it
reutnrs.)
(COND
((OR (EQ TIEFLG (QUOTE ALL))
(EQ TIEFLG (QUOTE LIST))
(EQ TIEFLG (QUOTE EVERYTHING)))
(SETQ X (CONS TEM X)))
(TIEFLG (SETQ X TEM))
(X
(* Already a match, therefore ambiguous.)
(PRINT (QUOTE ambiguous)
T)
(SETQ X NIL)
(RETURN))
(T (SETQ X TEM]
(GO LP3]
(GO LP2])
(FIXSPELL1
[LAMBDA (WORD X FLG FROMDWIM APPROVALFLG DEFAULT)
(* lmm " 6-APR-82 23:56")
(* Performs interaction with user associated with a spelling or other corretion.)
(PROG ([LISPXHIST (AND LISPXHIST (CONS (QUOTE *LISPXPRINT*)
(CONS NIL LISPXHIST]
(VAL T)
MESSFLG BUFS TEM)
(* LISPXHIST is rebound as we don't want to include any DWIM messages if the change isn't actually performed, e.g.
the user says NO. Therefore, we want to have LISPXPRIN1 et al save the output on a local LISPXHIST, and then
transfer it all over to the real LISPXHIST if the correction goes through.)
(AND (EQ WORD X)
(ERROR!))
(COND
((NEQ (POSITION T)
0)
(LISPXTERPRI T)
(TERPRI T)))
(COND
((OR (SETQ MESSFLG (OR (STRINGP WORD)
(STRINGP X)))
(EQ RESPELLS T))
(* Dont keep respells.)
)
((OR REREADFLG (STRPOS (QUOTE "")
WORD))
(* Spelling completion)
)
([OR (LISTP X)
(NULL (SETQ TEM (FASSOC X RESPELLS]
(SETQ RESPELLS (CONS (LIST X WORD)
RESPELLS)))
(T (NCONC1 TEM WORD)))
(COND
([AND (NEQ APPROVALFLG (QUOTE MUSTAPPROVE))
(COND
(FROMDWIM (AND TYPE-IN? (NULL MESSFLG)))
(T (NULL FLG]
(* This is the case where the correction is a spelling correction (as inidcated by MESSFLG being NIL), and no
approval is needed. i.e. FIXSPELL1 is just going to print = followed by the word.)
(AND (OR (EQ REREADFLG (QUOTE T))
FLG)
(PRIN2 WORD T T))
(PRIN1 (QUOTE =)
T)
(FIXSPELL2 X)
(AND (EQ TEM 2)
(PRIN1 (QUOTE "You seem to be having a lot of trouble typing that!
")
T))
(GO OUT1)))
(COND
([AND (NEQ APPROVALFLG (QUOTE MUSTAPPROVE))
(COND
((NULL FROMDWIM)
(OR (NULL FLG)
(NULL APPROVEFLG)))
(T
(* OR is true if approval is required. NOte that even if APPROVEFLG is T, when there are two interpretations to a
correction, as indicated by CLISPCHANGES not being NIL, always aks approval.)
(NULL (OR (AND (NULL TYPE-IN?)
APPROVEFLG)
CLISPCHANGES]
(SETQQ APPROVALFLG NEEDNOTAPPROVE)))
[COND
((OR (EQ APPROVALFLG (QUOTE MUSTAPPROVE))
(AND (NEQ APPROVALFLG (QUOTE NEEDNOTAPPROVE))
APPROVEFLG))
(* Want to clear out LINUF and SYSBUF to prevent CLBUFS from misakenly returning
left over typeahead from a previous CLEARBUF.)
(LINBUF)
(SYSBUF) (* The extra argument to CLBUFS prevents READBUF
(LISPX'S buffer) from being cleared.)
(SETQ BUFS (CLBUFS NIL T READBUF]
(FIXSPELL2 WORD T)
(COND
((AND FROMDWIM (NULL TYPE-IN?))
(FIXPRINTIN FAULTFN T)
(LISPXPRIN1 (OR FLG (QUOTE " -> "))
T))
(T (LISPXPRIN1 (COND
((AND FLG (NEQ FLG T))
FLG)
(T (QUOTE =)))
T) (* E.g. For Shall I load ... message, FLG is "" for unary minus it is " ")
))
(AND NIL (STRINGP WORD)
(STRINGP X)
(OR (NULL FLG)
(EQ FLG T))
(NOT (STREQUAL WORD (QUOTE "")))
(LISPXTERPRI T))
(* On corrections where both left and right are strings, and FLG is normal (thereby xcluding the TREAT AS CLISP
case) print the strings on separate lnes for readability.)
(COND
((EQ APPROVALFLG (QUOTE NEEDNOTAPPROVE))
(FIXSPELL2 X)
(GO OUT)))
(FIXSPELL2 X T)
[SETQ VAL (ASKUSER (AND DWIMWAIT (COND
(MESSFLG
(* MESSFLG would be NIL for straight spelling correction. This says that the correction involves an 8 or a 9, or
asks some question about CLISP. User will probably need more time to think about it in this case.)
(ITIMES 3 DWIMWAIT))
(T DWIMWAIT)))
(COND
(DEFAULT)
([AND (LISTP X)
(OR (ILESSP (SETQ TEM (NCHARS (CAR X)))
3)
(NOT (IGREATERP TEM (NCHARS (CDR X]
(* Runon correction. Defaut is NO if less than three characters in first word, or
first word is not greater than second in length)
(QUOTE n))
(T FIXSPELLDEFAULT))
(QUOTE " ? ")
(COND
(FROMDWIM DWIMKEYLST)
(T FIXSPELLKEYLST]
(AND BUFS (BKBUFS BUFS))
(SELECTQ VAL
((Y y)
(SETQ VAL T))
(N (LISPXWATCH VETOSTATS)
(* If value returned was 'n' as opposed to 'N', means defaulted to NO, not
vetoed.)
(RETURN NIL))
(n (RETURN NIL))
(SETQ X (CAR VAL)))
(LISPXTERPRI T NIL NIL T)
(* Adds a TERPRI to history list if LISPXPRINTFLG is T, but does not actually
print a carriage return.)
OUT (COND
((CADR LISPXHIST)
(LISPXPUT (QUOTE *LISPXPRINT*)
(CADR LISPXHIST)
T
(CDDR LISPXHIST))
(* Makes the print information part of LISPXHIST. Before it was on a property that ws just consed onto the front.
This will also add it to any other print information.)
))
OUT1[AND FROMDWIM LISPXHIST (NULL TYPE-IN?)
(NEQ (CAR SIDES)
(QUOTE CLISP% ))
(SETQ SIDES (LIST (QUOTE CLISP% )
(LIST COMMENTFLG (CADR LISPXHIST)
SIDES]
(* This marks the side information and print information as of the beginning of this correction.
For usefor selective undoing. CADR of LISPXHIST (which was rebound here), will be the beginning of the PRINT
information, which if approved, will be NCONCed onto the print informaion for this event.)
(COND
(MESSFLG (RETURN VAL))
(FROMDWIM (LISPXWATCH SPELLSTATS)
(AND LISPXHIST (LISPXPUT (QUOTE RESPELLS)
(LIST (CONS WORD X))
T LISPXHIST)))
(T (LISPXWATCH SPELLSTATS1)))
(AND (LISTP X)
(LISPXWATCH RUNONSTATS))
(RETURN VAL])
(FIXSPELL2
[LAMBDA (X FLG) (* wt: 15-JUL-76 20 53)
(COND
((LISTP X)
(MAPRINT (COND
((AND (CDR X)
(NLISTP (CDR X)))
(LIST (CAR X)
(CDR X)))
(T X))
T NIL NIL NIL [FUNCTION (LAMBDA (X)
(COND
((STRINGP X)
(LISPXPRIN1 X T))
(T (LISPXPRIN2 X T T]
T))
((STRINGP X)
(LISPXPRIN1 X T))
(T (LISPXPRIN2 X T T)))
(COND
((NULL FLG)
(LISPXTERPRI T])
(CHOOZ
[LAMBDA (XWORD REL SPLST TAIL FN TIEFLG NDBLS FROMDWIM)
(* DD: "17-Dec-81 14:14")
[COND
((NLISTP XWORD) (* When called from FIXSPELL, XWORD is already a CHCON lst.)
(SETQ XWORD (CHCON XWORD]
(PROG ((NCXWORD0 (FLENGTH XWORD))
NCXWORD NCTWORD TWORD TWORD1 TWORD2 TEM SC VAL (GENFN (AND (ARRAYP SPLST)
(ELT SPLST 1)))
(GENERATOR (AND (STACKP (CAR SPLST))
SPLST))
ALTFLG)
[AND (NULL NDBLS)
(SETQ NDBLS 0)
(MAPC XWORD (FUNCTION (LAMBDA (X)
(COND
((EQ X TEM)
(SETQ NDBLS (ADD1 NDBLS)))
(T (SETQ TEM X]
(* Counts number of (possibly) doubled characters)
(SETQ ALTFLG (EQ (CAR (LAST XWORD))
27)) (* xword ends in an alt-mode. means k to call skor even if testword is much
longer.)
LP [COND
[GENFN
(* this provides a way of giving the spelling corrector a generating function intead of a spelling list.
the generatng function can keep its 'state' in one of the other cells of the array. when it returns a value of NIL
for the 'next' element, the spelling lists is assume xhausted.)
(COND
((NULL (SETQ TWORD (APPLY* GENFN SPLST)))
(GO OUT]
[GENERATOR (COND
((EQ (SETQ TWORD (GENERATE GENERATOR))
GENERATOR)
(RELSTK (CDR GENERATOR))
(GO OUT]
((NULL SPLST)
(GO OUT))
((NLISTP SPLST)
(HELP "SMASHED SPELLING LIST" SPLST))
((OR (EQ (SETQ TWORD (CAR SPLST))
SPELLSTR1)
(EQ TWORD SPELLSTR2))
(* marker.)
(SETQ SPLST (CDR SPLST))
(GO LP))
(T (SETQ SPLST (CDR SPLST]
[COND
((LISTP TWORD) (* Synonym feature.)
(SETQ TWORD1 (CAR TWORD))
(SETQ TWORD2 (CDR TWORD)))
(T (SETQ TWORD1 (SETQ TWORD2 TWORD]
(SETQ NCTWORD (NCHARS TWORD1))
(SETQ NCXWORD (COND
(ALTFLG (* for purposes of call to skor, pretend that both words are same length so first
character matched against first character.)
NCTWORD)
(T NCXWORD0)))
[COND
((COND
((IGREATERP NCTWORD NCXWORD)
(* Checks to see if test word and unknown word differ sufficiently in number of characters so as to make it
unnecessary to even call SKOR. This case is where test word is longer than XWORD. If number of characters in XWORD,
NCW, divided by number of characters in test word, NCT, is less than REL than don't bother to call SKOR.
0 P)
(AND (NULL ALTFLG)
(ILESSP (IQUOTIENT (ITIMES NCXWORD 100)
NCTWORD)
REL)))
((AND (NULL TAIL)
(ILESSP [IQUOTIENT (ITIMES NCTWORD 100)
(COND
((EQ NCXWORD NDBLS)
1)
(T (IDIFFERENCE NCXWORD NDBLS]
REL))
(* XWORD longer than test word. However, must allow for possibility of doubled
characters.)
T))
(GO LP))
([AND (SETQ SC (SKOR XWORD (SETQ TEM (DCHCON TWORD1 SKORLST2))
NCXWORD NCTWORD FROMDWIM))
(OR (NULL FN)
(COND
((EQ FN (QUOTE GETD))
(FGETD TWORD2))
(T (APPLY* FN TWORD2]
(SETQ TEM (COND
((LISTP TWORD) (* to distinguish from a runon correction, which is returned as a dotted pair.)
(LIST TWORD1 TWORD2))
((AND GENFN (STRINGP TWORD))
(MKATOM TWORD))
(T TWORD))) (* note that i dont know what happens if you have both a synonym and
runoncorrecton)
(COND
((LISTP SC)
[AND RUNONFLG TAIL [OR (NULL VAL)
(EQ TIEFLG (QUOTE EVERYTHING))
(IGREATERP NCTWORD (NCHARS (CAAR VAL]
(SETQ VAL (CONS (CONS TEM (PACKC SC))
(COND
((EQ TIEFLG (QUOTE EVERYTHING))
VAL]
(* TWORD1 used instead of TWORD2 becauseif any interaction, want user to approve in terms of his typeing, not the
synonym. this will mean another call to spelling corrector to get the synonym, but big deal.)
)
[(ZEROP SC)
(COND
((EQ TIEFLG (QUOTE EVERYTHING))
(SETQ VAL (CONS TEM VAL)))
((AND (NEQ TIEFLG (QUOTE ALL))
(NEQ TIEFLG (QUOTE LIST)))
(* return the value)
(SETQ VAL TEM)
(GO OUT1))
((NEQ REL 100)
(* tieflg=LIST means list the tied candidates.
it used to be called ALL)
(SETQ REL 100)
(SETQ VAL (LIST TEM)))
(T (SETQ VAL (CONS TEM VAL]
[(IGREATERP [SETQ SC (COND
(ALTFLG (CHOOZ1 (SUB1 (IDIFFERENCE NCXWORD0 (IDIFFERENCE NCTWORD
NCXWORD)))
(SUB1 NCXWORD0)
SC))
(T (CHOOZ1 NCXWORD NCTWORD SC]
REL)
(SETQ VAL (CONS TEM (COND
((EQ TIEFLG (QUOTE EVERYTHING))
VAL)
(T (SETQ REL SC)
(* Now only look for words CLOSER than SC.)
NIL]
((EQ SC REL)
(SETQ VAL (CONS TEM VAL]
(GO LP)
OUT [SETQ VAL (COND
((OR (EQ TIEFLG (QUOTE ALL))
(EQ TIEFLG (QUOTE LIST))
(EQ TIEFLG (QUOTE EVERYTHING)))
(COND
((CDR VAL)
(DREVERSE VAL))
(T VAL)))
((AND (CDR VAL)
(NULL TIEFLG))
(* More than one.)
NIL)
(T (CAR VAL]
OUT1(RETURN VAL])
(CHOOZ1
[LAMBDA (NC1 NC2 SC) (* wt: 29-NOV-76 14 53)
(PROG (TEM)
(* The arithmetic expression computes the relative closeness as a percentage (times 100) by dividing the difference
|
between the average number of characters and the number of mistakes, over the average number of characters.
|
This is (((a+b) /2) -
|
sc) / (a+b) /2 Multiplying top and bottom by two gives (A+B-2*SC/A+B))
(RETURN (IQUOTIENT (ITIMES 100 (IDIFFERENCE (SETQ TEM (IPLUS NC1 NC2))
(ITIMES SC 2)))
TEM])
(SKOR0
[LAMBDA (TWORD NCXWORD NDBLS LST)
(* DD: "17-Dec-81 14:15")
(* A special call to SKOR for use by editor. LST is an exploded chconlst of characteers, NCXWORD the number of
characters in L, NDBLS the number of doubled characters. SKOR0 compares TWORD with L, and returns T if 'close'.)
(PROG ((NCTWORD (NCHARS TWORD))
SC TEM TAIL ALTFLG)
(RETURN (AND (COND
((IGREATERP NCTWORD NCXWORD)
(NOT (ILESSP (IQUOTIENT (ITIMES NCXWORD 100)
NCTWORD)
70)))
(T (IGREATERP [IQUOTIENT (ITIMES NCTWORD 100)
(COND
((EQ NCXWORD NDBLS)
1)
(T (IDIFFERENCE NCXWORD NDBLS]
70)))
(NUMBERP (SETQ SC (SKOR LST (DCHCON TWORD SKORLST2)
NCXWORD NCTWORD)))
(OR (ZEROP SC)
(IGREATERP (IQUOTIENT (ITIMES (IDIFFERENCE (SETQ TEM (COND
((IGREATERP NCXWORD NCTWORD)
NCXWORD)
(T NCTWORD)))
SC)
100)
TEM)
70])
(SKOR
[LAMBDA (XWORD TWORD NCX NCT FROMDWIM) (* wt: " 8-APR-80 10:56")
(* This algorithm counts the number of mistakes in the testword vis a vis the known word. A mistake is a character
in the known word that does not have a corresponding character in the test word, or vice versa.
Mistakes are not counted until the end of the scoring, so that transpositions are not counted as mistakes.
Instead, whenever an unexplained character is encountered, the tail is put in a buffer for the corresponding word.
(For reasons of efficiency, instead of a genuine buffer, two PROG variables are used for each word: T1, T2, X1, and
X2. Whenever these 'buffers' are exceeded, the skoring is aborted and NIL is returned as the value of SKOR.) When a
character is found that does not match, it is first compared with the buffer for the other word.
If it is there, it is not counted as a mistake but as out of order. Out of order characters are counted as mistakes
if they are misplaced by more than two positions, or if there are any other mistakes, e.g. substitutions or missing
letters. Also, double letters are not counted as mistakes, nor are shift mistakes, e.g. @RINT vs PRINT gives a value
of 0)
(PROG (X1 X2 T1 T2 X-1 XC TC (N 0)
(NTRANS 0)
TEM)
LP (SETQ XC (CAR XWORD))
(SETQ TC (CAR TWORD))
(COND
[(NULL XWORD)
(COND
((NULL TWORD)
(GO OUT))
(T (GO LP2]
((EQ XC 27) (* altmode)|
(COND|
((SETQ XWORD (CDR XWORD))|
(RETURN)))|
(SETQ TWORD NIL)|
(GO LP1))|
((NULL TWORD)
(GO LP1))
((OR (EQ XC TC)
(AND (OR (EQ XC (IPLUS TC 16))
(EQ XC (IDIFFERENCE TC 16)))
(SELECTQ TC
[(33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 64 75 76 77 78 79)
(* (! %" # $ %% & ' %( %) * + , -
%. / @ K L M N O) to their respective shift characters The last six transformations only operate on model 33's.)
(AND (EQ XC (IPLUS TC 16))
(OR MODEL33FLG (ILESSP TC 50]
[(49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 80 91 92 93 94 95)
(* (1 2 3 4 5 6 7 8 9 : ; < = > ? P %[ \ %] ↑ ←) to their respective shift characters)
(AND (EQ XC (IDIFFERENCE TC 16))
(OR MODEL33FLG (ILESSP TC 65]
NIL))
[AND (NULL MODEL33FLG)
(OR (AND (EQ XC 48)
(EQ TC 95))
(AND (EQ XC 95)
(EQ XC 48]
(AND (EQ XC (IPLUS TC 32))
(IGREATERP XC 96))
(AND (EQ TC (IPLUS XC 32))
(IGREATERP TC 96))
(AND (EQ TC 49)
(EQ XC 76)))
(* The 48-95 check is for 0 to ← The 32 check is for upper-lower case substitutions. The 49-76 check is typing L
|
instead of 1, i.e. misreading the LISP manual.)
(SETQ XWORD (CDR XWORD))
(SUB1VAR NCX)
(SETQ TWORD (CDR TWORD))
(SUB1VAR NCT)
(SETQ X-1 XC)
(GO LP)))
LP1 (COND
([AND T2 (OR (EQ XC (SETQ TEM (CAR T2)))
(AND (EQ XC (IPLUS TEM 32))
(IGREATERP XC 96))
(AND (EQ TEM (IPLUS XC 32))
(IGREATERP TEM 96]
(* Character encountered in TWORD before XWORD, e.g. the P in IPRNT vs PRINT. The case of RPINT vs PRINT is handled
specially without ever going to the buffers.)
(COND
((IGREATERP (FLENGTH T2)
(IPLUS NCX 2))
(ADD1VAR N))
(T (ADD1VAR NTRANS)))
(SETQ T2 NIL)
(SETQ XWORD (CDR XWORD))
(SUB1VAR NCX)
(SETQ X-1 XC)
(GO LP))
([AND T1 (OR (EQ XC (SETQ TEM (CAR T1)))
(AND (EQ XC (IPLUS TEM 32))
(IGREATERP XC 96))
(AND (EQ TEM (IPLUS XC 32))
(IGREATERP TEM 96]
(COND
((IGREATERP (FLENGTH T1)
(IPLUS NCX 2))
(ADD1VAR N))
(T (ADD1VAR NTRANS)))
(COND
(T2 (SETQ T1 T2)
(SETQ T2 NIL))
(T (SETQ T1 NIL)))
(SETQ XWORD (CDR XWORD))
(SUB1VAR NCX)
(SETQ X-1 XC)
(GO LP))
((NULL TWORD)
(GO LP3)))
LP2 (COND
([AND X2 (OR (EQ TC (SETQ TEM (CAR X2)))
(AND (EQ TC (IPLUS TEM 32))
(IGREATERP TC 96))
(AND (EQ TEM (IPLUS TC 32))
(IGREATERP TEM 96]
(COND
((IGREATERP (FLENGTH X2)
(IPLUS NCT 2))
(ADD1VAR N))
(T (ADD1VAR NTRANS))) (* Character encountered in XWORD first, e.g. I in IPRNT
|
vs PRINT.)
(SETQ X2 NIL)
(SETQ TWORD (CDR TWORD))
(SUB1VAR NCT)
(GO LP))
([AND X1 (OR (EQ TC (SETQ TEM (CAR X1)))
(AND (EQ TC (IPLUS TEM 32))
(IGREATERP TC 96))
(AND (EQ TEM (IPLUS TC 32))
(IGREATERP TEM 96]
(COND
((IGREATERP (FLENGTH X1)
(IPLUS NCT 2))
(ADD1VAR N))
(T (ADD1VAR NTRANS)))
(COND
(X2 (SETQ X1 X2)
(SETQ X2 NIL))
(T (SETQ X1 NIL)))
(SETQ TWORD (CDR TWORD))
(SUB1VAR NCT)
(GO LP))
((AND XWORD (EQ XC (CADR TWORD))
(EQ TC (CADR XWORD))
(NEQ TC (CADDR TWORD)))
(* Special check for most common case of transposition. The last clause is an attempt to distinguish the case of a
|
transposition from simply getting out of synch. e.g. consider MYCIN vs MICIN. The Y is discarded, and then we are
|
comparing CIN with ICIN. Treating CI as a transposition of IC is wrong in this case, since it matches with CI if the
|
I is discarded.)
(SETQ X-1 (CADR XWORD))
(SETQ XWORD (CDDR XWORD))
(SUB1VAR NCX)
(SUB1VAR NCX)
(ADD1VAR NTRANS)
(SETQ TWORD (CDDR TWORD))
(SUB1VAR NCT)
(SUB1VAR NCT)
(GO LP))
((IGREATERP NCT NCX) (* Remove from TWORD.)
(COND
((NULL T1)
(SETQ T1 TWORD))
((NULL T2)
(SETQ T2 TWORD))
([AND ALTFLG (OR (EQ XC X-1)
(EQ XC (CADR XWORD]
(* we already have two unaccounted for characters in tword, the (still) longer word. no point in checking for
|
doubled character in xword, because even if it were, still would be three characters unaccounted for.
|
however, if altflg is T, then worthwhile. reason why we dont do this before goig through T1 and T2 is that it might
|
NOT be a doubled character, but a missplaced character.)
(GO LP3))
(T (RETURN NIL)))
(SETQ TWORD (CDR TWORD))
(SUB1VAR NCT)
(GO LP)))
LP3 (COND
((OR (EQ XC X-1)
(EQ XC (CADR XWORD)))
(* About to remove from XWORD, check for double char. first check says was equal to last character.
|
This occurs when last character was correct. Second check says equal to next character, so throw this one away.)
(SETQ XWORD (CDR XWORD))
(SETQ NCXWORD (SUB1 NCXWORD))
(* Bound in CHOOZ. When computing value of SKOR, want to divide number of mistakes by actual length of word, i.e.
|
length minus number of doubled characters. Otherwise, making a word longer by adding extra characters will make it
|
CLOSER, e.g. ZZZZZZZ would correct to PP.)
(SUB1VAR NCX))
[[AND TAIL (NULL TWORD)
(NULL T1)
(NULL T2)
(NULL X1)
(NULL X2)
(ZEROP N)
(OR (ILESSP (ITIMES NTRANS 4)
NCTWORD)
(NULL (CDR XWORD]
(* The ilessp check is to discourage runon corrections when there is also a transposition unless the word is long,
|
e.g. PRETTYRPINTX will correct, but CNOSX wont.)
(RETURN (COND
((AND FROMDWIM CLISPFLG (FMEMB (FCHARACTER (CAR XWORD))
CLISPCHARS))
(* so that it does not consider runoncorrection splitting it at a clisp operator. E.g. if X*Y appears in your
|
functio and X is the name of a variable but Y is not, when dwim goes on to look for another corrrection because Y is
|
not bound, it shuld not offer X *Y as a possibility as this is almost always wrong.)
NIL)
([AND FROMDWIM CLISPFLG (OR (CDR XWORD)
(CDR TAIL))
(EQ (CAR XWORD)
(COND
(MODEL33FLG 79] (* mistyped O for ← on 33 or 0 for ← on 33)
(CONS 95 (CDR XWORD)))
(T XWORD]
(T (COND
((NULL X1)
(SETQ X1 XWORD))
((NULL X2)
(SETQ X2 XWORD))
(T (RETURN NIL)))
(SETQ XWORD (CDR XWORD))
(SUB1VAR NCX)
(SETQ X-1 XC)))
(GO LP)
OUT [COND
((AND (NULL XWORD)
(NULL TWORD)
T1 X1)
(SETQ T1 (FLENGTH T1))
(SETQ X1 (FLENGTH X1))
(AND T2 (SETQ T2 (FLENGTH T2)))
(AND X2 (SETQ X2 (FLENGTH X2)))
(COND
((OR (EQ T1 X1)
(EQ T1 X2)) (* Check for substitution errors.
|
Subtracts one so when two gets added below, net effect
|
is only counted as one.)
(SUB1VAR N)))
(COND
((AND T2 (OR (EQ T2 X1)
(EQ T2 X2)))
(SUB1VAR N]
[SETQ N (IPLUS N (COND
(X2 2)
(X1 1)
(T 0))
(COND
(T2 2)
(T1 1)
(T 0]
(RETURN (COND
((AND (NULL ALTFLG)
(OR (EQ N 0)
FASTYPEFLG))
(* If FASTYPEFLG is T, transpositions are not counted as errors. Otherwise, transpositions are counted if there are
other errors, i.e. if thee are no errors except for transpostions, SKOR returns 0.0)
N)
(T (IPLUS N NTRANS])
(MOVETOP
[LAMBDA (X L) (* Used by spelling block and
helpfixblock.)
(PROG ((Y L)
Z)
LP (COND
((NULL Y)
(RETURN L))
((NEQ (CAR Y)
X)
(SETQ Z Y)
(SETQ Y (CDR Y))
(GO LP))
((NEQ Y L)
(* Move to front of list)
(FRPLACD Z (CDR Y))
(FRPLACD Y (CDR L))
(FRPLACD L Y)
(FRPLACA Y (CAR L))
(FRPLACA L X)))
(RETURN L])
)
(RPAQ? USERWORDS )
(RPAQ? SPELLINGS1 (QUOTE (DEFINEQ ARGLIST MOVD GETD FNTYP BREAK UNBREAK REBREAK TRACE BREAKIN
MAKEFILE MAKEFILES LISTFILES FILES? WHEREIS CLEANUP PP PF EDITF
EDITV EDITP ADVISE UNADVISE UNSAVEDEF RECOMPILE TCOMPL COMPILE
BRECOMPILE BCOMPL MAPCAR MAPC LOAD LOADFROM LOADFNS TIME CLOSEF
CLOSEALL OPENP OUTPUT INPUT OUTFILE INFILE LOGOUT PUTPROP REMPROP
GETPROP SYSOUT CLISPIFY DWIMIFY EDITCALLERS FREEVARS CALLS)))
(RPAQ? SPELLINGS2 (QUOTE (GETPROP ADD1 AND APPEND ASSOC ATOM COND CONS COPY ELT EQ EQUAL ERROR ERSETQ
EVAL FASSOC FMEMB FRPLACA FRPLACD FUNCTION GO IDIFFERENCE IGREATERP
ILESSP IMINUS IPLUS ITIMES LENGTH LIST LISTP MAPC MAPCAR MAPCONC
MEMB MEMBER NCONC NCONC1 NEQ NLISTP NLSETQ NULL NUMBERP OR PRINT
PRIN1 PROG PROGN PUTPROP QUOTE READ RETURN RPLACA RPLACD SELECTQ
SETA SETQ SPACES SUB1 TERPRI ZEROP IF F/L VALUEOF FOR FETCH REPLACE
CREATE GETPROP PUTPROP DIFFERENCE GREATERP LESSP PLUS)))
(RPAQ? SPELLINGS3 (QUOTE (BROKENFNS ADVISEDFNS NOTLISTEDFILES FILELST NOTCOMPILEDFILES PROMPT#FLG
CLISPIFYPRETTYFLG DWIMIFYCOMPFLG FILERDTBL EDITRDTBL SYSPRETTYFLG
NOSPELLFLG INITIALS NIL)))
(RPAQ? SPELLSTR1 "{spellseparator}")
(RPAQ? SPELLSTR2 "{spellignore}")
(RPAQ? FIXSPELLREL 70)
(RPAQ? FIXSPELLDEFAULT (QUOTE y))
(RPAQ? SKORLST1 (QUOTE (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL
NIL)))
(RPAQ? SKORLST2 (QUOTE (NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL
NIL)))
(RPAQ? DWIMKEYLST NIL)
(RPAQ? FIXSPELLKEYLST NIL)
(RPAQ? FASTYPEFLG )
(RPAQ? RUNONFLG T)
(RPAQ? #USERWORDS 60)
(RPAQ? #SPELLINGS1 60)
(RPAQ? #SPELLINGS2 60)
(RPAQ? #SPELLINGS3 60)
(RPAQ? DWIMWAIT 10)
(RPAQ? RESPELLS )
(RPAQ? MODEL33FLG )
(NCONC1 SPELLINGS1 SPELLSTR1)
(NCONC1 SPELLINGS2 SPELLSTR1)
(ATTACH SPELLSTR1 SPELLINGS3)
[DECLARE: DONTEVAL@LOAD DOEVAL@COMPILE DONTCOPY
(BLOCK: FIXSPELLBLOCK MISSPELLED? FIXSPELL CHOOZ CHOOZ1 SKOR SKOR0 MOVETOP
(ENTRIES MISSPELLED? FIXSPELL CHOOZ SKOR0 SKOR MOVETOP)
(LOCALFREEVARS NCXWORD NCTWORD TAIL ALTFLG)
(GLOBALVARS CLISPCHARS CLISPFLG DWIMFLG EDITQUIETFLG FASTYPEFLG FCHARAR LASTWORD MODEL33FLG
NOSPELLFLG RUNONFLG SKORLST1 SKORLST2 SPELLINGS1 SPELLINGS2 SPELLSTATS1 SPELLSTR1
SPELLSTR2))
(BLOCK: FIXSPELL1 FIXSPELL1 FIXSPELL2 (GLOBALVARS APPROVEFLG COMMENTFLG CUTEFLG DWIMKEYLST DWIMWAIT
REREADFLG RESPELLS RUNONSTATS SPELLSTATS
SPELLSTATS1 VETOSTATS))
(BLOCK: ADDSPELLBLOCK ADDSPELL ADDSPELL1 (ENTRIES ADDSPELL ADDSPELL1)
(GLOBALVARS #SPELLINGS2 #SPELLINGS3 #USERWORDS LASTWORD SPELLINGS1 SPELLINGS2 SPELLINGS3
SPELLSTR1 SPELLSTR2 USERWORDS))
(BLOCK: NIL ADDSPELL2 (GLOBALVARS SPELLSTR2))
]
(PUTPROPS SPELL COPYRIGHT (NONE))
(DECLARE: DONTCOPY
(FILEMAP (NIL (3186 44989 (ADDSPELL 3198 . 5540) (ADDSPELL1 5544 . 9605) (ADDSPELL2 9609 . 9809) (
MISSPELLED? 9813 . 10586) (FIXSPELL 10590 . 20005) (FIXSPELL1 20009 . 26485) (FIXSPELL2 26489 . 26991)
(CHOOZ 26995 . 32633) (CHOOZ1 32637 . 33301) (SKOR0 33305 . 34395) (SKOR 34399 . 44423) (MOVETOP
44427 . 44986)))))
STOP