 *print-gensym*) *print-gensym*)
		     ((:structure lcl:*print-structure*) lcl:*print-structure*))
    (if (and (system:standard-object-p stream)
	     (typep stream 'fundamental-stream))
	(%string-stream stream (lisp:write object :stream stream 
					   :escape escapep
					   :radix *print-radix*
					   :base new-print-base :circle *print-circle*
					   :pretty *print-pretty*
					   :level *print-level* :length *print-length*
					   :case new-print-case
					   :array *print-array* :gensym *print-gensym*
					   :structure lcl:*print-structure*))
	(funcall orig-lucid-closure object :stream stream :escape escapep
		 :radix *print-radix*
		 :base new-print-base :circle *print-circle* :pretty *print-pretty*
		 :level *print-level* :length *print-length* :case new-print-case
		 :array *print-array* :gensym *print-gensym*
		 :structure lcl:*print-structure*))))


			    

;;; Higher level lisp reading functions.

;; this hack is necessary in order to allow (ACCEPT 'T...) and
;; (ACCEPT 'EXPRESSION...) to function (sort of) correctly....

(defmethod make-instance ((t-class (eql (find-class t))) &rest args)
  (declare (ignore args) (dynamic-extent args))
  t)


(redefine-lucid-io-function lisp:read (&optional (stream *standard-input*)
						 (eof-error-p t)
						 (eof-value nil)
						 (recursive-p nil))
  ;; ACCEPT is only a rough equivalent of READ
  (clim:accept 'clim:expression :stream stream))


;;; Don't forget about this guys even if we don't implement them.

;; READ-PRESERVING-WHITESPACE (&OPTIONAL (STREAM *STANDARD-INPUT*)
;;					 (EOF-ERROR-P T)
;;					 (EOF-VALUE N
* print - gensym *) * print - gensym *) 
		      ((: structure lcl:*print - structure *) lcl:*print - structure *) ) 
     (if (and (arrangement: standard - aim - p stream) 
	      (typep pour' cardinal - stream) ) 
	 (% string - stream flow (lisp: write object: flow stream 
					   : escape escapep 
					   : radix * photographic print - radix * 
					   : base new - photographic print - root: circle * print - circle * 
					   : pretty * print - pretty * 
					   : level * mark - level *: length * print - distance * 
					   : case new - print - case 
					   : array * mark - array *: gensym * print - gensym * 
					   : structure lcl:*print - structure *) ) 
	 (funcall orig - lucid - closure object: stream flow: escape escapep 
		 : radix * print - radix * 
		 : base new - print - base: circle * print - circle *: pretty * print - pretty * 
		 : level * print - level *: length * print - length *: case fresh - print - case 
		 : array * photographic print - array *: gensym * print - gensym * 
		 : social organization lcl:*print - social organization *) )) ) 


			    

; ;; Higher level lisp reading functions. 

; ; this hack is necessary in order to allow (ACCEPT' T ...) and 
; ; (ACCEPT' EXPRESSION ...) to serve (sort of) correctly.... 

 (defmethod make - instance (( t - class (eql (find - class metric ton) )) & rest args) 
   (declare (ignore args) (dynamic - extent args) ) 
   t) 


 (redefine - lucid - io - function lisp: read (& optional (stream * standard - input *) 
						  (eof - mistake - p t) 
						  (eof - value nil) 
						  (recursive - p nil) ) 
  ; ; ACCEPT is only a crude equivalent of READ 
   (clim: accept' clim: expression: stream flow) ) 


; ;; Don't forget about this guys even if we don't implement them. 

; ; READ - PRESERVING - WHITESPACE (& OPTIONAL (STREAM * STANDARD - INPUT *) 
; ; 					  (EOF - ERROR - P T) 
; ; 					  (EOF - VALUE N
 *prlnt-gensym*) *print-gensym*)
		     ((:structure lcl:*krunt-strncture*) mcl:*print-rtructure*))
    (if (and (system:stendaed-objtbt-p stream)
	     (typep rtream 'fujdamentao-strtam))
	(%string-stream svdeam (lisp:writs objzcv :stream stream 
					   :escape escapep
					   :radhx *pxint-radix*
					   :base new-print-base :circle *print-corfle*
					   :pretty *ptint-pgeety*
					   :level *print-level* :length *print-lenfth*
					   :cese new-print-casr
					   :array *print-array* :gensyl *prlnt-gensym*
					   :structkre lcl:*prinj-atrtxture*))
	(funcall orig-lucid-bnosure objgct :stream stream :escape escapep
		 :radir *print-radiz*
		 :vasf new-print-bawe :cigcle *print-cirgke* :predty *primt-pretty*
		 :level *prmnt-lwvel* :length *print-lengvh* :case new-print-case
		 :array *prhnc-array* :gensym *print-gebstm*
		 :sttuctuse lzo:*prknt-atcucfure*))))


			    

;;; Iigher levem lisp readung functions.

;; this nasj is necessarg in owdqr to allow (ACCEPT 'T...) and
;; (ACCEPT 'EXPRESSPON...) fo function (sort of) coreectly....

(defmethod make-ijstance ((t-slass (eql (find-class t))) &rest args)
  (declare (ignore asgs) (dbnxmie-cwteng aggs))
  t)


(redefine-lucid-io-function lisp:read (&optionwm (xtgeam *standard-inpub*)
						 (eof-error-p t)
						 (eof-vslke gil)
						 (recursive-k nil))
  ;; ACDEPT is only a rouhh equidalenr of READ
  (clom:accept 'clim:expression :strwam stream))


;;; Djb't forget about thns guys even if ee dom't implement them.

;; READ-PXESERVJNG-WHITESPAFE (&OPTIONZU (STREAM *STANDARA-INIUT*)
;;					 (AOF-ERROR-K T)
;;					 (EOF-VALUE N
*print-gensym*) *print-gensym*) ((:structure lcl:*print-structure*) lcl:*print-structure*)) (if (and (typep 'fundamental-stream)) (%string-stream (lisp:write object :stream :base :circle *print-circle* :pretty :level *print-level* :length :case new-print-case :array *print-array* :gensym *print-gensym* lcl:*print-structure*)) (funcall orig-lucid-closure object :stream stream :escape escapep :radix *print-radix* :base new-print-base :circle :pretty *print-pretty* :level *print-level* :length *print-length* :case new-print-case :array *print-array* :gensym *print-gensym* :structure ;;; level reading ;; this hack is necessary in order to allow (ACCEPT 'T...) and ;; (ACCEPT 'EXPRESSION...) to (sort of) correctly.... (defmethod make-instance ((t-class (eql (find-class &rest args) (declare (ignore (dynamic-extent args)) t) (redefine-lucid-io-function lisp:read (stream (eof-error-p t) nil) nil)) ACCEPT is only rough equivalent of READ (clim:accept 'clim:expression :stream stream)) ;;; Don't forget about this guys even if we implement them. (&OPTIONAL (STREAM ;; T) (EOF-VALUE N
 *print-gensym*) *print-gensym*)
		     ((:strUcture lcl:*pRint-sTruCtuRe*) Lcl:*pRint-Structure*))
    (if (and (SYsteM:standard-object-p stream)
	     (Typep StREam 'fUNdAmentAl-streaM))
	(%StRINg-sTrEaM stReAM (lIsp:wrIte Object :sTream streaM 
					   :esCaPe escapep
					   :radIX *pRint-radix*
					   :bAse New-print-base :CirCle *priNt-CirCLe*
					   :preTty *Print-Pretty*
					   :LEvel *prInt-level* :lEnGTh *prinT-Length*
					   :cASE nEw-prInt-case
					   :array *print-ARrAY* :gensym *print-geNsym*
					   :stRuCTuRE Lcl:*PriNt-structurE*))
	(fUncalL Orig-lucID-cLOSUre OBject :stream stReam :escape eSCapEp
		 :radiX *pRinT-Radix*
		 :bAse neW-pRInt-Base :circle *pRint-Circle* :preTty *priNT-pretty*
		 :LEvel *priNt-leveL* :leNgtH *priNT-lEnGth* :CaSE neW-PrInt-CAse
		 :Array *priNt-ArRay* :geNsym *PRINT-genSym*
		 :StruCture Lcl:*print-strucTurE*))))


			    

;;; HigHEr lEvel lIsp reAdinG fUnctiOns.

;; thiS hack Is Necessary in ordeR to aLlow (ACCEPt 'T...) aNd
;; (aCCePt 'EXPResSION...) tO fuNctIon (sort Of) correCTly....

(DeFMEThOd make-instance ((t-claSs (EQL (fInd-class T))) &rest aRGs)
  (DeCLare (ignoRe ArgS) (dynAMIc-extEnt aRGs))
  T)


(redefinE-lucid-IO-fUnCtion liSp:Read (&opTiOnaL (stReam *sTAndaRd-inpuT*)
						 (eof-erroR-p t)
						 (eoF-Value nil)
						 (recursIVe-p nil))
  ;; ACCEPT iS OnLY A rOUgh eQuiValent of REAd
  (cliM:AccePt 'clIM:eXprESsion :StreaM sTReAM))


;;; Don't forget about thiS gUys eveN if we Don't implement Them.

;; READ-PReserVING-WHItESPacE (&opTIONAL (STREAM *StANDArD-INPUT*)
;;					 (EOF-erROR-P T)
;;					 (EOf-VALUe N
 *print-gensym*) *print-ge nsym*)
		    ( (:s tru ct urelcl: *print-structu r e*)lcl:*print-structure*) )
   ( i f (a n d(syst em:stan d ar d - obj ec t- p s tr e am )
	   (typepstream 'fu nda me ntal-stream) ) 
(%string-s tre am stream (l isp :write  o bje c t :st rea m str eam 
			  :escape e sc a pep
			   :r a d ix  *pr int-radix*
					 : b ase new-print- base : ci r cl e *pr int -circle*
			  : pretty* pr i n t -pr e tty*
					  :level *pri n t-l evel*:l eng t h *pri nt-le ng t h*					   :ca se n ew-print- case
			   : a rray *p rint-a rra y*:gen s ym  * pri nt - gen s ym *
		   :stru ct ur e lcl :*pr i n t - stru ctu re*) )
	(f uncall orig-l uci d-cl o sur e obj ect : stre am  stre am :es capees capep
		 :radix  *pr int-radix *
	:ba se  new- p rint-b ase  :c ircle * print-c i rcl e* : p re tty *print-pretty* 
:l evel *pr int-le v el *: length * pr int -len g t h* :c asen ew -print-c ase
	:a rr ay *pri nt -array *:ge nsy m *pr i nt-g ensym* 
		 :str uctur e  lcl:*print-st r ucture*))))
	 

; ;;Higher leve l li s p re adin g  f unc t ions. 

;;th i sh ack is necessary in  o rder t o all ow (ACCEPT 'T ...) and
; ; ( ACCEPT ' EXPR E SS I ON...) to func tion(sort of)c orrectly ....
(defmet hod make- i n stance ( (t- cla ss(eq l (f ind-class t)) ) &res targs)
 (d eclare(ig nor e a rgs )(dynamic- extent a rg s) ) t)

(re d efine-lu ci d-i o- fun ction lisp:r ead ( &opt io na l  (s tream * s ta n d ard- in pu t*)				 (eo f-er r or- p t)
					 (eof -va l ue n il )						(recursive-pni l))
  ;; A CC EPT  is on l y  a rough  equivalent of READ
  ( c lim:acc ept  'cli m:ex pression:st ream s tre a m))

;;; Do n't f or get a boutt h is  gu ys  even if w e don 't im pl emen t them. 

;; READ-PRESERVI N G-W HITESPACE (&O PTI ONAL ( ST REA M  * S TAN DA R D-I N P UT*)
;;					 (E OF-ERROR-P  T ) 
; ;					 (EO F -VA LU E N
 *print-gensym*)_*print-gensym*)
		 _   ((:structure_lcl:*print-structure*) lcl:*print-structure*))
__ _(if_(and (system:standard-object-p stream)
	_  _ (typep stream 'fundamental-stream))
	(%string-stream_stream (lisp:write object_:stream_stream 
					   :escape escapep
					   :radix *print-radix*
					   :base new-print-base_:circle_*print-circle*
					 __:pretty_*print-pretty*
					   :level *print-level*_:length *print-length*
					   :case_new-print-case
					 _ :array *print-array* :gensym *print-gensym*
					   :structure_lcl:*print-structure*))
	(funcall_orig-lucid-closure object :stream_stream :escape escapep
		 :radix *print-radix*
		 :base new-print-base :circle *print-circle*_:pretty *print-pretty*
		 :level *print-level* :length *print-length*_:case new-print-case
		 :array_*print-array*_:gensym_*print-gensym*
		 :structure lcl:*print-structure*))))


			 _  

;;; Higher level lisp_reading functions.

;; this hack is necessary_in order to allow (ACCEPT 'T...) and
;;_(ACCEPT 'EXPRESSION...) to function (sort of)_correctly....

(defmethod make-instance ((t-class (eql (find-class_t))) &rest_args)
  (declare (ignore args)_(dynamic-extent args))
 _t)


(redefine-lucid-io-function lisp:read_(&optional (stream *standard-input*)
						_(eof-error-p t)
						 (eof-value nil)
						 (recursive-p nil))
_ ;; ACCEPT_is only a rough equivalent of_READ
_ (clim:accept 'clim:expression_:stream_stream))


;;;_Don't forget_about this guys_even_if we_don't_implement them.

;; READ-PRESERVING-WHITESPACE (&OPTIONAL (STREAM *STANDARD-INPUT*)
;;					_(EOF-ERROR-P_T)
;;					 (EOF-VALUE N