(FILECREATED " 2-Feb-86 18:41:06" {DSK}<LISPFILES2>LISP.LSP;2
 8381   

      changes to:  (VARS LISPCOMS))


(* Copyright (c) 1986 by Quintus Computer Systems, Inc. All rights reserved.)

(PRETTYCOMPRINT LISPCOMS)

(RPAQQ LISPCOMS
 ((FNS QL QP.lispify QP.lispify.cell QP.prologify R.call.lisp R.send.direct.Ai 
			R.send.direct.AiM R.send.variable.Ai R.send.variable.AiM R.start.calling)
		   (CONSTANTS QP.AV)))
(DEFINEQ

(QL

  (LAMBDA (N)
    (
SELECTQ
 N
	       (1 (QP.lispify.cell
 (
ReadPrologTag
 A1)
				     (
ReadPrologPtr
 A1)
				     T))
	       (2 (QP.lispify.cell
 (
ReadPrologTag
 A2)
				     (
ReadPrologPtr
 A2)
				     T))
	       (3 (QP.lispify.cell
 (
ReadPrologTag
 A3)
				     (
ReadPrologPtr
 A3)
				     T))
	       (4 (QP.lispify.cell
 (
ReadPrologTag
 A4)
				     (
ReadPrologPtr
 A4)
				     T))
	       (QP.lispify
 (add.cell QP.membot N)
			     T))))

(QP.lispify

  (LAMBDA (Ptr Debug)
    (QP.lispify.cell
 (
\GETBASEBYTE
 Ptr 0)
		       (
\GETBASEPTR
 Ptr 0)
		       Debug)))

(QP.lispify.cell

  (LAMBDA (Tag Ptr Debug)
    (
PROG
 (X N)
	L   (
SELECTC
 Tag
		       (ref.tag.8 (if
 (
\BASELESSP
 Ptr QP.membot)
				      then
 (if
 Debug
						 then
 (
RETURN
 (
LIST
 (
QUOTE
 %.)
									  (
QUOTE
 SHOULDNT)
									  Ptr))
					       else
 (SHOUDLNT (
QUOTE
 QP.lispify))))
				  (
SETQ
 N (
\GETBASEBYTE
 Ptr 0))
				  (
SETQ
 X (
\GETBASEPTR
 Ptr 0))
				  (if
 (
OR
 (
NEQ
 N 0)
					      (
NEQ
 X Ptr))
				      then
 (
SETQ
 Tag N)
					     (
SETQ
 Ptr X)
					     (
GO
 L))
				  (if
 (
NOT
 Debug)
				      then
 (
QP.OVERFLOW
 21)
				    elseif
 (
EQ
 Debug (
QUOTE
 S))
				      then
 (
RETURN
 Ptr)
				    else
 (
RETURN
 (
LIST
 (
QUOTE
 %.)
							     (if
 (
\BASELESSP
 Ptr QP.init.E)
								 then
 (
QUOTE
 Global)
							       else
 (
QUOTE
 Local))
							     Ptr))))
		       (list.tag.8 (
RETURN
 (
CONS
 (QP.lispify
 Ptr Debug)
						     (QP.lispify
 (
\ADDBASE
 Ptr 2)
								   Debug))))
		       (struct.tag.8 (if
 (
NOT
 Debug)
					 then
 (
QP.OVERFLOW
 21))
				     (
SETQ
 N (
LLSH
 (arity.of.cell Ptr)
						       1))
				     (
SETQ
 Tag (atom.of.cell Ptr))
				     (
SETQ
 X NIL)
				     (until
 (
EQ
 N 0)
					      (
SETQ
 X (
CONS
 (QP.lispify
 (
\ADDBASE
 Ptr N)
									      T)
								X))
					      (
SETQ
 N (
IDIFFERENCE
 N 2)))
				     (
RETURN
 (
CONS
 (
QUOTE
 %.)
						       (
CONS
 Tag X))))
		       (
RETURN
 Ptr)))))

(QP.prologify

  (LAMBDA (X Y)
    (if
 (
LISTP
 X)
	then
 (
\PUTBASEPTR
 Y 0 (get.24 H))
	       (
\PUTBASEBYTE
 Y 0 list.tag.8)
	       (
SETQ
 Y (get.24 H))
	       (increment.cell.pointer H 2)
	       (check.heap H)
	       (QP.prologify
 (
CAR
 X)
			       Y)
	       (QP.prologify
 (
CDR
 X)
			       (
\ADDBASE
 Y 2))
      elseif
 (
LITATOM
 X)
	then
 (
\PUTBASEPTR
 Y 0 X)
	       (
\PUTBASE
 Y 0 symbol.tag.16)
      elseif
 (
SMALLP
 X)
	then
 (
\PUTBASEPTR
 Y 0 X)
	       (
\PUTBASEBYTE
 Y 0 immed.tag.8)
      else
 (
\PUTBASEPTR
 Y 0 (
QP.ADD.REF
 X))
	     (
\PUTBASEBYTE
 Y 0 (if
 (
FIXP
 X)
				     then
 boxed.tag.8
				   elseif
 (
FLOATP
 X)
				     then
 float.tag.8
				   else
 other.tag.8)))))

(R.call.lisp

  (LAMBDA NIL
    (
SETQ
 MV.RETURNER0 (
SELECTC
 (get.16 I)
				    (0 (
APPLY*
 (get.24 C)))
				    (1 (
APPLY*
 (get.24 C)
						 MV.RETURNER0))
				    (2 (
APPLY*
 (get.24 C)
						 MV.RETURNER0 MV.RETURNER1))
				    (3 (
APPLY*
 (get.24 C)
						 MV.RETURNER0 MV.RETURNER1 MV.RETURNER2))
				    (4 (
APPLY*
 (get.24 C)
						 MV.RETURNER0 MV.RETURNER1 MV.RETURNER2 MV.RETURNER3))
				    (5 (
APPLY*
 (get.24 C)
						 MV.RETURNER0 MV.RETURNER1 MV.RETURNER2 MV.RETURNER3 
						 MV.RETURNER4))
				    (6 (
APPLY*
 (get.24 C)
						 MV.RETURNER0 MV.RETURNER1 MV.RETURNER2 MV.RETURNER3 
						 MV.RETURNER4 MV.RETURNER5))
				    (7 (
APPLY*
 (get.24 C)
						 MV.RETURNER0 MV.RETURNER1 MV.RETURNER2 MV.RETURNER3 
						 MV.RETURNER4 MV.RETURNER5 MV.RETURNER6))
				    (8 (
APPLY*
 (get.24 C)
						 MV.RETURNER0 MV.RETURNER1 MV.RETURNER2 MV.RETURNER3 
						 MV.RETURNER4 MV.RETURNER5 MV.RETURNER6 MV.RETURNER7))
				    (9 (
APPLY*
 (get.24 C)
						 MV.RETURNER0 MV.RETURNER1 MV.RETURNER2 MV.RETURNER3 
						 MV.RETURNER4 MV.RETURNER5 MV.RETURNER6 MV.RETURNER7 
						 MV.RETURNER8))
				    (10 (
APPLY*
 (get.24 C)
						  MV.RETURNER0 MV.RETURNER1 MV.RETURNER2 MV.RETURNER3 
						  MV.RETURNER4 MV.RETURNER5 MV.RETURNER6 MV.RETURNER7 
						  MV.RETURNER8 MV.RETURNER9))
				    (11 (
APPLY*
 (get.24 C)
						  MV.RETURNER0 MV.RETURNER1 MV.RETURNER2 MV.RETURNER3 
						  MV.RETURNER4 MV.RETURNER5 MV.RETURNER6 MV.RETURNER7 
						  MV.RETURNER8 MV.RETURNER9 MV.RETURNER10))
				    (12 (
APPLY*
 (get.24 C)
						  MV.RETURNER0 MV.RETURNER1 MV.RETURNER2 MV.RETURNER3 
						  MV.RETURNER4 MV.RETURNER5 MV.RETURNER6 MV.RETURNER7 
						  MV.RETURNER8 MV.RETURNER9 MV.RETURNER10 
						  MV.RETURNER11))
				    (13 (
APPLY*
 (get.24 C)
						  MV.RETURNER0 MV.RETURNER1 MV.RETURNER2 MV.RETURNER3 
						  MV.RETURNER4 MV.RETURNER5 MV.RETURNER6 MV.RETURNER7 
						  MV.RETURNER8 MV.RETURNER9 MV.RETURNER10 
						  MV.RETURNER11 MV.RETURNER12))
				    (14 (
APPLY*
 (get.24 C)
						  MV.RETURNER0 MV.RETURNER1 MV.RETURNER2 MV.RETURNER3 
						  MV.RETURNER4 MV.RETURNER5 MV.RETURNER6 MV.RETURNER7 
						  MV.RETURNER8 MV.RETURNER9 MV.RETURNER10 
						  MV.RETURNER11 MV.RETURNER12 MV.RETURNER13))
				    (15 (
APPLY*
 (get.24 C)
						  MV.RETURNER0 MV.RETURNER1 MV.RETURNER2 MV.RETURNER3 
						  MV.RETURNER4 MV.RETURNER5 MV.RETURNER6 MV.RETURNER7 
						  MV.RETURNER8 MV.RETURNER9 MV.RETURNER10 
						  MV.RETURNER11 MV.RETURNER12 MV.RETURNER13 
						  MV.RETURNER14))
				    (16 (
APPLY*
 (get.24 C)
						  MV.RETURNER0 MV.RETURNER1 MV.RETURNER2 MV.RETURNER3 
						  MV.RETURNER4 MV.RETURNER5 MV.RETURNER6 MV.RETURNER7 
						  MV.RETURNER8 MV.RETURNER9 MV.RETURNER10 
						  MV.RETURNER11 MV.RETURNER12 MV.RETURNER13 
						  MV.RETURNER14 MV.RETURNER15))
				    (
SHOULDNT
 "Too many arguments in Lisp call")))
    (put.24 R QP.AV)
    (put.24 S (get.24 H))
    (put.24 C (get.24 H))
    (increment.cell.pointer H (get.16 N))
    (until
 (zero N)
	     (QP.prologify
 (
GETTOPVAL
 (
CAR
 (get.24 R)))
			     (get.24 C))
	     (put.24 R (
CDR
 (get.24 R)))
	     (increment.cell.pointer C)
	     (decrement.counter N))
    (read.continue 0)))

(R.send.direct.Ai

  (LAMBDA NIL
    (put.32 T0 (get.Aval N))
    (
SETTOPVAL
 (
CAR
 (get.24 R))
		 (QP.lispify.cell
 (
ReadPrologTag
 T0)
				    (
ReadPrologPtr
 T0)
				    (
QUOTE
 S)))
    (put.24 R (
CDR
 (get.24 R)))
    (read.continue 0)))

(R.send.direct.AiM

  (LAMBDA NIL
    (put.32 T0 (get.Amem N))
    (
SETTOPVAL
 (
CAR
 (get.24 R))
		 (QP.lispify.cell
 (
ReadPrologTag
 T0)
				    (
ReadPrologPtr
 T0)
				    (
QUOTE
 S)))
    (put.24 R (
CDR
 (get.24 R)))
    (read.continue 0)))

(R.send.variable.Ai

  (LAMBDA NIL
    (put.32 T0 (get.Aval N))
    (
SETTOPVAL
 (
CAR
 (get.24 R))
		 (QP.lispify.cell
 (
ReadPrologTag
 T0)
				    (
ReadPrologPtr
 T0)))
    (put.24 R (
CDR
 (get.24 R)))
    (read.continue 0)))

(R.send.variable.AiM

  (LAMBDA NIL
    (put.32 T0 (get.Amem N))
    (
SETTOPVAL
 (
CAR
 (get.24 R))
		 (QP.lispify.cell
 (
ReadPrologTag
 T0)
				    (
ReadPrologPtr
 T0)))
    (put.24 R (
CDR
 (get.24 R)))
    (read.continue 0)))

(R.start.calling

  (LAMBDA NIL                                                (* defined I C R)

    (put.16 I (
LOGAND
 (get.code P 0)
			255))
    (put.24 C (
\VAG2
 0 (get.code P 1)))
    (put.24 R QP.AV)
    (read.continue 2)))
)
(DECLARE: EVAL@COMPILE 

(RPAQQ QP.AV
 (MV.RETURNER0 MV.RETURNER1 MV.RETURNER2 MV.RETURNER3 MV.RETURNER4 MV.RETURNER5 
			     MV.RETURNER6 MV.RETURNER7 MV.RETURNER8 MV.RETURNER9 MV.RETURNER10 
			     MV.RETURNER11 MV.RETURNER12 MV.RETURNER13 MV.RETURNER14 MV.RETURNER15))

(CONSTANTS QP.AV)
)
(PUTPROPS LISP.LSP COPYRIGHT ("Quintus Computer Systems, Inc" 1986))
(DECLARE: DONTCOPY
  (FILEMAP (NIL (422 7992 (QL 432 . 933) (QP.lispify 935 . 1073) (QP.lispify.cell 1075 . 2657) (
QP.prologify 2659 . 3462) (R.call.lisp 3464 . 6712) (R.send.direct.Ai 6714 . 6980) (R.send.direct.AiM 
6982 . 7249) (R.send.variable.Ai 7251 . 7497) (R.send.variable.AiM 7499 . 7746) (R.start.calling 7748
 . 7990)))))
STOP