There are no other files named uci.xfo in the archive.

(FILECREATED "17-NOV-74 00:38:44" UCI.XFORMS;1 31549 ) (DEFINEQ (DROPOFFP [LAMBDA (FORMS) (* Function to decide if a PROG expression can 'drop off'. In UCI lisp this is guaranteed to return NIL, so the TRANSFORMATIONS for PROG use DROPOFFP to decide if they need to insert (RETURN NIL) at end of PROG.) (PROG [(LASTFORM (CAR (LAST FORMS] (SELECTQ (CAR LASTFORM) ((GO RETURN) (RETURN)) [COND (RETURN (OR (NEQ T (CAAR (LAST LASTFORM))) (SOME (CDR LASTFORM) (FUNCTION DROPOFFP] (RETURN T]) (UCISCAN [LAMBDA (FILE) (PRESCAN FILE (QUOTE ((47 . 37) (37 . 47]) (UCITRANSOR [LAMBDA (FILE) (TRANSOR (UCISCAN FILE]) ) (LISPXPRINT (QUOTE XFORMSFNS) T T) (RPAQQ XFORMSFNS (DROPOFFP UCISCAN UCITRANSOR)) (LISPXPRINT (QUOTE XFORMSVARS) T T) (RPAQQ XFORMSVARS ((TRANSAVE))) (RPAQQ DUMPFILE UCI.XFORMS) [RPAQQ USERNOTES ((*FUNCTION: (* *FUNCTION is not implemented in BBN-lisp. FUNARG is implemented, tentatively and differently, as a second argument to the function FUNCTION. the user must recode this expression, carefully.)) [*MAX/*MIN (* The UCILISP functions *MAX and *MIN must be defined by the user. Herewith a definition of *MAX. (LAMBDA (X y) (COND ((GREATERP X Y) X) (T Y] (ADD1: (* ADD1, ZEROP and and SUB1 in BBN lisp fix their arguments before checking or incrementing, i.e. are an integer functions only.)) (ALIST (* UCILISP allows an extra optional argument to EVAL and APPLY which is either an alist or a pointer into the context stack. BBN LISP does not have this feature and it must be re-hacked by the user.)) (APPLY/EVAL (* TRANSOR will translate the arguments of the APPLY or EVAL expression, but the user must make sure that the run-time evaluation of the arguments returns a BBN-compatible expression.) ) (ARG1: (* This particular instance of the function ARG or SETARG could not be successfully translated, because TRANSOR could not find the containing lambda-atom expression, thus could not identify the lambda variable which must be inserted as the first argument to the ARG or SETARG. See comment on successful translations of ARG.)) (ARG: (* In UCILISP, lsubrs (i.e. expr*'s) take a single lambda-variable, which is bound to the number of arguments actually supplied at run-time. So also in bbn-lisp; but whereas the reference in UCILISP is (ARG N) , where the name of the lambda-variable is implicit, in bbn-lisp the reference is (ARG FOO N) where FOO is the (quoted) name of the lambda variable. TRANSOR looks up the appropriate variable name and inserts it, but users should probably check to make sure TRANSOR got the right lambda-expression. If TRANSOR cannot find a containing expr* lambda-expression, a separate note is made.) The same translation is also made for SETARG.) (ARRAY: (* UCILISP (ARRAY FOO T index1 index2 ...) converts to (SETQ FOO (ARRAY (ITIMES INDEX1 INDEX2 ...) )) and (ARRAY FOO number i1 i2 ...) to (SETQ FOO (ARRAY (ITIMES I1 I2 ...) (ITIMES I1 I2 ...))) %. Since the indexes may be dotted pairs specifying boundaries, the use may have to rewrite the computation of those indexes. Users should further note that in UCILISP the default is zero orgin indexing, the fifth element of the array FOO is accessed by (FOO 5) where in BBN, FOO is a variable, bound to a pointer to the array which itself prints as #12345, i.e. the octal address. See manual discussion on arrays. The fifth element must be retrieved by (ELT FOO 5) %. There is no way to anticipate this in TRANSOR.)) (ARRAYS (* There is no facilitiy for external arrays in BBN LISP.)) (BASE: (* The UCILISP function BASE should convert directly to BBN's RADIX.)) (CHARACTERCODE (* The UCI functions ASCII and CHRVAL should be directly replacable by the BBN function CHARACTER and CHCON1 respectively This transformation has been performed, but the user should watch out for such problems as different use of control characters, etc.)) (CHRCT: (* The UCILISP function CHRCT can usually be replaced by the appropriate use of position, which returns the number of chars already typed on the line instead of the number to go.)) (CLRBFI: (* (CLRBFI) is converted to (CLEARBUF T) %.)) (DDTIN: (* The UCI LISP function DDTIN has been changed to control. The user should note that control always returns NIL where DDTIN returns the previous setting of the switch.)) (DECLARATION (* Compiler declarations are changed into comments.)) (DEFPROP-MACRO (* Macros are converted to FEXPRS by the following method. The macro FOO with definition [LAMBDA (L) --] is changed to [LAMBDA (L) ([LAMBDA (L) --] (CONS (QUOTE FOO) L] %. This method is wasteful because it uses an extra CONS cell and will not compile open.)) (ERR: (* UCI'S ERR is said to return the value of its argument to the last ERRORSET or to the top level if none. Ignoring the top level problem my translation, (RETFROM (QUOTE ERRORSET) X) , should work ok. If the toplevel case arises at runtime you will get error 19, illegal stack ARG, and (ERROR!) will do.)) (ERRORX (* BBN LISP does not directly handle the ERRORX forms of ERRSET and ERR. The problem can be gotten around by defining two new functions, ERRSET-ERRORX and ERR-ERRORX. The definition of ERRSET-ERRORX should be [NLAMBDA (X) (CONS (EVAL X] , and the definition of ERR-ERRORX should be [LAMBDA NIL (RETFROM ERRSET-ERRORX (QUOTE ERRORX] %.)) (ERRSET: (* The expression (ERRSET X Y) where X and Y are forms, translates to (ERRORSET (QUOTE X) (QUOTE Y)) %.)) (EXPR* (* The UCI function type LSUBR should translate without user assistance to BBN EXPR*'S. However, see notes on the use of the function ARG.)) (FARRAY (* BBN LISP does not support FLOATING point arrays, no changes have been made to this expression.)) (FDEFPROP (* Funny DEFPROP: too few args. Translation of it abandoned.)) (GC: (* UCILISP GC converts to bbn RECLAIM)) (GCTIME (* I did not think that UCI'S function GCTIME took any arguments. Nothing done to this form.)) (GET1: (* Expression of form (GET & (QUOTE PNAME)) user must recode any such direct manipulations of the pname.)) (GET: (* Expression of the form (GET & (QUOTE VALUE)) converted to (CAR &) but the user should beware , in UCI LISP the actual value is the CDR of the result of the GET. See bbn-lisp manual discussion of atom value cells and global variables.)) (GETSYM: (* GETSYM and PUTSYM are undefined. functions which uses them probably have to be completely recoded at a higher level. However, there are a large number of DDT symbols already represented, however, by property entries on the property coreval, which is widely used by the compiler and may be added to as you wish. Don't clobber existing ones, though. COREVALS is a list of extant symbols; the rest have to be brought over by hand from DDT and may change with new assemblies.)) (GO (* In UCI LISP, if the argument to GO is not a tag of a containing PROG, then it is evaluated to obtain a tag. This glitch has been used in the above places, and has been translated by gathering up all tags from the closest containing PROG, and constructing a dispatch of the form (SELECTQ original-form (TAG1 (GO TAG1)) (TAG2 (GO TAG2)) ... (HELP (QUOTE "ILLEGAL TAG"))) %.)) (GREATERP/LESSP (* UCI'S GREATERP and LESSP take an indefinite number of args and test to see that they are in order. Accordingly, where these functions were used with exactly two args they were allowed to stand, but in the cases noted here they were actually called with extra arguments and must be replaced with something written for the purpose.)) (GRIN (* Since the UCI functions GRINDEF and GRINL handle values, properties, expressions, and LAP code, as well as funtions, they cannot simply be replaced by BBN PRETTYPRINT funtions.)) (HYPERBOLIC (* Hyperbolic functions are not defined in BBN LISP, but the user can easily define them himself.)) (IBASE: (* The input RADIX for lisp is always decimal. To input octal numbers, they must be typed or printed with a Q following.)) (INTEGERFN? (* At the places noted above, an UCI arithmetic function has been converted to a general arithmetic fn in the BBN system. This choice is rather conservative, since most of the time the conversion could probably be made to the corresponding BBN integer arithmetic function. For the advantages of using integer fns whenever possible, see chapter 13 of the BBN lisp manual. Users may accept the conservative choice; or they may eyeball their listings and substitute the integer functions themselves by hand, or they may choose to revise the transformations to convert to the integer functions and then search by hand for those places where the general function was really required. The latter approach is best when one knows in advance that the object program does no floating point arithmetic.)) (INTERN (* No direct match for INTERN exists on BBN Lisp.)) (INTERN/MAKNAM (* The expression (INTERN (MAKNAM FOO)) converts to (PACK FOO) , but there is no BBN equivalent to INTERN or MAKNAM alone; user must decide what is being attempted.)) (IOFNS (* Random grubby IO functions, documented in chapter 14 of SRI LISP SAILON 28.5 and chapter 4 of the UCI LISP manual, most of which I am too lazy to fix up.) ) (LABEL (* The LABEL device is not implemented in BBN lisp.)) (LAP: Following this form will be lines of machine-code with a NIL terminator. This code will have to be edited and rewritten by the use.) (LAZY (* I did not really expect this fn to appear and will (may) write TRANSFORMATIONS for it if it does.)) (LINEREAD: (* LINEREAD converts to READLINE)) (LOAD: (* UCI lisp's function LOAD is not defined in bbnlisp. BBN's LOAD is a symbolic lisp-file reader and has nothing to do with loading rel files.)) (MACHINE-CODE (* Expression dependent on machine-code. User must recode.)) (MAKNUM: (* MAKNUM converts to LOC. But users should perhaps make sure that the overall sense of functions which do boxing and unboxing is still reasonable.) ) (MAPFNS (* User must recode here. UCI mapping functions all permit an indefinite number of list arguments. Where only one was used, they translate correctly to BBN lisp, but in the places noted above, extra list arguments were utilized, and the output expression will be of the form (MAPFN L1 (FUNCTION BLAH) L2 L3 --))) [MAX/MIN (* The UCILISP functions MAX and MIN must be defined by the user. Herewith a definition of MAX. (LAMBDA NARGS (PROG ((N 2) V BST) (SETQ BST (ARG NARGS 1)) LP (SETQ BST (*MAX BST (ARG NARGS N)) ) (COND ((IGREATERP (SETQ N (ADD1 N)) NARGS) (RETURN BST))) (GO LP] (NOBIND (* (UNBOUND) converts to (QUOTE NOBIND))) (NOUUO: (* NOUUO is not defined in BBN LISP. For discussion of linkage between compiled functions see compiler chapter of BBN LISP manual.)) (NUMBERS (* When comparing numbers, EQP should be used instead of EQUAL. This change has been made.)) (NUMVAL: (* NUMVAL converts to VAG. But users should perhaps make sure that the overall sense of functions which do boxing and unboxing is still reasonable.) ) (PRIN1: (* PRIN1 converts to PRIN2.)) (PRINC1: (* PRINC converts to PRIN1.)) [PRINT: (* UCILISP PRINT outputs a carriage-return and linefeed before the argument is printed, not after, and outputs a space after. Nothing has been done to it on the grounds that most I/O code tends to get pretty thoroughly revised anyway. Users may however convert all calls to PRINT in their program to calls to UCIPRINT by performing (MAPC FNS (F/L (CHANGENAME X 'PRINT 'UCIPRINT))) and then define UCIPRINT with (LAMBDA (X) (TERPRI) (PRIN2 X) (SPACES 1] (PUTPROP1: (* Expression of form (PUTPROP & & (QUOTE PNAME)) user must recode any such direct manipulations of pnames.)) (PUTPROP: (* Expression of form (PUTPROP & & (QUOTE VALUE)) converted to (RPLACA & (CDR &)) See BBN LISP manual discussion of atom value cells and global variables.)) (READ-MACRO (* BBN LISP allows neither read macro characters nor arbitrary redfinition of characters. The user will have to fix these up himself, perhaps by writing his own read routine.)) (READCH: (* READCH converts to READC)) (READLIST (* The function READLIST has been replaced with PACK, although it differs from PACK in two ways. First, READLIST only takes the first character of the elements of the list it is given. If some of these have more than one character, they will be included entire by BBN'S PACK. But rather than do (NTHCHAR * 1) around every element of the argument list, I have left it to the user to detect when and if the UCI. program utilized this feature. Secondly, BBN'S PACK returns an atom come what may; UCI'S READLIST operates by 'UNREADING' and may therefore return lists. Again, the user must check for this, since there is no reasonable way to check for it from TRANSOR.)) (REMPROP (* On UCI Lisp REMPROP returns T if the property was there, on BBN returns name of property always. User must check if value being used.)) (RETFROM: (* RETFROM has been left unchanged.)) (SASSOC: (* A call to SASSOC failed to translate correctly. The last (functional) argument was not in the expected format, (FUNCTION [LAMBDA NIL --]) %. User must repair the expression.)) (SET (* SET on UCI LISP cannot affect compiled function variables which are not special. This may be used by some functions, to allow their local variables to become invisible. There is nothing TRANSOR can do about this however; users will just have to find such usage themselves.)) (SPEAK: (* UCILISP SPEAK converts to BBN CONSCOUNT. See manual for extra features of CONSCOUNT.)) (SPECPDL (* UCI LISP expects fexpr's to be of the form [LAMBDA (ARG) --] or [LAMBDA (ARG SPECIAL/THINGY) --] %. The former is converted by TRANSOR to the BBN equivalent, [NLAMBDA ARG --] %. The latter has no direct equivalent and the user will have to hack it out himself should it arise. At the places noted here, it arose.)) (SPRINT: (* SPRINT has been changed to PRINTDEF)) (STACKFN (* These functions access the context stack. Since UCI'S stack works somewhat differently than BBN's, these functions will most probably have to be rewritten.)) (STORE: (* The UCILISP function STORE is used by (STORE (name i1 i2 ...) value) where i1, i2, etc. are indexes to a multiply-indexed array. Where only one index is given, this converts to BBN's (SETA NAME I1 VALUE) %. Where more than one index occurred, a separate remark, STOREMI, was made.)) (STOREMI (* Use of UCILISP STORE with multiple indexes. User must do his own indexing since BBN arrays are all one-dimensional.)) (TIME (* I did not think that UCI'S function TIME took any arguments. Nothing done to this form.)) [TYI: (* The UCILISP function TYI inputs one char as an asciz code and has been converted to (CHCON1 (READC] (TYO: (* The UCI LISP function TYO outputs one character, and accepts for its argument an asciz number, so it has been converted to (PRIN1 (CHARACTER X)) %.)) (UDF (* This function is not defined directly in BBN Lisp)) (VALUE (* At the places noted above, reference was made to the property indicators PNAME or VALUE. This usage probably should be revised to be (CAR (QUOTE &)) or perhaps the atom should be put on GLOBALVARS. I don't know what usage of pname might involve since pnames are not kept on property lists in bbn-lisp. To get the pname of an atom perform (CDR (VAG (IPLUS 2 (LOC ATOM] (RPAQQ NLISTPCOMS NIL) [RPAQQ LAMBDACOMS ((IF [NULL (FMEMB (CAAAR L) (QUOTE (LAMBDA NLAMBDA] ((REMARK BLAMBDA1) (-1 APPLY*)) ((IF (NEQ (LENGTH (## (NTH 2))) (LENGTH (## 1 2))) ((REMARK BLAMBDA2)) NIL) MARK (ORR (1 (NTH 3) DOTHESE) ((REMARK BLAMBDA3))) __ (NTH 2) DOTHESE] (RPAQQ TRANSFORMATIONS (*APPEND *DIF *EVAL *EXPAND *EXPAND1 *FUNCTION *GREAT *LESS *MAX *MIN *PLUS *QUO *TIMES /DEREAD ACOS ADD1 AND# APPLY APPLY# ARG ARRAY ASCII ASIN ASSOC ASSOC# ATAN BASE BOOLE BREAK CHRCT CHRVAL CLRBFI COND CONSP COS COSD COSH DDTIN DE DECLARE DEFPROP DEPOSIT DF DIFFERENCE DIVIDE DM DRM DSKIN DSKOUT DSM EQUAL ERR ERRSET EVAL EVALV EXAMINE EXARRAY EXCISE EXP EXPLODE EXPLODEC FLATSIZE FLATSIZEC FNDBRKPT FREE FREELIST GC GCD GCTIME GET GETL GETSYM GO GREATERP GRINDEF GRINL HGHCOR HGHEND HGHORG IBASE INC INITFN INITPROMPT INPUT INTERN LABEL LAP LAST LESSP LEXORDER LINEREAD LOAD MAKNAM MAKNUM MAP MAPC MAPCAN MAPCAR MAPCONC MAPLIST MAX MEMBER# MEMQ MEMQ# MIN MODCHR NCONC NCONS NEXTEV NILL NOCALL NOUUO NUMVAL OR# OUTC OUTPUT OUTVAL PATOM PREVEV PRIN1 PRINC PRINLEV PRINTLEV PROG PROG2 PROMPT PUTPROP PUTSYM QUOTE QUOTIENT RANDOM READLIST REMAINDER REMOB REMPROP RETFROM SASSOC SELECTQ SET SETARG SETCHR SETQ SETSYS SIN SIND SINH SPDLFT SPDLPT SPDLRT SPEAK SPECIAL SPREDO SPREVAL SPRINT STKCOUNT STKNAME STKNTH STKPTR STKSRCH STORE SUB1 SUBST SYSCLR TAN TANH TCONC TERPRI TIME TTYECHO TYI TYO UNBOUND UNSPECIAL UNTYI XCONS ZEROP)) (DEFLIST(QUOTE( (*APPEND ((1 APPEND))) (*DIF ((1 DIFFERENCE) (REMARK INTEGERFN?))) (*EVAL ((1 EVAL) (REMARK APPLY/EVAL))) (*EXPAND ((REMARK UDF))) (*EXPAND1 ((REMARK UDF))) (*FUNCTION ((1 FUNCTION) (REMARK *FUNCTION:) 2 (NTH 3) DOTHESE)) (*GREAT ((1 GREATERP) (REMARK INTEGERFN?))) (*LESS ((1 LESSP) (REMARK INTEGERFN?))) (*MAX ((REMARK *MAX/*MIN))) (*MIN ((REMARK *MAX/*MIN))) (*PLUS ((1 PLUS) (REMARK INTEGERFN?))) (*QUO ((1 QUOTIENT) (REMARK INTEGERFN?))) (*TIMES ((1 TIMES) (REMARK INTEGERFN?))) (/DEREAD ((REMARK READ-MACRO))) (ACOS ((1 ARCCOS) (N T))) (ADD1 ((REMARK ADD1:))) (AND# ((1 AND))) (APPLY ((REMARK APPLY/EVAL) (IF (## 4) ((REMARK ALIST)) NIL))) (APPLY# ((1 APPLY) (REMARK APPLY/EVAL))) [ARG ((BIND MARK (LPQ 0 (_ LAMBDA) (S #1 2) (IF (LISTP #1))) __ (IF (LITATOM #1) ((I -2 #1) (REMARK ARG:)) ((REMARK ARG1:] (ARRAY ((REMARK ARRAY:) (IF (## 3) ((1 SETQ) (IF (## 5) ((EMBED (4 TO) IN ITIMES)) NIL) [IF (EQ (## 3) T) NIL ((I N (LIST (## 4] (3 ARRAY) (BI 3 -1) -1 (NTH 2)) ((REMARK FARRAY) (NTH 4))) DOTHESE)) (ASCII ((1 CHARACTER) (REMARK CHARACTERCODE))) (ASIN ((1 ARCSIN) (N T))) (ASSOC ((1 FASSOC))) (ASSOC# ((1 SASSOC))) (ATAN ((1 ARCTAN) (N T))) (BASE ((1 RADIX) (REMARK BASE:))) [BOOLE (ORR ((IF (EQ (## 2) 7)) (1 LOGOR)) ((IF (EQ (## 2) 1)) (1 LOGAND)) ((IF (EQ (## 2) 6)) (1 LOGXOR)) ((REMARK UDF] (BREAK ((1 BREAK1) (SW 2 4))) (CHRCT ((REMARK CHRCT:))) (CHRVAL ((1 CHCON1) (REMARK CHARACTERCODE))) (CLRBFI ((1 CLEARBUF) (N T) (REMARK CLRBFI:))) (COND (1 (LPQ NX DOTHESE))) (CONSP ((1 LISTP))) (COS ((N T))) (COSD ((1 COS))) (COSH ((REMARK HYPERBOLIC))) (DDTIN ((1 CONTROL) (REMARK DDTIN:))) (DE ((REMARK LAZY))) (DECLARE ((REMARK DECLARATION) (BI 1 -1) (-1 *) NLAM)) [DEFPROP ((ORR ((IF (NLISTP (CDDDAR L))) (REMARK FDEFPROP) NLAM) ((IF (EQ (## -1) (QUOTE VALUE))) (1 RPAQQ) (I 3 (CDR (## 3))) (4) NLAM) ((IF (SELECTQ (## -1) ((EXPR FEXPR MACRO) NIL) T)) (1 PUT) (EMBED 2 IN QUOTE) (SW 3 4) (EMBED 3 IN QUOTE) (EMBED 4 IN QUOTE) NLAM) ((1 DEFINEQ) (IF (EQ (## 4) (QUOTE MACRO)) ((REMARK DEFPROP-MACRO) (4 FEXPR) (INSERT CONS (## 2) (## 3 2 1) AFTER 3) (EMBED 5 IN QUOTE) (BI 4 6) (BI 3 4) (INSERT LAMBDA (## 3 1 2) BEFORE 3) (BI 3 5)) NIL) (IF (EQ (## 4) (QUOTE FEXPR)) [(CHANGE 3 1 TO NLAMBDA) (IF (## 3 2 2) ((REMARK SPECPDL)) ((EXTRACT 1 FROM 3 2] NIL) (4) (BI 2 3) 2 2 3 UP DOTHESE] (DEPOSIT ((1 CLOSER) (REMARK MACHINE-CODE))) (DF ((REMARK LAZY))) (DIFFERENCE ((IF (## 4) ((EMBED (3 TO) IN PLUS)) NIL) (REMARK INTEGERFN?))) (DIVIDE ((REMARK UDF))) (DM ((REMARK LAZY))) (DRM ((REMARK READ-MACRO))) (DSKIN ((REMARK IOFNS))) (DSKOUT ((REMARK IOFNS))) (DSM ((REMARK READ-MACRO))) (EQUAL ((IF (OR (NUMBERP (## 2)) (NUMBERP (## 3))) ((1 EQP) (REMARK NUMBERS)) NIL))) [ERR ((IF (## 2) ([IF (EDIT4E (QUOTE (ERR (QUOTE ERRORX))) (##)) ((REMARK ERRORX)) ((1 RETFROM) (-2 (QUOTE ERRORSET] (REMARK ERR:)) ((: (ERROR!)) 1] [ERRSET ((ORR ((IF (EDIT4E (QUOTE (ERRSET & NIL)) (##))) (3) (1 NLSETQ)) ((IF (EDIT4E (QUOTE (ERRSET & T)) (##))) (3) (1 ERSETQ)) ((IF (EDIT4E (QUOTE (ERRSET & ERRORX)) (##))) (REMARK ERRORX)) ((IF (EDIT4E (QUOTE (ERRSET &)) (##))) (1 ERRORSET) (EMBED 2 IN QUOTE) (N T)) ((1 ERRORSET) (EMBED 2 IN QUOTE) (EMBED 3 IN QUOTE] (EVAL ((REMARK APPLY/EVAL) (IF (## 3) ((REMARK ALIST)) NIL))) (EVALV ((REMARK STACKFN))) (EXAMINE ((1 OPENR) (REMARK MACHINE-CODE))) (EXARRAY ((REMARK ARRAYS))) (EXCISE ((REMARK UDF))) (EXP ((1 ANTILOG))) (EXPLODE ((1 UNPACK) (N T))) (EXPLODEC ((1 UNPACK))) (FLATSIZE ((1 NCHARS) (N T))) (FLATSIZEC ((1 NCHARS))) (FNDBRKPT ((REMARK STACKFN))) (FREE ((REMARK IOFNS))) (FREELIST ((REMARK IOFNS))) (GC ((1 RECLAIM) (REMARK GC:))) (GCD ((REMARK UDF))) [GCTIME ((IF (## 2) ((REMARK GCTIME)) ((1 CLOCK) (N 3] [GET ((ORR ((IF (EDIT4E (QUOTE (GET & (QUOTE VALUE))) (##))) (REMARK GET:) (1 CAR) (3)) ((IF (EDIT4E (QUOTE (GET & (QUOTE PNAME))) (##))) (REMARK GET1:)) ((1 GETP] (GETL ((1 GETLIS) (IF (AND (EQ (## -1) (QUOTE QUOTE)) (INTERSECTION (QUOTE (VALUE PNAME)) (## -1 -1))) ((REMARK VALUE)) NIL))) (GETSYM ((REMARK GETSYM:))) (GO ((IF (NULL (LITATOM (## 2))) ((REMARK GO) (BIND MARK (_ PROG) (E [MAPC (CDDR (##)) (FUNCTION (LAMBDA (Y) (AND Y (LITATOM Y) (SETQ #1 (CONS (LIST Y (LIST (QUOTE GO) Y)) #1] T) __ (1 SELECTQ) (I N #1) (BO -1) (N (HELP (QUOTE "ILLEGAL GOTO"))) 2 DOTHIS)) NIL))) (GREATERP ((IF (EQ 3 (LENGTH (CAR L))) NIL ((REMARK GREATERP/LESSP))) (REMARK INTEGERFN?))) (GRINDEF ((REMARK GRIN))) (GRINL ((REMARK GRIN))) (HGHCOR ((REMARK IOFNS))) (HGHEND ((REMARK IOFNS))) (HGHORG ((REMARK IOFNS))) (IBASE ((REMARK IBASE:))) (INC ((REMARK IOFNS))) (INITFN ((REMARK UDF))) (INITPROMPT ((REMARK IOFNS))) (INPUT ((REMARK IOFNS))) [INTERN ((IF (EDIT4E (QUOTE (INTERN (MAKNAM &))) (##)) ((1 PACK) (EXTRACT -1 FROM -1)) ((REMARK INTERN/MAKNAM] (LABEL ((REMARK LABEL))) (LAP ((REMARK LAP:))) (LAST ((1 FLAST))) (LESSP ((IF (EQ 3 (LENGTH (CAR L))) NIL ((REMARK GREATERP/LESSP))) (REMARK INTEGERFN?))) (LEXORDER ((1 ALPHAORDER))) (LINEREAD ((1 READLINE) (REMARK LINEREAD:))) (LOAD ((REMARK LOAD:))) (MAKNAM ((REMARK INTERN/MAKNAM))) (MAKNUM ((1 LOC) (REMARK MAKNUM:))) (MAP ((SW 2 3) (IF (## 4) ((REMARK MAPFNS)) NIL))) [MAPC ((ORR (5 0 (REMARK MAPFNS)) (4 0 (1 MAP2C) (MOVE 2 TO N HERE)) ((MOVE 2 TO N HERE] (MAPCAN ((1 MAPCONC) (SW 2 3) (IF (## 4) ((REMARK MAPFNS)) NIL))) (MAPCAR ((SW 2 3) (IF (## 4) ((REMARK MAPFNS)) NIL))) (MAPCONC ((SW 2 3) (IF (## 4) ((REMARK MAPFNS)) NIL))) (MAPLIST ((SW 2 3) (IF (## 4) ((REMARK MAPFNS)) NIL))) (MAX ((REMARK MAX/MIN) (REMARK *MAX/*MIN))) (MEMBER# ((1 MEMBER))) (MEMQ ((1 MEMB))) (MEMQ# ((1 MEMB))) (MIN ((REMARK MAX/MIN) (REMARK *MAX/*MIN))) (MODCHR ((REMARK READ-MACRO))) (NCONC (ORR ((IF (EDIT4E (QUOTE (NCONC & (NCONS &))) (##))) (1 NCONC1) 3 (XTR 2) 0) ((IF (## 4) (EMBED (3 THRU) IN NCONC))) NIL)) (NCONS ((1 CONS))) (NEXTEV ((REMARK STACKFN))) (NILL ((1 *))) (NOCALL ((REMARK DECLARATION) (BI 1 -1) (-1 *) NLAM)) (NOUUO ((REMARK NOUUO:))) (NUMVAL ((1 VAG) (REMARK NUMVAL:))) (OR# ((1 OR))) (OUTC ((REMARK IOFNS))) (OUTPUT ((REMARK IOFNS))) (OUTVAL ((REMARK STACKFN))) (PATOM ((1 NLISTP))) (PREVEV ((REMARK STACKFN))) (PRIN1 ((1 PRIN2) (REMARK PRIN1:))) (PRINC ((1 PRIN1) (REMARK PRINC1:))) (PRINLEV ((REMARK IOFNS))) (PRINTLEV ((REMARK IOFNS))) (PROG ((IF (DROPOFFP (CAR L)) ((N (RETURN))) NIL) (NTH 3) DOTHESE)) [PROG2 ((ORR ([IF (MEMBER (## 2) (QUOTE (0 T NIL] (1 PROG1) (2)) ([IF (EQ 3 (LENGTH (##] (1 PROGN)) ((1 (LAMBDA (X Y) Y] (PROMPT ((REMARK IOFNS))) [PUTPROP ((ORR ((IF (EDIT4E (QUOTE (PUTPROP & & (QUOTE VALUE))) (##))) (REMARK PUTPROP:) (1 RPLACA) (EMBED 3 IN CDR) (4)) ((IF (EDIT4E (QUOTE (PUTPROP & & (QUOTE PNAME))) (##))) (REMARK PUTPROP1:)) ((1 PUT) (SW 3 4] (PUTSYM ((REMARK GETSYM:))) (QUOTE (NLAM)) (QUOTIENT ((IF (## 4) ((EMBED (3 TO) IN TIMES)) NIL) (REMARK INTEGERFN?))) (RANDOM ((1 RAND) (N 0.0 1.0))) (READLIST ((1 PACK) (REMARK READLIST))) (REMAINDER ((1 IREMAINDER))) (REMOB ((REMARK UDF))) (REMPROP ((REMARK REMPROP))) (RETFROM ((REMARK RETFROM:))) [SASSOC ((1 FASSOC) (MBD OR) (MOVE 2 4 TO N HERE) -1 (ORR ((IF (EDIT4E (QUOTE (FUNCTION [LAMBDA NIL &])) (##))) (XTR 2 3)) ((IF (EDIT4E (QUOTE (FUNCTION [LAMBDA NIL & & --])) (##))) (XTR 2) (EMBED (3 TO) IN PROGN) (XTR 3)) ((REMARK SASSOC:] [SELECTQ (2 DOTHIS (LPQ NX (IF (## NX UP) ((NTH 2) DOTHESE 0) (DOTHIS] (SET ((REMARK SET))) [SETARG ((BIND MARK (LPQ 0 (_ LAMBDA) (S #1 2) (IF (LISTP #1))) __ (IF (LITATOM #1) ((I -2 #1) (REMARK ARG:)) ((REMARK ARG1:] (SETCHR ((REMARK READ-MACRO))) (SETQ ((IF (## 3) (3 DOTHIS) NIL))) (SETSYS ((REMARK IOFNS))) (SIN ((N T))) (SIND ((1 SIN))) (SINH ((REMARK HYPERBOLIC))) (SPDLFT ((REMARK STACKFN))) (SPDLPT ((REMARK STACKFN))) (SPDLRT ((REMARK STACKFN))) (SPEAK ((1 CONSCOUNT) (REMARK SPEAK:))) (SPECIAL ((REMARK DECLARATION) (BI 1 -1) (-1 *) NLAM)) (SPREDO ((REMARK STACKFN))) (SPREVAL ((REMARK STACKFN))) (SPRINT ((1 PRINTDEF) (REMARK SPRINT:))) (STKCOUNT ((REMARK STACKFN))) (STKNAME ((REMARK STACKFN))) (STKNTH ((REMARK STACKFN))) (STKPTR ((REMARK STACKFN))) (STKSRCH ((REMARK STACKFN))) (STORE ((1 SETA) (MOVE 2 1 TO BEFORE 2) (IF (## 3 2) ((REMARK STOREMI) 3 DOTHESE NX DOTHIS) ((BO 3))) (REMARK STORE:))) (SUB1 ((REMARK ADD1:))) (SUBST ((IF (EQ (## 2) (## 3)) ((1 COPY)) NIL))) (SYSCLR ((REMARK UDF))) (TAN ((N T))) (TANH ((REMARK HYPERBOLIC))) (TCONC ((SW 2 3))) (TERPRI ((IF (## 2) ((MBD PROGN) (MOVE 2 2 TO AFTER 2)) NIL))) [TIME ((IF (## 2) ((REMARK TIME)) ((1 CLOCK) (N 0] (TTYECHO ((REMARK IOFNS))) (TYI ((REMARK TYI:) (1 READC) (MBD CHCON1))) (TYO ((REMARK TYO:) (1 PRIN1) (EMBED 2 IN CHARACTER))) (UNBOUND ((1 QUOTE) (N NOBIND) (REMARK NOBIND))) (UNSPECIAL ((REMARK DECLARATION) (BI 1 -1) (-1 *) NLAM)) (UNTYI ((REMARK IOFNS))) [XCONS ((1 (LAMBDA (X Y) (CONS Y X] [ZEROP ((IF (EDIT4E (QUOTE (ZEROP (*ANY* (DIFFERENCE & &) *DIF))) (##)) ((1 EQP) (BO 2) (2)) ((REMARK ADD1:] ))(QUOTE XFORM)) [COND [(EQ (EVALV (QUOTE MERGE)) T) [RPAQ TRANSFORMATIONS (UNION TRANSFORMATIONS (LISTP (GETP (QUOTE TRANSFORMATIONS) (QUOTE VALUE] (MAPC (GETP (QUOTE USERNOTES) (QUOTE VALUE)) (FUNCTION (LAMBDA (NOTE) (OR (ASSOC (CAR NOTE) USERNOTES) (SETQ USERNOTES (CONS NOTE USERNOTES] (T (MAPC (GETP (QUOTE TRANSFORMATIONS) (QUOTE VALUE)) (FUNCTION (LAMBDA (X) (AND (NOT (MEMB X TRANSFORMATONS)) (/REMPROP X (QUOTE XFORM] (DECLARE: DONTCOPY (FILEMAP (NIL (61 781 (DROPOFFP 73 . 631) (UCISCAN 635 . 715) ( UCITRANSOR 719 . 778))))) STOP