Trailing-Edge
-
PDP-10 Archives
-
decus_20tap1_198111
-
decus/20-0004/sri.xfo
There are no other files named sri.xfo in the archive.
(FILECREATED "11-SEP-74 15:42:32" SRI.XFORMS;2 11398
previous date: "11-SEP-74 15:13:08" SRI.XFORMS;1)
(LISPXPRINT (QUOTE XFORMSVARS)
T)
(RPAQQ XFORMSVARS ((TRANSAVE)))
(RPAQQ DUMPFILE SRI.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.))
(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.)
)
(ARRAYS (* Array function. No transformations for these
functions have been composed yet.))
(CHARACTERCODE (* The SRI function ASCII should be directly
replacable by the BBN function CHARACTER.
This transformation has been performed, but
the user should watch out for such problems
as different use of control characters,
etc.))
(DEFPROP-MACRO (* * macro properties go here eventually. I
don't have any to do in QA3 except SELECTQ
and ORV, which disappear anyway, so this
clause temporarily shorted out.))
(DEFPROP: (* DEFPROP to VALUE doesn't have the usual NIL in
place.))
(EXPR* (* The function ARG is currently implemented to take
two arguments, the (quoted)
name of the lambda variable, which is bound to the
number of args supplied, and the number of the ARG
desired. Thus PROGN becomes [LAMBDA (X)
(ARG X X]
%. This implementation is somewhat tentative. In
other respects EXPR*'S work as on the 94O. SRI
LEXPR'S should therefore TRANSOR without user
assistance, until BBN EXPR*'S are changed, if that
happens.))
(FDEFPROP (* Funny DEFPROP: too few args. Translation of it
abandoned.))
(GCTIME (* I did not think that sri's function GCTIME took
any arguments. Nothing done to this form.))
(GO (* Non-atomic args to GO are evaluated repeatedly to get
a tag on SRI-LISP, when interpreting. Compiled, this
glitch does not work, even at SRI. It can probably be
accomplished on BBN Lisp, while interpreting only, by
(APPLY (FUNCTION GO)
non-atomic-form)
%. This glitch has been used at the above places in
the object code. TRANSOR has generated the APPLY
expression and translated its argument, but the user
is advised to beware of gross bummery.))
(GREATERP/LESSP (* SRI'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.))
(INTERN (* No direct match for INTERN exists on BBN Lisp.))
(IOFNS (* Random grubby IO functions, documented in chapter
14 of SAILON 28.2, which I am too lazy to fix up.))
(LABEL (* The LABEL device is not implemented in BBN lisp.))
(LAZY (* I did not really expect this fn to appear and will
(may)
write TRANSFORMATIONS for it if it does.))
(MACHINE-CODE (* Expression dependent on machine-code. User
must recode.))
(READLIST (* The function READLIST has been replaced with
PACK, although it differs from PACK in two ways.
First, it 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 SRI program utilized this feature. Secondly,
BBN'S PACK returns an atom come what may; SRI'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 SRI Lisp REMPROP returns T if the property was
there, on BBN returns name of property always.
User must check if value being used.))
(SASSOC: (* This expression is a correct translation of
SRI's function SASSOC, but the code is ugly and
users may want to rewrite it.))
(SET (* SET on SRI lisp cannot affect compiled function VARS
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 debug it themselves.)
)
(TIME (* I did not think that SRI'S function TIME took any
arguments. Nothing done to this form.))
(UDF (* This function is not defined directly in BBN Lisp]
(RPAQQ NLISTPCOMS NIL)
[RPAQQ LAMBDACOMS (IF (SELECTQ (## 1 1)
([LAMBDA NLAMBDA]
T)
NIL)
(MARK 1 (NTH 3)
DOTHESE __ (NTH 2)
DOTHESE)
((REMARK BLAMBDA1)
(-1 APPLY*]
(RPAQQ TRANSFORMATIONS
(*APPEND *DIF *FUNCTION *GREAT *LESS *PLUS *QUO *TIMES APPLY
ARG ARRAY ASCII ASSOC BOOLE CHRCT CLOCK COND CSYM
DDTIN DDTOUT DE DEFPROP DEPOSIT DF DIFFERENCE DIVIDE
DM DREMOVE ERR ERRSET EVAL EXAMINE EXARRAY EXPLODE
EXPLODEC FIX FLATSIZE FORCE FUNCTION GCD GCTIME GET
GETL GO GREATERP INC INPUT INTERN LABEL LESSP MAKNAM
MAP MAPC MAPCAR MAPCONC MAPLIST MEMQ NCONS NSTORE
NTH1 ORV OUTC OUTPUT PRIN1 PRINC PRINT PROG PROG2
PUTPROP QUOTE QUOTIENT READ READCH READLIST REMAINDER
REMOB REMPROP SASSOC SELECTQ SET SETQ STORE SUBST
TERPRI TIME TYI TYO UUO XCONS ZEROP))
(DEFLIST(QUOTE(
(*APPEND ((1 APPEND)))
(*DIF ((1 DIFFERENCE)))
(*FUNCTION ((REMARK *FUNCTION:)
2
(NTH 3)
DOTHESE))
(*GREAT ((1 GREATERP)))
(*LESS ((1 LESSP)))
(*PLUS ((1 PLUS)))
(*QUO ((1 QUOTIENT)))
(*TIMES ((1 TIMES)))
(APPLY ((REMARK APPLY/EVAL)))
[ARG ((REMARK EXPR*)
(I -2 (## (_ LAMBDA)
2]
(ARRAY ((REMARK ARRAYS)))
(ASCII ((1 CHARACTER)
(REMARK CHARACTERCODE)))
(ASSOC ((1 FASSOC)))
[BOOLE ((IF (EQ (## 2)
7)
((1 LOGOR))
((REMARK UDF]
(CHRCT ((REMARK LAZY)))
[CLOCK ((IF (EQ (## 2)
1)
((1 DATE)
(2))
((2 0]
(COND (1 (LPQ NX DOTHESE)))
(CSYM ((REMARK LAZY)))
(DDTIN (DELETE))
(DDTOUT (DELETE))
(DE ((REMARK LAZY)))
[DEFPROP ((ORR ((IF (NLISTP (CDDDAR L)))
(REMARK FDEFPROP)
NLAM)
((IF (EQ (## -1)
(QUOTE MACRO)))
(REMARK DEFPROP-MACRO))
((IF (EQ (## -1)
(QUOTE VALUE)))
(1 RPAQQ)
(IF [AND (LISTP (## 3))
(NULL (CAR (## 3]
[(I 3 (CDR (## 3]
((REMARK DEFPROP:)))
(4)
NLAM)
((IF (SELECTQ (## -1)
((EXPR FEXPR)
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 FEXPR))
((EXTRACT 1 FROM 3 2)
(CHANGE 3 1 TO NLAMBDA)
(REMARK SPECPDL))
NIL)
(4)
(BI 2 3)
2 2 3 UP DOTHESE]
(DEPOSIT ((1 CLOSER)
(REMARK MACHINE-CODE)))
(DF ((REMARK LAZY)))
[DIFFERENCE ((IF (CDDDR (##))
((EMBED (3 TO)
IN PLUS))
(NIL]
(DIVIDE ((REMARK UDF)))
(DM ((REMARK LAZY)))
(DREMOVE ((1 SRI-DREMOVE)))
[ERR ((IF (## 2)
((1 RETFROM)
(-2 (QUOTE ERRORSET)))
((1 ERROR!]
[ERRSET ((ORR ([IF (NULL (CADDR (##]
(1 ERSETQ)
(ORR ((3))
NIL))
((IF (EQ (## 3)
T))
(1 NLSETQ)
(3))
((1 ERRORSET)
2 DOTHIS (MBD QUOTE)
NX DOTHIS (MBD NOT]
(EVAL ((REMARK APPLY/EVAL)))
(EXAMINE ((1 OPENR)
(REMARK MACHINE-CODE)))
(EXARRAY ((REMARK ARRAYS)))
(EXPLODE ((1 UNPACK)))
(EXPLODEC ((1 UNPACK)
(N T)))
(FIX ((1 IPLUS)))
(FLATSIZE ((1 NCHARS)))
(FORCE (DELETE))
(FUNCTION (2 (IF (LISTP (##))
((NTH 3)
DOTHESE)
NIL)))
(GCD ((REMARK UDF)))
[GCTIME ((IF (## 2)
((REMARK GCTIME))
((1 CLOCK)
(N 3]
(GET ((1 GETP)))
(GETL ((EMBED 3 IN LIST)))
(GO ((IF (NULL (LITATOM (## 2)))
((REMARK GO)
(-1 APPLY)
(EMBED 2 IN FUNCTION))
NIL)))
[GREATERP ((IF (EQ 3 (LENGTH (CAR L)))
NIL
((REMARK GREATERP/LESSP]
(INC ((REMARK IOFNS)))
(INPUT ((REMARK IOFNS)))
(INTERN ((REMARK INTERN)))
(LABEL ((REMARK LABEL)))
[LESSP ((IF (EQ 3 (LENGTH (CAR L)))
NIL
((REMARK GREATERP/LESSP]
(MAKNAM ((REMARK INTERN)))
(MAP ((SW 2 3)))
(MAPC ((SW 2 3)))
(MAPCAR ((SW 2 3)))
(MAPCONC ((SW 2 3)))
(MAPLIST ((SW 2 3)))
(MEMQ ((1 MEMB)))
(NCONS ((1 CONS)))
(NSTORE ((REMARK ARRAYS)))
(NTH1 ((1 CAR)
(EMBED (2 TO)
IN NTH)))
(ORV ((1 OR)))
(OUTC ((REMARK IOFNS)))
(OUTPUT ((REMARK IOFNS)))
(PRIN1 ((REMARK IOFNS)))
(PRINC ((1 PRIN2)
(REMARK IOFNS)))
(PRINT ((REMARK IOFNS)))
(PROG ((IF (DROPOFFP (CAR L))
((N (RETURN)))
NIL)
(NTH 3)
DOTHESE))
[PROG2 ((ORR ((IF (ZEROP (## 2)))
(1 PROG1)
(2))
([IF (EQ 3 (LENGTH (##]
(1 PROGN))
((1 (LAMBDA (X Y)
Y]
(PUTPROP ((1 PUT)
(SW 3 4)))
(QUOTE (NLAM))
[QUOTIENT ((IF (CDDDR (##))
((EMBED (3 TO)
IN TIMES))
(NIL]
(READ ((REMARK IOFNS)))
(READCH ((REMARK IOFNS)))
(READLIST ((REMARK READLIST)))
(REMAINDER ((1 IREMAINDER)))
(REMOB ((REMARK INTERN)))
(REMPROP ((REMARK REMPROP)))
[SASSOC ((IF (## 4)
[(1 OR)
(EMBED (2 THRU 3)
IN FASSOC)
-1
(IF (EDIT4E (QUOTE (FUNCTION [LAMBDA NIL &]))
(##))
((XTR -1 -1))
((MBD APPLY)
(REMARK SASSOC:]
((1 FASSOC]
[SELECTQ (2 DOTHIS (LPQ NX (IF (## NX)
((NTH 2)
DOTHESE 0)
(DOTHIS]
(SET ((REMARK SET)))
(SETQ (3 DOTHIS))
(STORE ((REMARK ARRAYS)))
[SUBST ((IF (EDIT4E (QUOTE (SUBST 0 0 &))
(##))
((1 COPY))
(NIL]
(TERPRI ((REMARK IOFNS)))
[TIME ((IF (## 2)
((REMARK TIME))
((1 CLOCK)
(N 0]
(TYI ((REMARK IOFNS)))
(TYO ((REMARK IOFNS)))
(UUO ((REMARK MACHINE-CODE)))
[XCONS ((1 (LAMBDA (X Y)
(CONS Y X]
[ZEROP ((IF (EDIT4E (QUOTE (ZEROP (DIFFERENCE & &)))
(##))
((1 EQP)
(BO 2)
(2))
(NIL]
))(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)))
STOP