In DJ: L.SYS; SYSDCL.LISP#280
In DJ: L.SYS2; DEFMAC.LISP#84
In DJ: L.SYS2; LMMAC.LISP#451
  23*   `(WHEN (EQ PROCESSOR-TYPE-CODE #.CADR-TYPE-CODE)
  24>     ,@FORMS))
  25> (compiler:make-obsolete if-in-cadr "use SELECT-PROCESSOR")
  28*   `(WHEN (EQ PROCESSOR-TYPE-CODE #.LAMBDA-TYPE-CODE)
  29>     ,@FORMS))
  30> (compiler:make-obsolete if-in-lambda "use SELECT-PROCESSOR")
  33*   `(WHEN (EQ PROCESSOR-TYPE-CODE #.EXPLORER-TYPE-CODE)
  34>     ,@FORMS))
  35> (compiler:make-obsolete if-in-explorer "use SELECT-PROCESSOR")
  41*   (defprop :cadr #.cadr-type-code processor-type-symbol)
  42*   (defprop :lambda #.lambda-type-code processor-type-symbol)
  43*   (defprop :explorer #.explorer-type-code processor-type-symbol)
  44>   (defconst *all-known-processor-types* '(:cadr :lambda :explorer))
  45> )
 391*   (= (%DATA-TYPE X) #.DTP-CLOSURE))
 392> 
 393> (DEFSUBST ENTITYP (X)
 395*   (= (%DATA-TYPE X) #.DTP-ENTITY))
 396> 
 397> (DEFSUBST RANDOM-STATE-P (OBJECT)
 422*   (MEMQ (%DATA-TYPE OBJECT) '(#.DTP-U-ENTRY #.DTP-FEF-POINTER)))
 423> 
 424> (DEFSUBST LOCATIVEP (X)
 426*   (EQ (%DATA-TYPE X) #.DTP-LOCATIVE))
 427> 
 428> (DEFSUBST %POINTERP (X)
 432* 	     '(#.DTP-FIX #.DTP-SMALL-FLONUM #.DTP-U-ENTRY #.DTP-CHARACTER))))
 433> 
 434> (DEFSUBST %POINTER-TYPE-P (DATA-TYPE-CODE)
 437* 	     '(#.DTP-FIX #.DTP-SMALL-FLONUM #.DTP-U-ENTRY #.DTP-CHARACTER
 438* 	       #.DTP-TRAP #.DTP-NULL #.DTP-SELF-REF-POINTER
 439>    ;note that DTP-INSTANCE-HEADER IS a pointer!.
 440* 	       #.DTP-HEADER #.DTP-ARRAY-HEADER
 441>    ;note that DTP-HEADER-FORWARD IS a pointer!.
 442> 	       ))))
 458* 	'(#.DTP-SYMBOL #.DTP-FIX #.DTP-EXTENDED-NUMBER #.DTP-LOCATIVE #.DTP-LIST
 459* 	  #.DTP-U-ENTRY #.DTP-FEF-POINTER #.DTP-ARRAY-POINTER
 460* 	  #.DTP-STACK-GROUP #.DTP-CLOSURE #.DTP-SMALL-FLONUM #.DTP-SELECT-METHOD
 461* 	  #.DTP-INSTANCE #.DTP-ENTITY #.DTP-STACK-CLOSURE #.DTP-CHARACTER)))
 462> 
 463> (DEFSUBST %P-CONTENTS-SAFE-P (POINTER)
In DJ: L.SYS2; SETF.LISP#115
In DJ: L.SYS2; STRUCT.LISP#331
  71*        (princ '#.(and (status feature MacLisp-10)*
  72> 		 1(maknam (nconc (exploden ";Loading DEFSTRUCT ")*
  73> 			     1(exploden (caddr (truename infile))))))*
2518*        1#.(and (status feature MacLisp-10)*
2519> 	     1(caddr (truename infile)))*
2520>        1version)*
In DJ: L.SYS; TYPES.LISP#100
 117* 		'(#.dtp-locative #.dtp-stack-group #.dtp-select-method
 118* 		  #.dtp-closure #.dtp-entity #.dtp-u-entry))))))
 119> 
 120> ;;;; TYPE-OF
 123* 	  '((#.dtp-symbol . symbol)
 124* 	    (#.dtp-character . cl:character)
 125* 	    (#.dtp-character . zl:character)
 126* 	    (#.dtp-list . cons)
 127* 	    (#.dtp-fix . fixnum)
 128* 	    (#.dtp-locative . locative)
 129* 	    (#.dtp-fef-pointer . compiled-function)
 130* 	    (#.dtp-closure . closure)
 131* 	    (#.dtp-entity . entity)
 132* 	    (#.dtp-instance . instance)
 133* 	    (#.dtp-u-entry . microcode-function)
 134* 	    (#.dtp-select-method . select)
 135* 	    (#.dtp-small-flonum . short-float)
 136* 	    (#.dtp-stack-group . stack-group)))
 137> 
 138> (defun type-of (object &aux (dtp (%data-type object)))
 153* 	   (#.%header-type-flonum 'single-float)
 154* 	   (#.%header-type-bignum 'bignum)
 155* 	   (#.%header-type-rational 'ratio)
 156* 	   (#.%header-type-complex 'complex)
 157> 	   (t t)))
 158> 	((cdr (assq dtp type-of-alist)))
 164* 	  '((#.dtp-symbol . :symbol)
 165> 
 166* 	    (#.dtp-list . :cons)
 167* 	    (#.dtp-fix . :fixnum)
 168* 	    (#.dtp-locative . :locative)
 169* 	    (#.dtp-fef-pointer . :compiled-function)
 170* 	    (#.dtp-closure . :closure)
 171* 	    (#.dtp-entity . :entity)
 172* 	    (#.dtp-instance . :instance)
 173* 	    (#.dtp-u-entry . :microcode-function)
 174* 	    (#.dtp-select-method . :select)
 175* 	    (#.dtp-small-flonum . :small-flonum)
 176* 	    (#.dtp-stack-group . :stack-group)))
 177> 
 178> (defun typep (object &optional (type nil type-specified-p))
1276*   "Returns an array-type code, such as #.art-q"
1277>   (if (fixnump array-type1)
1278>       (if (zerop (ldb %%array-type-field array-type1))
1288*     (#.art-q
1289> 
1290*     (#.art-q-list
1291*      (not (eq array-type1 #.art-q)))
1292*     ((#.art-stack-group-head #.art-special-pdl #.art-reg-pdl)
1293*      (not (memq array-type1 '(#.art-q #.art-q-list))))
1294*     (#.art-string
1295*      (eq array-type1 #.art-string))
1296*     (#.art-fat-string
1297*      (memq array-type1 '(#.art-string #.art-fat-string)))
1298*     (#.art-32b
1299*      (memq array-type1 '(#.art-1b #.art-2b #.art-4b #.art-8b #.art-16b #.art-32b)))
1300*     (#.art-16b
1301*      (memq array-type1 '(#.art-1b #.art-2b #.art-4b #.art-8b #.art-16b)))
1302*     (#.art-half-fix
1303*      (memq array-type1 '(#.art-1b #.art-2b #.art-4b #.art-8b #.art-half-fix)))
1304*     (#.art-8b
1305*      (memq array-type1 '(#.art-1b #.art-2b #.art-4b #.art-8b)))
1306*     (#.art-4b
1307*      (memq array-type1 '(#.art-1b #.art-2b #.art-4b)))
1308*     (#.art-2b
1309*      (memq array-type1 '(#.art-1b #.art-2b)))
1310*     (#.art-1b
1311*      (memq array-type1 '(#.art-1b)))
1312*     (#.art-complex
1313*      (memq array-type1 '(#.art-complex #.art-complex-float #.art-complex-fps-float)))
1314*     (#.art-complex-float
1315*      (memq array-type1 '(#.art-complex-float #.art-complex-fps-float)))
1316*     (#.art-float
1317*      (memq array-type1 '(#.art-float #.art-fps-float)))
1318*     (#.art-fps-float
1319*      (memq array-type1 '(#.art-fps-float)))
1320>     (t nil)))
1321> 
1339* 	      (#.art-error type)
1340* 	      (#.art-q-list #.art-q-list)
1341* 	      (#.art-q #.art-q)
1342* 	      (#.art-stack-group-head #.art-stack-group-head)
1343* 	      (#.art-special-pdl #.art-special-pdl)
1344* 	      (#.art-reg-pdl #.art-reg-pdl)
1345* 	      (#.art-fat-string
1346* 	       (if (memq type '(#.art-string #.art-fat-string)) #.art-fat-string))
1347* 	      (#.art-string
1348* 	       (if (eq type #.art-string) #.art-string))
1349* 	      (#.art-complex-fps-float
1350> 	       (case type
1351* 		 (#.art-complex-fps-float #.art-complex-fps-float)
1352* 		 (#.art-complex-float #.art-complex-float)
1353* 		 (#.art-complex #.art-complex)))
1354* 	      (#.art-complex-float
1355> 	       (case type
1356* 		 ((#.art-complex-float #.art-float) #.art-complex-float)
1357* 		 (#.art-complex #.art-complex)))
1358* 	      (#.art-complex
1359> 	       (case type
1360* 		 ((#.art-complex #.art-float) #.art-complex)))
1361* 	      (#.art-fps-float
1362> 	       (case type
1363* 		 ((#.art-fps-float #.art-float) art-fps-float)))
1364* 	      (#.art-float
1365> 	       (case type
1366* 		 (#.art-float art-float)))
1367* 	      (#.art-half-fix
1368> 	       (case type
1369* 		 ((#.art-half-fix #.art-1b #.art-2b #.art-4b #.art-8b) #.art-half-fix)))
1370* 	      (#.art-32b #.art-32b)
1371* 	      (#.art-16b #.art-16b)
1372* 	      (#.art-8b #.art-8b)
1373* 	      (#.art-4b #.art-4b)
1374* 	      (#.art-2b #.art-2b)
1375* 	      (#.art-1b #.art-1b))
1376* 	    #.art-q))				;rampaging dotulism
1377>   (nth (ldb %%array-type-field array-type1) array-types))
1378> 
1967* 	    '(or (integer * (#.most-negative-fixnum)) (integer (#.most-positive-fixnum) *))))
1968> 
1969> (define-system-type fixnum
1975* 		'(integer #.most-negative-fixnum #.most-positive-fixnum)
1976> 	      `(integer ,(if (eq low '*) most-negative-fixnum low)
1977> 			,(if (eq high '*) most-positive-fixnum high))))
In DJ: L.DEBUGGER; ERRMAC.LISP#23
In DJ: L.IO1; CONVER.LISP#153
In DJ: L.IO1; SRCCOM.LISP#40
In DJ: L.IO1; METER.LISP#84
  44*   (SETQ *BUFFER-ARRAY* (MAKE-ARRAY (* PAGE-SIZE 4) :ELEMENT-TYPE '(MOD #.(^ 2 16.))))
  45>   (MULTIPLE-VALUE-SETQ (*DISK-PARTITION-START* *DISK-PARTITION-LENGTH*)
  46>     (SI:FIND-DISK-PARTITION (find-metr-partition-name)))
  56* 			     :ELEMENT-TYPE '(MOD #.(^ 2 16.))
  57> 			     :DISPLACED-TO *BUFFER-ARRAY*
  58> 			     :DISPLACED-INDEX-OFFSET (* 2 (- *BUFFER-ADDRESS*
In DJ: L.DEMO; HAKDEF.LISP#15
In DJ: L.DEMO; ABACUS.LISP#21
In DJ: L.DEMO; ALARM.LISP#51
In DJ: L.DEMO; BEEPS.LISP#8
In DJ: L.DEMO; CROCK.LISP#6
In DJ: L.DEMO; DC.LISP#4
In DJ: L.DEMO; DEUTSC.LISP#35
In DJ: L.DEMO; DLWHAK.LISP#40
In DJ: L.DEMO; DOCTOR.LISP#10
In DJ: L.DEMO; DOCSCR.LISP#6
In DJ: L.DEMO; GEB.LISP#28
In DJ: L.DEMO; HCEDIT.LISP#29
In DJ: L.DEMO; MUNCH.LISP#16
In DJ: L.DEMO; OHACKS.LISP#37
In DJ: L.DEMO; ORGAN.LISP#21
In DJ: L.DEMO; QIX.LISP#6
In DJ: L.DEMO; ROTATE.LISP#8
In DJ: L.DEMO; ROTCIR.LISP#6
In DJ: L.DEMO; WORM.LISP#11
In DJ: L.DEMO; WORM-TRAILS.LISP#16
In DJ: L.SYS2; MATRIX.LISP#30
In DJ: L.DEBUGGER; EH.LISP#389
2598* 				  '(#.DTP-EXTERNAL-VALUE-CELL-POINTER
2599* 				    #.DTP-ONE-Q-FORWARD
2600* 				    #.DTP-HEADER-FORWARD
2601* 				    #.DTP-BODY-FORWARD))
2602> 			    (p-prin1-careful-1 (%make-pointer dtp-locative
2603> 							      (%p-pointer locative))
In DJ: L.DEBUGGER; EHF.LISP#289
In DJ: L.DEBUGGER; TRAP.LISP#27
In DJ: L.DEBUGGER; CONDITION-FLAVORS.LISP#13
In DJ: L.DEBUGGER; EHC.LISP#258
In DJ: L.DEBUGGER; EHBPT.LISP#9
 198* 			      (:activation memq (#.(char-int #/end) #.(char-int #/newline)))
 199> 			      (:no-input-save t)))
 200> 	(tagbody
In DJ: L.DEBUGGER; EHW.LISP#120
In DJ: L.IO1; FNTDEF.LISP#20
In DJ: L.WINDOW; IMAGE-TOOLS.LISP#339
In DJ: L.IO1; FNTCNV.LISP#86
In DJ: L.WINDOW; FED.LISP#238
In DJ: L.ZWEI; DEFS.LISP#166
In DJ: L.ZWEI; MACROS.LISP#158
In DJ: L.ZWEI; SCREEN.LISP#481
In DJ: L.ZWEI; COMTAB.LISP#349
In DJ: L.ZWEI; DISPLA.LISP#173
In DJ: L.ZWEI; FOR.LISP#63
In DJ: L.ZWEI; INDENT.LISP#110
In DJ: L.ZWEI; INSERT.LISP#3
In DJ: L.ZWEI; METH.LISP#52
1402*       (#.(CHAR-CODE #/OVERSTRIKE) (SETQ X (MAX (1- X) 0)))
1403*       (#.(CHAR-CODE #/TAB) (SETQ X (* (1+ (FLOOR X 8)) 8)))
1404>       (OTHERWISE (INCF X)))))
1405> 
In DJ: L.ZWEI; PRIMIT.LISP#183
In DJ: L.ZWEI; NPRIM.LISP#37
In DJ: L.ZWEI; HISTORY.LISP#20
In DJ: L.ZWEI; FONT.LISP#96
In DJ: L.ZWEI; KBDMAC.LISP#49
In DJ: L.ZWEI; SEARCH.LISP#91
In DJ: L.ZWEI; COMA.LISP#112
In DJ: L.ZWEI; COMB.LISP#106
In DJ: L.ZWEI; COMC.LISP#216
In DJ: L.ZWEI; COMD.LISP#175
In DJ: L.ZWEI; COME.LISP#139
In DJ: L.ZWEI; COMF.LISP#109
In DJ: L.ZWEI; COMG.LISP#47
In DJ: L.ZWEI; COMH.LISP#20
In DJ: L.ZWEI; COMS.LISP#92
In DJ: L.ZWEI; DIRED.LISP#322
In DJ: L.ZWEI; BDIRED.LISP#47
In DJ: L.ZWEI; DOC.LISP#83
In DJ: L.ZWEI; FASUPD.LISP#31
In DJ: L.ZWEI; FILES.LISP#208
In DJ: L.ZWEI; HOST.LISP#4
In DJ: L.ZWEI; ISPELL.LISP#54
In DJ: L.ZWEI; LPARSE.LISP#33
 254*  Forward motion also moves over them after a string, for the sake of #|foo|#.
 255> NO-UP-P means it is forbidden to move up and then down again.
 256>  NIL is returned if that starts to happen."
 315* 				       ;; for the sake of #|foo|#.
 316> 				       (IF MOVE-OVER-SINGLEQUOTES-P
 317> 					   (DO ((BP (CHARMAP-BP-AFTER) (IBP BP)))
 530*  Forward motion also moves over them after a string, for the sake of #|foo|#.
 531> If an unmatched closeparen is found going forward
 532>  or an unmatched open going backward, NIL is returned."
In DJ: L.ZWEI; MODES.LISP#157
In DJ: L.ZWEI; MOUSE.LISP#102
In DJ: L.ZWEI; PATED.LISP#36
In DJ: L.ZWEI; PL1MOD.LISP#18
In DJ: L.ZWEI; POSS.LISP#97
In DJ: L.ZWEI; STREAM.LISP#171
In DJ: L.ZWEI; SECTIO.LISP#284
In DJ: L.ZWEI; ZMNEW.LISP#43
In DJ: L.ZWEI; ZMACS.LISP#558
In DJ: L.ZWEI; ZYMURG.LISP#43
In DJ: L.NETWORK; SUPDUP.LISP#289
In DJ: L.WINDOW; PEEK.LISP#190
In DJ: L.NETWORK.CHAOS; PEEKCH.LISP#34
In DJ: L.WINDOW; PEEKFS.LISP#10
In DJ: L.WINDOW; TVDEFS.LISP#294
In DJ: L.WINDOW; SCRMAN.LISP#169
In DJ: L.WINDOW; SHEET.LISP#579
In DJ: L.WINDOW; SHWARM.LISP#365
 981*       ((neq (%p-mask-field-offset #.%%array-type-field string 0) #.art-string)
 982>        (SETQ FONTX T))
 983>       ;; The current font is variable width.
1177* 			  #.ART-STRING))		;i.e. no font changes
1178> 	 (NULL (SETQ CWA (FONT-CHAR-WIDTH-TABLE FONT)))	;and fixed width
1179> 	 (GO FAST))
1351* 	(unless (eq (%p-mask-field-offset #.%%array-type-field string 0) #.art-string)
1352> 	  (go multiple-font))
1353> 
1454* 	(setq font-next (%logldb #.%%ch-font (setq c (zl:aref string i))))
1455>    multiple-font-main-loop-font-changed
1456> 	(setq font (aref font-map (setq font-index font-next)))
1463* 	(when ( (setq c (%logldb #.%%ch-char c)) #o200) (go multiple-font-special-character))
1464> 	
1465>    multiple-font-graphic-character
1503* 	(if (eq (setq font-next (%logldb #.%%ch-font (setq c (zl:aref string i)))) font-index)
1504> 	    (go multiple-font-main-loop-font-unchanged)
1505> 	  (go multiple-font-main-loop-font-changed))
1508* 	(when ( (setq c (%logldb #.%%ch-char c)) #o200)
1509> 	  (go multiple-font-special-character))
1510> 	(when (> (setq npos (+ (setq xpos npos) width))
1516* 	(if (eq (setq font-next (%logldb #.%%ch-font (setq c (zl:aref string i)))) font-index)
1517> 	    (go multiple-font-fixed-width-loop)
1518> 	  (go multiple-font-main-loop-font-changed))
1521* 	(when ( (setq c (%logldb #.%%ch-char c)) #o200)
1522> 	  (go multiple-font-special-character))
1523> 	(when (> (setq npos (+ (setq xpos npos)
1530* 	(if (eq (setq font-next (%logldb #.%%ch-font (setq c (zl:aref string i)))) font-index)
1531> 	    (go multiple-font-variable-width-loop)
1532> 	  (go multiple-font-main-loop-font-changed))
1535* 	(when ( (setq c (%logldb #.%%ch-char c)) #o200)
1536> 	  (go multiple-font-special-character))
1537> 	(when (> (setq npos (+ (setq xpos npos)
1544* 	(if (eq (setq font-next (%logldb #.%%ch-font (setq c (zl:aref string i)))) font-index)
1545> 	    (go multiple-font-variable-width-with-kerning-loop)
1546> 	  (go multiple-font-main-loop-font-changed))
In DJ: L.WINDOW; BASWIN.LISP#577
1826* 		 (string= (second note) "Process " :end1 #.(length "Process "))
1827> 		 (or (string= (second note) "wants to type out"
1828> 			      :start1 (max (- (length (second note))
1829* 					      #.(length "wants to type out"))
1830> 					   0))
1831> 		     (string= (second note) "wants typein"
1832* 			      :start1 (max (- (length (second note)) #.(length "wants typein"))
1833> 					   0))))
1834> 	    (SETQ PENDING-NOTIFICATIONS
In DJ: L.WINDOW; WHOLIN.LISP#102
 355* 			   (string= string "Process " :end1 #.(length "Process "))
 356> 			   (or (string= string "wants to type out"
 357> 					:start1 (max (- string-length
 358* 							#.(length "wants to type out"))
 359> 						     0))
 360> 			       (string= string "wants typein"
 361* 					:start1 (max (- string-length #.(length "wants typein"))
 362> 						     0))))
 363> 		      (send self :string-out string 0 (min string-length max-chars)))
 366* 			     (len (+ #.(length "Notification: ") (or n string-length))))
 367> 			(if (eql n (1- string-length)) (setq string-length n n nil))
 368> 			(cond ((and (null n) ( len max-chars))
 375* 						 (- max-chars #.(length "Notification:  "))))
 376> 			       (send self :string-out "  "))
 377> 			      #||(t
 379* 				     0 (min #.(length "Notification pending"))))||#)))))))
 380> 	 (setq who-line-item-state pending-notifications))
 381> 	(CURRENT-STREAM
In DJ: L.WINDOW; MOUSE.LISP#263
In DJ: L.WINDOW; BASSTR.LISP#402
In DJ: L.WINDOW; STREAM.LISP#152
 152* 	       (MEMQ (CADR CH) '(#/MOUSE-3-1 #.(CHAR-INT #/MOUSE-3-1))))
 153>       (MOUSE-CALL-SYSTEM-MENU))))
 154> 
 166* 	       (MEMQ (CADR CH) '(#/MOUSE-3-1 #.(CHAR-INT #/MOUSE-3-1))))
 167>       (MOUSE-CALL-SYSTEM-MENU))))
 168> 
In DJ: L.WINDOW; GRAPHICS.LISP#8
In DJ: L.WINDOW; MENU.LISP#112
In DJ: L.WINDOW; COMETH.LISP#27
In DJ: L.WINDOW; SYSMEN.LISP#193
In DJ: L.WINDOW; SCRED.LISP#117
In DJ: L.WINDOW; TYPWIN.LISP#123
In DJ: L.WINDOW; SCROLL.LISP#183
In DJ: L.WINDOW; TSCROL.LISP#75
In DJ: L.WINDOW; FRAME.LISP#172
In DJ: L.WINDOW; CHOICE.LISP#127
In DJ: L.WINDOW; CSRPOS.LISP#10
In DJ: L.WINDOW; INSPCT.LISP#181
In DJ: L.WINDOW; RH.LISP#176
In DJ: L.IO1; TIME.LISP#128
In DJ: L.IO1; TIMPAR.LISP#78
In DJ: L.IO1; RELLD.LISP#12
In DJ: L.IO1; RELDMP.LISP#13
In DJ: L.IO.FILE; ACCESS.LISP#33
In DJ: L.IO.FILE; PATHNM.LISP#570
In DJ: L.IO.FILE; PATHST.LISP#209
 639* 	    &AUX (WILD-STRINGS '(#.(STRING #/BREAK))))
 640>   (DECLARE (VALUES DEVICE DIRECTORY NAME TYPE VERSION
 641> 		   DEVICE-SPECIFIED-P DIRECTORY-SPECIFIED-P NAME-SPECIFIED-P TYPE-SPECIFIED-P
In DJ: L.COLD; NULL-FILE.LISP#1
In DJ: L.FILE; LMPARS.LISP#120
In DJ: L.IO.FILE; OPEN.LISP#202
In DJ: L.IO.FILE; BALDIR.LISP#117
In DJ: L.NETWORK.CHAOS; QFILE.LISP#374
In DJ: L.SYS; QCDEFS.LISP#176
In DJ: L.SYS2; DISASS.LISP#104
In DJ: L.SYS; QCFASD.LISP#257
In DJ: L.SYS; QCFILE.LISP#356
In DJ: L.SYS; QCP1.LISP#660
In DJ: L.SYS; QCP2.LISP#298
In DJ: L.SYS; QCOPT.LISP#169
  67* ;;; EVAL-WHEN so the #.'s below will win the first time.
  68> (eval-when (compile load eval)
  69> (defvar cxrs '(car cdr caar cadr cdar cddr caaar caadr
  79* 	  '#.(loop for sym in (cddr cxrs) collecting
  80> 		   (cons sym (intern (string-append #/C (substring sym 2))))))
  81> 
  83* 	  '#.(loop for sym in 3cxrs
  84> 		   as first = (substring (symbol-name sym)
  85> 					 0 (1- (array-active-length (symbol-name sym))))
In DJ: L.SYS; QCLUKE.LISP#34
In DJ: L.SYS; QCPEEP.LISP#39
In DJ: L.SYS; QCLAP.LISP#269
In DJ: L.COLD; DEFMIC.LISP#258
In DJ: L.COLD; DOCMIC.LISP#44
In DJ: L.COLD; SYSCONF.LISP#22
In DJ: L.SYS; CONFIG-DEFS.LISP#15
In DJ: L.SYS; SHARE-CHAOS.LISP#16
In DJ: L.SYS; IOMSG.LISP#38
In DJ: L.SYS; SHARED-DEVICE.LISP#47
In DJ: L.SYS; CONFIG.LISP#46
In DJ: L.NETWORK; SIMPLE-ETHER.LISP#75
In DJ: L.NETWORK; ADDR-RES.LISP#43
In DJ: L.NETWORK.CHAOS; CHSNCP.LISP#365
2074* 	  '((#.ethernet:chaos-ethernet-type . receive-chaos-ethernet-type)
2075* 	    (#.ethernet:address-resolution-type . receive-addr-ethernet-type)
2076> 	    ))
2077> 
2757* 			  '(#.rfc-op #.opn-op #.cls-op #.ans-op))
2758> 		    (dotimes (c (min 100. (ceiling (pkt-nbytes int-pkt) 2)))
2759> 		      (let ((b (aref int-pkt (+ c first-data-word-in-pkt))))
In DJ: L.NETWORK.CHAOS; CHUSE.LISP#27
In DJ: L.NETWORK.CHAOS; CHSAUX.LISP#392
In DJ: L.NETWORK.CHAOS; EFTP.LISP#41
  13* 		(:INITIAL-OFFSET #.FIRST-DATA-WORD-IN-PKT) (:SIZE-SYMBOL PUP-FIRST-DATA-WORD))
  14>   (PUP-OVERALL-LENGTH)
  15>   ((PUP-TYPE #o0010) (PUP-TRANSPORT #o1010))
In DJ: L.IO; FORMAT.LISP#265
In DJ: L.IO1; FQUERY.LISP#53
In DJ: L.IO1; OUTPUT.LISP#47
 417* 		   (and (memq char1 '(#.(char-code #/)
 418* 				      #.(char-code #/)
 419* 				      #.(char-code #/)
 420* 				      #.(char-code #/)
 421* 				      #.(char-code #/)
 422* 				      #.(char-code #/)))
 423> 			(write-char #/))
 424> 		   (send *standard-output* :tyo char1)))
In DJ: L.SYS; STORAGE-DEFS.LISP#12
  27*   (%logldb #.%%region-space-type (%area-region-bits region)))
  28> 
  29> (defsubst %area-flip-enable (region)
  30*   (%logldb #.%%region-flip-enable (%area-region-bits region)))
  31> 
  32> (defsubst %area-scavenge-enable (region)
  33*   (%logldb #.%%region-scavenge-enable (%area-region-bits region)))
  34> 
  35> (defsubst %area-scavenge-carefully (region)
  36*   (%logldb #.%%region-scavenge-carefully (%area-region-bits region)))
  37> 
  38> (defsubst %area-volatility (region)
  39*   (%logldb #.%%region-volatility (%area-region-bits region)))
  40> 
  41> (defsubst %area-swap-recommendations (region)
  42*   (%logldb #.%%region-swapin-quantum (%area-region-bits region)))
  43> 
  44> (defsubst %area-map-status (region)
  45*   (%logldb #.%%region-map-status-code (%area-region-bits region)))
  46> 
  47> 			
  57*   (%logldb #.%%region-space-type (%region-bits region)))
  58> 
  59> (defsubst %region-representation-type (region)
  60*   (%logldb #.%%region-representation-type (%region-bits region)))
  61> 
  62> (defsubst %region-flip-enable (region)
  63*   (%logldb #.%%region-flip-enable (%region-bits region)))
  64> 
  65> (defsubst %region-scavenge-enable (region)
  66*   (%logldb #.%%region-scavenge-enable (%region-bits region)))
  67> 
  68> (defsubst %region-scavenge-carefully (region)
  69*   (%logldb #.%%region-scavenge-carefully (%region-bits region)))
  70> 
  71> (defsubst %region-volatility (region)
  72*   (%logldb #.%%region-volatility (%region-bits region)))
  73> 
  74> (defsubst %region-swap-recommendations (region)
  75*   (%logldb #.%%region-swapin-quantum (%region-bits region)))
  76> 
  77> (defsetf %region-free-pointer set-%region-free-pointer)
In DJ: L.SYS2; GC.LISP#311
In DJ: L.SYS2; PRODEF.LISP#60
 158*     `(DPB ,HIGH #.(byte (integer-length most-positive-fixnum)
 159> 			(integer-length most-positive-fixnum))
 160> 	  ,LOW)))
In DJ: L.IO; RDDEFS.LISP#63
In DJ: L.SYS2; SGDEFS.LISP#58
In DJ: L.SYS2; NUMDEF.LISP#13
In DJ: L.SYS2; METH.LISP#67
In DJ: L.SYS2; CLASS.LISP#104
In DJ: L.SYS2; ADVISE.LISP#42
In DJ: L.SYS2; BAND.LISP#48
In DJ: L.SYS2; CHARACTER.LISP#25
In DJ: L.SYS; CLPACK.LISP#211
In DJ: L.WINDOW; COLD.LISP#178
In DJ: L.SYS2; DEFSEL.LISP#74
In DJ: L.IO; NEW-DISK.LISP#53
In DJ: L.IO; DISK.LISP#405
In DJ: L.IO; UDISK.LISP#19
In DJ: L.SYS; DESCRIBE.LISP#17
In DJ: L.IO; DLEDIT.LISP#96
In DJ: L.IO; DRIBBL.LISP#40
In DJ: L.SYS2; ENCAPS.LISP#34
In DJ: L.SYS; EVAL.LISP#168
In DJ: L.SYS2; FLAVOR.LISP#311
2533* 	     '(#.%HEADER-TYPE-FEF
2534> 		;no, the ultra fast option cannot be used with methods 
2535> 		; or DECLARE-FLAVOR-INSTANCE-VARIABLES, etc.
2536* 	       ;#.%HEADER-TYPE-FAST-FEF-FIXED-ARGS-NO-LOCALS
2537* 	       ;#.%HEADER-TYPE-FAST-FEF-VAR-ARGS-NO-LOCALS
2538* 	       ;#.%HEADER-TYPE-FAST-FEF-FIXED-ARGS-WITH-LOCALS
2539* 	       ;#.%HEADER-TYPE-FAST-FEF-VAR-ARGS-WITH-LOCALS
2540> 	       ))
2541>        (NOT (ZEROP (%P-LDB %%FEFH-GET-SELF-MAPPING-TABLE FEF)))
In DJ: L.SYS; GENRIC.LISP#46
In DJ: L.COLD; GLOBAL.LISP#654
In DJ: L.IO; GRIND.LISP#149
In DJ: L.IO1; HARDCOPY.LISP#4
In DJ: L.SYS2; HASH.LISP#114
In DJ: L.SYS2; HASHFL.LISP#69
 157* 	     (%make-pointer-offset #.dtp-locative p blen))
 158> 	  (blen (hash-array-block-length harry))
 159> 	  (alen (array-length harry)))
 166* 	   (setq p (%make-pointer-offset #.dtp-locative p (- alen))))
 167*        (cond ((eq (%p-data-type p) #.dtp-null)		;deleted or empty
 168> 	      ,(if rehash-if-lose-form
 169> 		   ;; If we find a slot that has never been used, this key is not present.
 182* 				      (%make-pointer-offset #.dtp-list p 1))))
 183> 		    '((return (values (%p-contents-offset p 1)
 184> 				      t
 185* 				      (%make-pointer #.dtp-list p))))))))))
 186> 
 187> (defmacro define-put-hash-method (flavor
 206* 		 (%make-pointer-offset #.dtp-locative p blen))
 207> 	      (blen (hash-array-block-length harry))
 208> 	      (alen (array-length harry))
 217* 	       (setq p (%make-pointer-offset #.dtp-locative p (- alen))))
 218* 	   (cond ((eq (%p-data-type p) #.dtp-null)	;deleted or empty
 219> 		  (or emptyp (setq emptyp p))
 220> 		  (when (zerop (%p-pointer p))
 259* 				       `(%make-pointer-offset #.dtp-list p 1)
 260* 				       `(%make-pointer #.dtp-list p)))))))))))
 261> 
 262> (defmacro define-rem-hash-method (flavor
 276* 	       (%make-pointer-offset #.dtp-locative p blen))
 277> 	    (blen (hash-array-block-length harry))
 278> 	    (alen (array-length harry)))
 285* 	     (setq p (%make-pointer-offset #.dtp-locative p (- alen))))
 286* 	 (cond ((eq (%p-data-type p) #.dtp-null)	;deleted or empty
 287> 		(cond ((not (zerop (%p-pointer p))))	;empty
 288> 		      ,@(if rehash-if-lose-form
 297* 		  (%p-store-data-type p #.dtp-null)
 298> 		  (%p-store-pointer p 1)		;Remove entry
 299> 		  (decf (hash-array-fullness harry))
 472*       (unless (eq (%p-data-type (locf (aref harry i))) #.dtp-null)
 473> 	(%open-call-block function 0 0)
 474* 	(dolist (i (%make-pointer-offset #.dtp-list (locf (aref harry i)) block-offset))
 475> 	  (%push i))
 476> 	(dolist (i extra-args)
 488*     (unless (eq (%p-data-type (locf (aref harry i))) #.dtp-null)
 489>       (%open-call-block function 0 0)
 490*       (dolist (i (%make-pointer-offset #.dtp-list (locf (aref harry i)) block-offset))
 491> 	(%push i))
 492>       (dolist (i extra-args)
 519*       (unless (eq (%p-data-type (locf (aref harry i))) #.dtp-null)
 520> 	(let ((value (apply function
 521* 			    (%make-pointer-offset #.dtp-list (locf (aref harry i))
 522> 						  block-offset))))
 523> 	  (if nconc
 542*     (unless (eq (%p-data-type (locf (aref harry i))) #.dtp-null)
 543>       (let ((value (apply function
 544* 			  (%make-pointer-offset #.dtp-list (locf (aref harry i))
 545> 						block-offset))))
 546> 	(if nconc
 584* 	  (cond (( #.most-negative-short-float key #.most-positive-short-float)
 585> 		 (%pointer (coerce key 'short-float)))
 586* 		(( #.most-negative-single-float key #.most-positive-single-float)
 587> 		 (%single-float-mantissa (coerce key 'single-float)))
 588> 		(t
 593* 	  (if (< #.most-negative-short-float key #.most-positive-single-float)
 594> 	      (%pointer (coerce key 'short-float))
 595> 	    (%single-float-mantissa key)))
 598*     #.most-negative-fixnum))
 599> 
 600> ;;;; make-hash-table
In DJ: L.NETWORK; PACKAGE.LISP#11
In DJ: L.NETWORK; HOST.LISP#153
In DJ: L.IO1; INC.LISP#12
In DJ: L.IO1; INFIX.LISP#11
In DJ: L.IO; INPUT-READERS.LISP#9
  89* 		((MEMQ CH '(#.(CHAR-INT #\SPACE)
  90* 			    #.(CHAR-INT #\TAB)
  91* 			    #.(CHAR-INT #\NEWLINE))))
  92> 		(T
  93> 		 (SEND STREAM :UNTYI CH)
 112*       (read-delimited-string '(#.(char-int #\Newline) #.(char-int #\End))
 113> 			     stream
 114> 			     eof-error-p
 142* 	(read-delimited-string '(#.(char-int #\Newline) #.(char-int #\End)) stream
 143> 			       eof-error-p (car options))
 144> 	(unless eof
 295* 			       (:activation memq (#.(char-int #\End) (char-int #\Newline)))))
 296> 			function option *query-io*))
 297> 		 (t
 348* 				(:activation eq #.(char-int #\End))))
 349> 	  (let ((ch (send stream :any-tyi)))
 350> 	    (cond ((and (consp option) (get-location-or-nil option :default)
 377* 		(:activation eq #.(char-int #\End)))
 378> 	 prompt-and-read-rubout-options)
 379> 
 381* 		      (:activation eq #.(char-int #\End)))
 382> 	 prompt-and-read-rubout-options)
 383> 
 386* 			     (:activation eq #.(char-int #\End)))
 387> 	 prompt-and-read-rubout-options)
 388> (defun expression-or-end-prompt-and-read (ignore stream)
 405* 	(cond ((memq char '(#.(char-int #\quote) #.(char-int #\c-q)))
 406> 	       (setq char (send stream :tyi)))
 407> 	      ((eq char (char-int #\Clear-input))
 548* 			    (:activation memq (#.(char-int #\End) #.(char-int #\Return)))))
 549>       (nth (cl:read *query-io*)
 550> 	   choices))))
 564* 			    (:activation memq (#.(char-int #\End) #.(char-int #\Return)))))
 565>       (cdr (nth (cl:read *query-io*)
 566> 		choices)))))
In DJ: L.COLD; LISP.LISP#10
In DJ: L.SYS2; LOGIN.LISP#90
In DJ: L.SYS2; LOOP.LISP#804
1178* 				 #.(and (loop-featurep Loop-Small-Floatp)
1179> 					(small-float 0)))
1180> 			      (t 0.0))
1403* ; is of the form  (#.gofoo var tail).  This construct must appear in
1404> ; the binding environment those variables are bound in, currently.
1405> ; Note that this hack only currently works for local variables, so loop
1707* 	  #+Lispm '#.(and (loop-featurep :Lispm)
1708> 			  (mapcar 'ascii '(#/ #/ #/)))
1709> 	  #+For-NIL '(1+& 1-& +& -& plusp& minusp& zerop& *& //& \&
2191* 		      '(1 1.0 #.(and (loop-featurep Loop-Small-Floatp)
2192> 				     (small-float 1)))
2193> 		    #-Loop-Small-Floatp '(1 1.0))
In DJ: L.SYS; LTOP.LISP#566
In DJ: L.SYS2; MACARRAY.LISP#7
In DJ: L.SYS2; MAKSYS.LISP#199
 767* 			       (FQUERY `(:timeout #.(* 5 60. 60.)
 768> 					 :default-value t
 769> 					 :CHOICES
In DJ: L.SYS2; NUMER.LISP#79
 657* (%p-dpb #o77777 #.(byte 11. 8) most-positive-single-float)
 658> (%p-store-contents-offset -1 most-positive-single-float 1)
 659> 
 663* (%p-dpb #o77777 #.(byte 12. 7) most-negative-single-float)
 664> 
 665> (defconstant least-positive-single-float (- 1.0 1.0)
 668* (%p-dpb 1 #.(byte 11. 8) least-positive-single-float)
 669* (%p-dpb 1 #.(byte 1 6) least-positive-single-float)
 670> 
 671> 
 675* (%p-dpb 1 #.(byte 11. 8) least-negative-single-float)
 676* (%p-dpb 1 #.(byte 1 7) least-negative-single-float)
 677* (%p-dpb #o777 #.(byte 5 0) least-negative-single-float)
 678> (%p-store-contents-offset -1 least-negative-single-float 1)
 679> 
In DJ: L.SYS2; PATCH.LISP#176
In DJ: L.SYS2; PLANE.LISP#35
In DJ: L.IO; PRINT.LISP#216
 372* 		   ;; A number - that is the label.  Print only #label#.
 373> 		   (CATCH 'LABEL-PRINTED
 374> 		     (SEND *PRINT-HASH-TABLE* :MODIFY-HASH EXP
In DJ: L.SYS2; PROCES.LISP#191
In DJ: L.IO; QIO.LISP#227
In DJ: L.SYS; QFASL.LISP#486
In DJ: L.SYS; QFCTNS.LISP#824
 435* 		     (NOT (MEMQ DTP '(#.DTP-LOCATIVE
 436* 				      #.DTP-SYMBOL
 437* 				      #.DTP-EXTERNAL-VALUE-CELL-POINTER
 438* 				      #.DTP-BODY-FORWARD))))
 439> 	    (SETF (%P-CONTENTS-OFFSET LEADER I)
 440> 		  (IF (EQ DEPTH 0)
1438* 		  ((#.DTP-FEF-POINTER #.DTP-U-ENTRY)
1439> 		   (IF (BIT-TEST (LOGIOR %ARG-DESC-QUOTED-REST %ARG-DESC-FEF-QUOTE-HAIR)
1440> 				 (%ARGS-INFO X))
1443* 		  ((#.DTP-LIST)
1444> 		   (COND ((EQ (CAR X) 'LAMBDA)
1445> 			  (IF (MEMQ '&QUOTE (CADR X)) (FERROR NIL "Obsolete special form: ~S" X))
1456* 		  ((#.DTP-SELECT-METHOD #.DTP-CLOSURE #.DTP-STACK-CLOSURE) T)
1457* 		  ((#.DTP-SYMBOL)
1458> 		   (COND ((NOT (FBOUNDP X))
1459> 			  (AND ALLOW-SPECIAL-FORMS
2620* 				((#.DTP-EXTERNAL-VALUE-CELL-POINTER)
2621> 				 (MULTIPLE-VALUE-BIND (SYM CELL-FUNCTION)
2622> 				     (DECODE-EVCP (%P-CONTENTS-AS-LOCATIVE ADL))
2627* 				((#.DTP-SELF-REF-POINTER)
2628> 				 (FLAVOR-DECODE-SELF-REF-POINTER
2629> 				   (FEF-FLAVOR-NAME FUNCTION)
In DJ: L.SYS; QMISC.LISP#722
  25*     (LOGIOR (LDB #.(1- %%Q-POINTER) N) (ROT (LDB #.(BYTE 1 (1- %%Q-POINTER)) N) -1))))
  26> 
  27> (DEFUN CALL (FN &REST ALTERNATES
1856* 				    . #.FORMAT:Y-OR-N-P-CHOICES)
1857> 				   :HELP-FUNCTION
1858> 				   (LAMBDA (STREAM &REST IGNORE)
In DJ: L.SYS; QNEW.LISP#20
In DJ: L.SYS; QRAND.LISP#487
In DJ: L.SYS2; QTRACE.LISP#160
In DJ: L.SYS2; RAT.LISP#53
 132* 	  (short-float #.(coerce pi 'short-float))
 133> 	  (t pi))
 134>       (- number number))))
In DJ: L.IO; READ.LISP#454
 108* (SETQ RDTBL-ARRAY-SIZE #.RDTBL-ARRAY-SIZE)	;Have a reasonable value in the cold load
 109> 
 110> (DEFVAR-RESETTABLE READ-AREA NIL NIL
1608*       ((fixnum 0 #.array-rank-limit)
1609>        (let (dimensions (sequences (internal-read stream t nil t)))
1610> 	 (do ((dim 0 (1+ dim))
1878* (defun xr-#.-macro (stream ignore &optional arg)
1879>   (cond (*read-suppress*)
1880* 	(arg (read-error "An argument, ~D, was given to /"#./"" arg)))
1881>   (let ((frob (internal-read stream t nil t)))
1882>     (values (if *read-suppress*
In DJ: L.SYS; REP.LISP#19
In DJ: L.SYS2; RESOUR.LISP#46
In DJ: L.SYS2; SELEV.LISP#31
In DJ: L.IO1; SERIAL.LISP#32
In DJ: L.IO1; SDU-SERIAL.LISP#32
In DJ: L.SYS; SGFCTN.LISP#70
In DJ: L.SYS; SORT.LISP#67
In DJ: L.SYS2; STEP.LISP#74
In DJ: L.SYS; STORAGE.LISP#82
 394* 	  when (memq (%logldb %%type (%region-bits region)) '#.(list %region-space-new
 395> 								     %region-space-copy
 396> 								     %region-space-static))
In DJ: L.IO; STREAM.LISP#114
In DJ: L.SYS2; STRING.LISP#159
In DJ: L.COLD; SYSTEM.LISP#108
In DJ: L.SYS2; UNFASL.LISP#24
  36*   (cond ((eq pkg #.(intern "" "")) ;107 reader bug
  37> 	 (write-char #/: stream))
  38> 	(pkg
In DJ: L.IO; UNIBUS.LISP#27
In DJ: L.SYS2; CLMAC.LISP#7
In DJ: L.SYS2; ANALYZE.LISP#46
In DJ: L.NETWORK; TABLE.LISP#6
In DJ: L.NETWORK; TRANSPARENT.LISP#11
In DJ: L.COLD; EXPORT.LISP#35
In DJ: L.FONTS; EQUIVALENCE.LISP#1