/[cmucl]/src/code/lispinit.lisp
ViewVC logotype

Diff of /src/code/lispinit.lisp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.67.4.2 by gerd, Mon Mar 24 10:54:40 2003 UTC revision 1.82 by rtoy, Tue Apr 20 17:57:44 2010 UTC
# Line 15  Line 15 
15  ;;; Written by Skef Wholey and Rob MacLachlan.  ;;; Written by Skef Wholey and Rob MacLachlan.
16  ;;;  ;;;
17  (in-package :lisp)  (in-package :lisp)
18    (intl:textdomain "cmucl")
19    
20  (export '(most-positive-fixnum most-negative-fixnum sleep  (export '(most-positive-fixnum most-negative-fixnum sleep
21            ++ +++ ** *** // ///))            ++ +++ ** *** // ///))
22    
23    (defvar *features* '(:common :common-lisp :ansi-cl :ieee-floating-point :cmu)
24      "Holds a list of symbols that describe features provided by the
25       implementation.")
26    
27    
28  (in-package :system)  (in-package :system)
29  (export '(compiler-version scrub-control-stack))  (export '(compiler-version scrub-control-stack *runtime-features*))
30    
31    (defvar *runtime-features* nil
32      "Features affecting the runtime")
33    
34  (in-package :extensions)  (in-package :extensions)
35  (export '(quit *prompt*))  (export '(quit *prompt*))
36    
37  (in-package :lisp)  (in-package :lisp)
38    
39    #+stack-checking
40    (sys:register-lisp-runtime-feature :stack-checking)
41    
42    #+heap-overflow-check
43    (sys:register-lisp-runtime-feature :heap-overflow-check)
44    
45    #+double-double
46    (sys:register-lisp-feature :double-double)
47    
48  ;;; Make the error system enable interrupts.  ;;; Make the error system enable interrupts.
49    
50  (defconstant most-positive-fixnum #.vm:target-most-positive-fixnum  (defconstant most-positive-fixnum #.vm:target-most-positive-fixnum
# Line 42  Line 60 
60    
61    
62  ;;; Must be initialized in %INITIAL-FUNCTION before the DEFVAR runs...  ;;; Must be initialized in %INITIAL-FUNCTION before the DEFVAR runs...
63  (declaim (special *gc-inhibit* *already-maybe-gcing*  (declaim
64                    *need-to-collect-garbage* *gc-verbose*    #-gengc
65                    *before-gc-hooks* *after-gc-hooks*    (special *gc-inhibit* *already-maybe-gcing*
66                    #+x86 *pseudo-atomic-atomic*             *need-to-collect-garbage* *gc-verbose*
67                    #+x86 *pseudo-atomic-interrupted*             *before-gc-hooks* *after-gc-hooks*
68                    unix::*interrupts-enabled*             #+x86 *pseudo-atomic-atomic*
69                    unix::*interrupt-pending*             #+x86 *pseudo-atomic-interrupted*
70                    *type-system-initialized*))             unix::*interrupts-enabled*
71               unix::*interrupt-pending*
72               *type-system-initialized*
73               unix::*filename-encoding*)
74      #+gengc
75      (special *gc-verbose* *before-gc-hooks* *after-gc-hooks*
76               *type-system-initialized* unix::*filename-encoding*))
77    
78    
79  ;;;; Random magic specials.  ;;;; Random magic specials.
# Line 57  Line 81 
81    
82  ;;; These are filled in by Genesis.  ;;; These are filled in by Genesis.
83    
84    #-gengc
85    (progn
86    
87  (defvar *current-catch-block*)  (defvar *current-catch-block*)
88  (defvar *current-unwind-protect-block*)  (defvar *current-unwind-protect-block*)
89  (defvar *free-interrupt-context-index*)  (defvar *free-interrupt-context-index*)
90    
91    ); #-gengc progn
92    
93    
94  ;;;; Random stuff that needs to be in the cold load which would otherwise be  ;;;; Random stuff that needs to be in the cold load which would otherwise be
95  ;;;; byte-compiled.  ;;;; byte-compiled.
# Line 127  Line 156 
156      (let ((obos *break-on-signals*)      (let ((obos *break-on-signals*)
157            (*break-on-signals* nil))            (*break-on-signals* nil))
158        (when (typep condition obos)        (when (typep condition obos)
159          (break "~A~%Break entered because of *break-on-signals* (now NIL.)"          (break (intl:gettext "~A~%Break entered because of *break-on-signals* (now NIL.)")
160                 condition)))                 condition)))
161      (loop      (loop
162        (unless *handler-clusters* (return))        (unless *handler-clusters* (return))
# Line 144  Line 173 
173  (defun coerce-to-condition (datum arguments default-type function-name)  (defun coerce-to-condition (datum arguments default-type function-name)
174    (cond ((typep datum 'condition)    (cond ((typep datum 'condition)
175           (if arguments           (if arguments
176               (cerror "Ignore the additional arguments."               (cerror (intl:gettext "Ignore the additional arguments.")
177                       'simple-type-error                       'simple-type-error
178                       :datum arguments                       :datum arguments
179                       :expected-type 'null                       :expected-type 'null
180                       :format-control "You may not supply additional arguments ~                       :format-control (intl:gettext "You may not supply additional arguments ~
181                                       when giving ~S to ~S."                                       when giving ~S to ~S.")
182                       :format-arguments (list datum function-name)))                       :format-arguments (list datum function-name)))
183           datum)           datum)
184          ((symbolp datum) ;Roughly, (subtypep datum 'condition).          ((symbolp datum) ;Roughly, (subtypep datum 'condition).
# Line 162  Line 191 
191           (error 'simple-type-error           (error 'simple-type-error
192                  :datum datum                  :datum datum
193                  :expected-type '(or symbol string)                  :expected-type '(or symbol string)
194                  :format-control "Bad argument to ~S: ~S"                  :format-control (intl:gettext "Bad argument to ~S: ~S")
195                  :format-arguments (list function-name datum)))))                  :format-arguments (list function-name datum)))))
196    
197  (defun error (datum &rest arguments)  (defun error (datum &rest arguments)
# Line 215  Line 244 
244    "Prints a message and invokes the debugger without allowing any possibility    "Prints a message and invokes the debugger without allowing any possibility
245     of condition handling occurring."     of condition handling occurring."
246    (kernel:infinite-error-protect    (kernel:infinite-error-protect
247      (with-simple-restart (continue "Return from BREAK.")      (with-simple-restart (continue (intl:gettext "Return from BREAK."))
248        (let ((debug:*stack-top-hint*        (let ((debug:*stack-top-hint*
249               (or debug:*stack-top-hint*               (or debug:*stack-top-hint*
250                   (nth-value 1 (kernel:find-caller-name)))))                   (nth-value 1 (kernel:find-caller-name)))))
# Line 230  Line 259 
259    (kernel:infinite-error-protect    (kernel:infinite-error-protect
260      (let ((condition (coerce-to-condition datum arguments      (let ((condition (coerce-to-condition datum arguments
261                                            'simple-warning 'warn)))                                            'simple-warning 'warn)))
262        (check-type condition warning "a warning condition")        (check-type condition warning (intl:gettext "a warning condition"))
263        (restart-case (signal condition)        (restart-case (signal condition)
264          (muffle-warning ()          (muffle-warning ()
265            :report "Skip warning."            :report (lambda (stream)
266                        (write-string (intl:gettext "Skip warning.") stream))
267            (return-from warn nil)))            (return-from warn nil)))
268        (format *error-output* "~&~@<Warning:  ~3i~:_~A~:>~%" condition)))        (format *error-output* (intl:gettext "~&~@<Warning:  ~3i~:_~A~:>~%") condition)))
269    nil)    nil)
270    
271  ;;; Utility functions  ;;; Utility functions
# Line 281  Line 311 
311      `(progn      `(progn
312         (%primitive print ,(symbol-name name))         (%primitive print ,(symbol-name name))
313         (,name))))         (,name))))
   
314  #+nil  #+nil
315  (defun hexstr (thing)  (defun hexstr(thing)
316    (let ((addr (kernel:get-lisp-obj-address thing))    (let ((addr (kernel:get-lisp-obj-address thing))
317          (str (make-string 10)))          (str (make-string 10)))
318      (setf (char str 0) #\0      (setf (char str 0) #\0
# Line 300  Line 329 
329  (defun %initial-function ()  (defun %initial-function ()
330    "Gives the world a shove and hopes it spins."    "Gives the world a shove and hopes it spins."
331    (%primitive print "In initial-function, and running.")    (%primitive print "In initial-function, and running.")
332    (setf *already-maybe-gcing* t)    #-gengc (setf *already-maybe-gcing* t)
333    (setf *gc-inhibit* t)    #-gengc (setf *gc-inhibit* t)
334    (setf *need-to-collect-garbage* nil)    #-gengc (setf *need-to-collect-garbage* nil)
335    (setf *gc-verbose* t)    (setf *gc-verbose* #-gengc t #+gengc nil)
336    (setf *before-gc-hooks* nil)    (setf *before-gc-hooks* nil)
337    (setf *after-gc-hooks* nil)    (setf *after-gc-hooks* nil)
338    (setf unix::*interrupts-enabled* t)    #-gengc (setf unix::*interrupts-enabled* t)
339    (setf unix::*interrupt-pending* nil)    #-gengc (setf unix::*interrupt-pending* nil)
340    (setf *type-system-initialized* nil)    (setf *type-system-initialized* nil)
341    (setf *break-on-signals* nil)    (setf *break-on-signals* nil)
342    ;;    (setf unix::*filename-encoding* nil)
343      #+gengc (setf conditions::*handler-clusters* nil)
344      (setq intl::*default-domain* "cmucl")
345      (setq intl::*locale* "C")
346    
347    ;; Many top-level forms call INFO, (SETF INFO).    ;; Many top-level forms call INFO, (SETF INFO).
348    (print-and-call c::globaldb-init)    (print-and-call c::globaldb-init)
349    ;;  
350    ;; Set up the fdefn database.    ;; Set up the fdefn database.
351    (print-and-call fdefn-init)    (print-and-call fdefn-init)
352    ;;  
353    ;; Some of the random top-level forms call Make-Array, which calls Subtypep    ;; Some of the random top-level forms call Make-Array, which calls Subtypep
354    (print-and-call typedef-init)    (print-and-call typedef-init)
355    (print-and-call class-init)    (print-and-call class-init)
356    
357    (print-and-call type-init)    (print-and-call type-init)
358    
359    (dolist (fun (nreverse *lisp-initialization-functions*))    (let ((funs (nreverse *lisp-initialization-functions*)))
360      (typecase fun      (%primitive print "Calling top-level forms.")
361        (function (funcall fun))      #+nil (%primitive print (length funs))
362        (dolist (fun funs)
363        (cons        #+nil (%primitive print fun)
364         (case (car fun)        (typecase fun
365           (:load-time-value          (function
366            (setf (svref *load-time-values* (third fun))           (funcall fun))
367                  (funcall (second fun))))          (cons
368             (case (car fun)
369           (:load-time-value-fixup             (:load-time-value
370            (setf (sap-ref-32 (second fun) 0)              (setf (svref *load-time-values* (third fun))
371                  (get-lisp-obj-address (svref *load-time-values* (third fun)))))                    (funcall (second fun))))
372               (:load-time-value-fixup
373           #+(and x86 gencgc)              #-gengc
374           (:load-time-code-fixup              (setf (#+amd64 sap-ref-64
375            (vm::do-load-time-code-fixup                     #-amd64 sap-ref-32 (second fun) 0)
376                (second fun) (third fun) (fourth fun) (fifth fun)))                    (get-lisp-obj-address
377                       (svref *load-time-values* (third fun))))
378           (:type-system-initialized              #+gengc
379            (setf *type-system-initialized* t))              (do-load-time-value-fixup (second fun) (third fun) (fourth fun)))
380               #+(and (or x86 amd64) gencgc)
381           (:reader-init             (:load-time-code-fixup
382            (print-and-call reader-init)              (vm::do-load-time-code-fixup (second fun) (third fun) (fourth fun)
383            (setf *readtable* (copy-readtable std-lisp-readtable)))                                           (fifth fun)))
384               (t
385           (:signal-init              (%primitive print
386            (print-and-call kernel::signal-init)                          "Bogus fixup in *lisp-initialization-functions*")
387            (setf (alien:extern-alien "internal_errors_enabled" boolean) t))              (%halt))))
388            (t
389           (:set-floating-point-modes           (%primitive print
390            (set-floating-point-modes                       "Bogus function in *lisp-initialization-functions*")
391             :traps '(:overflow #-x86 :underflow :invalid :divide-by-zero)))           (%halt)))))
392      (makunbound '*lisp-initialization-functions*) ; So it gets GC'ed.
          (:lisp-implementation-version  
           (setq *lisp-implementation-version* (cdr fun)))  
   
          (:file  
           (%primitive print (cdr fun)))  
   
          (:load  
           (load (cdr fun)))  
   
          (:cold-core  
           (pushnew :cold-core *features*))  
   
          (t  
           (let ((fun (car fun)))  
             (unless (and (symbolp fun) (fboundp fun))  
               (%primitive print "Bogus init function.")  
               (typecase fun  
                 (symbol (%primitive print (symbol-name fun)))  
                 (string (%primitive print fun)))  
               (%halt))  
             (%primitive print (symbol-name fun))  
             (funcall fun)))))  
   
       (t  
        (%primitive print "Bogus element in *LISP-INITIALIZATION-FUNCTIONS*")  
        (%halt))))  
   
   (makunbound '*lisp-initialization-functions*)  
393    (makunbound '*load-time-values*)    (makunbound '*load-time-values*)
   (setf *already-maybe-gcing* nil)  
394    
395    (cond ((featurep :cold-core)    ;; Only do this after top level forms have run, 'cause thats where
396           (setq *package* (find-package "USER"))    ;; deftypes are.
397           (print-herald))    (setf *type-system-initialized* t)
398          (t  
399           (terpri)    (print-and-call os-init)
400           (princ "CMUCL cold core ")    (print-and-call filesys-init)
401           (princ (lisp-implementation-version))  
402           (princ ".")    (print-and-call reader-init)
403           (terpri)    ;; Note: sharpm and backq not yet loaded, so this is not the final RT.
404           (princ "[You are in the LISP package.]")    (setf *readtable* (copy-readtable std-lisp-readtable))
405           (terpri)))  
406      (print-and-call stream-init)
407      (print-and-call loader-init)
408      (print-and-call package-init)
409      (print-and-call kernel::signal-init)
410      (setf (alien:extern-alien "internal_errors_enabled" boolean) t)
411    
412      (set-floating-point-modes :traps '(:overflow :invalid :divide-by-zero))
413    
414      ;; This is necessary because some of the initial top level forms might
415      ;; have changed the compilation policy in strange ways.
416      (print-and-call c::proclaim-init)
417    
418      (print-and-call kernel::class-finalize)
419    
420      (setq intl::*default-domain* nil)
421      (%primitive print "Done initializing.")
422    
423      #-gengc (setf *already-maybe-gcing* nil)
424      #+gengc (setf *gc-verbose* t)
425      (terpri)
426      (princ "CMU Common Lisp kernel core image ")
427      (princ (lisp-implementation-version))
428      (princ ".")
429      (terpri)
430      (princ "[You are in the LISP package.]")
431      (terpri)
432    (let ((wot (catch '%end-of-the-world    (let ((wot (catch '%end-of-the-world
433                 (loop                 (loop
434                    (%top-level)                   (%top-level)
435                    (write-line "You're certainly a clever child.")))))                   (write-line "You're certainly a clever child.")))))
436      (unix:unix-exit wot)))      (unix:unix-exit wot)))
437    
438    #+gengc
439    (defun do-load-time-value-fixup (object offset index)
440      (declare (type index offset))
441      (macrolet ((lose (msg)
442                   `(progn
443                      (%primitive print ,msg)
444                      (%halt))))
445        (let ((value (svref *load-time-values* index)))
446          (typecase object
447            (list
448             (case offset
449               (0 (setf (car object) value))
450               (1 (setf (cdr object) value))
451               (t (lose "Bogus offset in cons cell."))))
452            (instance
453             (setf (%instance-ref object (- offset vm:instance-slots-offset))
454                   value))
455            (code-component
456             (setf (code-header-ref object offset) value))
457            (simple-vector
458             (setf (svref object (- offset vm:vector-data-offset)) value))
459            (t
460             (lose "Unknown kind of object for load-time-value fixup."))))))
461    
462    
463  ;;;; Initialization functions:  ;;;; Initialization functions:
464    
# Line 422  Line 476 
476      (gc-init)      (gc-init)
477      (setf (alien:extern-alien "internal_errors_enabled" boolean) t)      (setf (alien:extern-alien "internal_errors_enabled" boolean) t)
478      (set-floating-point-modes :traps      (set-floating-point-modes :traps
479                                '(:overflow #-x86 :underflow :invalid                                '(:overflow :invalid :divide-by-zero))
                                           :divide-by-zero))  
480      ;; Clear pseudo atomic in case this core wasn't compiled with support.      ;; Clear pseudo atomic in case this core wasn't compiled with support.
481      #+x86 (setf lisp::*pseudo-atomic-atomic* 0))))      #+(or x86 amd64) (setf lisp::*pseudo-atomic-atomic* 0))))
482    
483    
484  ;;;; Miscellaneous external functions:  ;;;; Miscellaneous external functions:
# Line 447  Line 500 
500    
501  #-mp ; Multi-processing version defined in multi-proc.lisp.  #-mp ; Multi-processing version defined in multi-proc.lisp.
502  (defun sleep (n)  (defun sleep (n)
503    "This function causes execution to be suspended for N seconds.  N may    _N"This function causes execution to be suspended for N seconds.  N may
504    be any non-negative, non-complex number."    be any non-negative, non-complex number."
505    (when (or (not (realp n))    (when (or (not (realp n))
506              (minusp n))              (minusp n))
# Line 473  Line 526 
526    (zone   c-call:int)    (zone   c-call:int)
527    (guardp c-call:int))    (guardp c-call:int))
528    
529    
530  (defconstant bytes-per-scrub-unit 2048)  (defconstant bytes-per-scrub-unit 2048)
531    
532  ;;; Scrub-control-stack.  ;;; Scrub-control-stack.
533  ;;;  ;;;
534  #-x86  #-(or x86 amd64)
535  (defun scrub-control-stack ()  (defun %scrub-control-stack ()
536    "Zero the unused portion of the control stack so that old objects are not    _N"Zero the unused portion of the control stack so that old objects are not
537     kept alive because of uninitialized stack variables."     kept alive because of uninitialized stack variables."
538    (declare (optimize (speed 3) (safety 0))    (declare (optimize (speed 3) (safety 0))
539             (values (unsigned-byte 20)))             (values (unsigned-byte 20)))
# Line 514  Line 568 
568    
569  ;;; Scrub-control-stack.  ;;; Scrub-control-stack.
570  ;;;  ;;;
571  ;;; On the x86 port the stack grows downwards, and to support grow on  ;;; On the x86 and amd64 port the stack grows downwards, and to support grow on
572  ;;; demand stacks the stack must be decreased as it is scrubbed.  ;;; demand stacks the stack must be decreased as it is scrubbed.
573  ;;;  ;;;
 #+x86  
574  (defun scrub-control-stack ()  (defun scrub-control-stack ()
575    "Zero the unused portion of the control stack so that old objects are not    "Zero the unused portion of the control stack so that old objects are not
576     kept alive because of uninitialized stack variables."     kept alive because of uninitialized stack variables."
# Line 528  Line 581 
581    (%scrub-control-stack)    (%scrub-control-stack)
582    #+stack-checking (os-guard-control-stack 0 1))    #+stack-checking (os-guard-control-stack 0 1))
583    
584  #+x86  #+(or x86 amd64)
585  (defun %scrub-control-stack ()  (defun %scrub-control-stack ()
586    (%scrub-control-stack))    (%scrub-control-stack))
587    
588    
589  ;;;; TOP-LEVEL loop.  ;;;; TOP-LEVEL loop.
590    
591  (defvar / nil  (defvar / nil
592    "Holds a list of all the values returned by the most recent top-level EVAL.")    "Holds a list of all the values returned by the most recent top-level EVAL.")
593  (defvar // nil "Gets the previous value of / when a new value is computed.")  (defvar // nil "Gets the previous value of / when a new value is computed.")
# Line 556  Line 609 
609  (defun interactive-eval (form)  (defun interactive-eval (form)
610    "Evaluate FORM, returning whatever it returns but adjust ***, **, *, +++, ++,    "Evaluate FORM, returning whatever it returns but adjust ***, **, *, +++, ++,
611    +, ///, //, /, and -."    +, ///, //, /, and -."
612      (when (and (fboundp 'commandp) (funcall 'commandp form))
613        (return-from interactive-eval (funcall 'invoke-command-interactive form)))
614    (setf - form)    (setf - form)
615    (let ((results (multiple-value-list    (let ((results (multiple-value-list (eval form))))
                   (if (and (fboundp 'commandp)(funcall 'commandp form))  
                       (funcall 'invoke-command-interactive form)  
                       (eval form)))))  
616      (finish-standard-output-streams)      (finish-standard-output-streams)
617      (setf /// //      (setf /// //
618            // /            // /
# Line 574  Line 626 
626    (unless (boundp '*)    (unless (boundp '*)
627      ;; The bogon returned an unbound marker.      ;; The bogon returned an unbound marker.
628      (setf * nil)      (setf * nil)
629      (cerror "Go on with * set to NIL."      (cerror (intl:gettext "Go on with * set to NIL.")
630              "EVAL returned an unbound marker."))              (intl:gettext "EVAL returned an unbound marker.")))
631    (values-list /))    (values-list /))
632    
633    
634  (defconstant eofs-before-quit 10)  (defconstant eofs-before-quit 10)
635    
636    (defparameter *reserved-heap-pages* 256
637      "How many pages to reserve from the total heap space so we can handle
638    heap overflow.")
639    
640    #+heap-overflow-check
641    (alien:def-alien-variable "reserved_heap_pages" c-call:unsigned-long)
642    
643  (defun %top-level ()  (defun %top-level ()
644    "Top-level READ-EVAL-PRINT loop.  Do not call this."    "Top-level READ-EVAL-PRINT loop.  Do not call this."
645    (let  ((* nil) (** nil) (*** nil)    (let  ((* nil) (** nil) (*** nil)
# Line 588  Line 648 
648           (magic-eof-cookie (cons :eof nil))           (magic-eof-cookie (cons :eof nil))
649           (number-of-eofs 0))           (number-of-eofs 0))
650      (loop      (loop
651        (with-simple-restart (abort "Return to Top-Level.")        (with-simple-restart (abort (intl:gettext "Return to Top-Level."))
652          (catch 'top-level-catcher          (catch 'top-level-catcher
653            (unix:unix-sigsetmask 0)            (unix:unix-sigsetmask 0)
654            (let ((*in-top-level-catcher* t))            (let ((*in-top-level-catcher* t))
655              (loop              (loop
656                (scrub-control-stack)                (scrub-control-stack)
657                (fresh-line)                (fresh-line)
658                  ;; Reset reserved pages in the heap
659                  #+heap-overflow-check (setf reserved-heap-pages *reserved-heap-pages*)
660                (princ (if (functionp *prompt*)                (princ (if (functionp *prompt*)
661                           (funcall *prompt*)                           (funcall *prompt*)
662                           *prompt*))                           *prompt*))
# Line 613  Line 675 
675                             (let ((stream (make-synonym-stream '*terminal-io*)))                             (let ((stream (make-synonym-stream '*terminal-io*)))
676                               (setf *standard-input* stream)                               (setf *standard-input* stream)
677                               (setf *standard-output* stream)                               (setf *standard-output* stream)
678                               (format t "~&Received EOF on *standard-input*, ~                               (format t (intl:gettext "~&Received EOF on *standard-input*, ~
679                                          switching to *terminal-io*.~%"))))                                          switching to *terminal-io*.~%")))))
680                        ((> number-of-eofs eofs-before-quit)                        ((> number-of-eofs eofs-before-quit)
681                         (format t "~&Received more than ~D EOFs; Aborting.~%"                         (format t (intl:gettext "~&Received more than ~D EOFs; Aborting.~%")
682                                 eofs-before-quit)                                 eofs-before-quit)
683                         (quit))                         (quit))
684                        (t                        (t
685                         (format t "~&Received EOF.~%")))))))))))                         (format t (intl:gettext "~&Received EOF.~%"))))))))))))
686    
687    
688  ;;; %Halt  --  Interface  ;;; %Halt  --  Interface
# Line 628  Line 690 
690  ;;;    A convenient way to get into the assembly level debugger.  ;;;    A convenient way to get into the assembly level debugger.
691  ;;;  ;;;
692  (defun %halt ()  (defun %halt ()
   (%primitive print "%halt called")  
693    (%primitive halt))    (%primitive halt))

Legend:
Removed from v.1.67.4.2  
changed lines
  Added in v.1.82

  ViewVC Help
Powered by ViewVC 1.1.5