Trailing-Edge
-
PDP-10 Archives
-
decus_20tap1_198111
-
decus/20-0004/uci.xfo
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