;;;; files for more information.
(in-package "SB!IMPL")
+;;;; Generalizing over SIMPLE-FUN, CLOSURE, and FUNCALLABLE-INSTANCEs
-(file-comment
- "$Header$")
-
-;;; cobbled from stuff in describe.lisp.
-(defun function-doc (x)
- (let ((name
- (case (get-type x)
- (#.sb!vm:closure-header-type
- (%function-name (%closure-function x)))
- ((#.sb!vm:function-header-type #.sb!vm:closure-function-header-type)
- (%function-name x))
- (#.sb!vm:funcallable-instance-header-type
- (typecase x
- (byte-function
- (sb!c::byte-function-name x))
- (byte-closure
- (sb!c::byte-function-name (byte-closure-function x)))
- (sb!eval:interpreted-function
- (multiple-value-bind (exp closure-p dname)
- (sb!eval:interpreted-function-lambda-expression x)
- (declare (ignore exp closure-p))
- dname))
- (t ;; funcallable-instance
- (%function-name
- (funcallable-instance-function x))))))))
- (when (and name (typep name '(or symbol cons)))
- (values (info :function :documentation name)))))
-
-(defvar *features* '#.sb-cold:*shebang-features*
+;;; Underlying SIMPLE-FUN
+(defun %fun-fun (function)
+ (declare (function function))
+ (typecase function
+ (simple-fun
+ function)
+ (closure
+ (%closure-fun function))
+ (funcallable-instance
+ (%fun-fun (funcallable-instance-fun function)))))
+
+(defun %fun-lambda-list (function)
+ (typecase function
+ #!+sb-eval
+ (sb!eval:interpreted-function
+ (sb!eval:interpreted-function-debug-lambda-list function))
+ (t
+ (%simple-fun-arglist (%fun-fun function)))))
+
+(defun (setf %fun-lambda-list) (new-value function)
+ (typecase function
+ #!+sb-eval
+ (sb!eval:interpreted-function
+ (setf (sb!eval:interpreted-function-debug-lambda-list function) new-value))
+ ;; FIXME: Eliding general funcallable-instances for now.
+ ((or simple-fun closure)
+ (setf (%simple-fun-arglist (%fun-fun function)) new-value)))
+ new-value)
+
+(defun %fun-type (function)
+ (%simple-fun-type (%fun-fun function)))
+
+;;; a SETFable function to return the associated debug name for FUN
+;;; (i.e., the third value returned from CL:FUNCTION-LAMBDA-EXPRESSION),
+;;; or NIL if there's none
+(defun %fun-name (function)
+ (typecase function
+ #!+sb-eval
+ (sb!eval:interpreted-function
+ (sb!eval:interpreted-function-debug-name function))
+ (t
+ (%simple-fun-name (%fun-fun function)))))
+
+(defun (setf %fun-name) (new-value function)
+ (typecase function
+ #!+sb-eval
+ (sb!eval:interpreted-function
+ (setf (sb!eval:interpreted-function-debug-name function) new-value))
+ ;; FIXME: Eliding general funcallable-instances for now.
+ ((or simple-fun closure)
+ (setf (%simple-fun-name (%fun-fun function)) new-value)))
+ new-value)
+
+(defun %fun-doc (function)
+ (typecase function
+ #!+sb-eval
+ (sb!eval:interpreted-function
+ (sb!eval:interpreted-function-documentation function))
+ (t
+ (%simple-fun-doc (%fun-fun function)))))
+
+(defun (setf %fun-doc) (new-value function)
+ (declare (type (or null string) new-value))
+ (typecase function
+ #!+sb-eval
+ (sb!eval:interpreted-function
+ (setf (sb!eval:interpreted-function-documentation function) new-value))
+ ((or simple-fun closure)
+ (setf (%simple-fun-doc (%fun-fun function)) new-value)))
+ new-value)
+\f
+;;; various environment inquiries
+
+(defvar *features*
+ '#.(sort (copy-list sb-cold:*shebang-features*) #'string<)
#!+sb-doc
"a list of symbols that describe features provided by the
implementation")
-\f
-;;; various environment inquiries
(defun machine-instance ()
#!+sb-doc
"Return a string giving the name of the local machine."
- (sb!unix:unix-gethostname))
+ #!+win32 (sb!win32::get-computer-name)
+ #!-win32 (sb!unix:unix-gethostname))
+
+(defvar *machine-version*)
+
+(defun machine-version ()
+ #!+sb-doc
+ "Return a string describing the version of the computer hardware we
+are running on, or NIL if we can't find any useful information."
+ (unless (boundp '*machine-version*)
+ (setf *machine-version* (get-machine-version)))
+ *machine-version*)
;;; FIXME: Don't forget to set these in a sample site-init file.
;;; FIXME: Perhaps the functions could be SETFable instead of having the
#!+sb-doc "the value of LONG-SITE-NAME")
(defun short-site-name ()
#!+sb-doc
- "Returns a string with the abbreviated site name, or NIL if not known."
+ "Return a string with the abbreviated site name, or NIL if not known."
*short-site-name*)
(defun long-site-name ()
#!+sb-doc
- "Returns a string with the long form of the site name, or NIL if not known."
+ "Return a string with the long form of the site name, or NIL if not known."
*long-site-name*)
\f
+;;;; ED
+(defvar *ed-functions* nil
+ "See function documentation for ED.")
+
+(defun ed (&optional x)
+ "Starts the editor (on a file or a function if named). Functions
+from the list *ED-FUNCTIONS* are called in order with X as an argument
+until one of them returns non-NIL; these functions are responsible for
+signalling a FILE-ERROR to indicate failure to perform an operation on
+the file system."
+ (dolist (fun *ed-functions*
+ (error 'extension-failure
+ :format-control "Don't know how to ~S ~A"
+ :format-arguments (list 'ed x)
+ :references (list '(:sbcl :variable *ed-functions*))))
+ (when (funcall fun x)
+ (return t))))
+\f
;;;; dribble stuff
;;; Each time we start dribbling to a new stream, we put it in
record of further I/O to that file. Without an argument, it closes
the dribble file, and quits logging."
(cond (pathname
- (let* ((new-dribble-stream
- (open pathname
- :direction :output
- :if-exists if-exists
- :if-does-not-exist :create))
- (new-standard-output
- (make-broadcast-stream *standard-output* new-dribble-stream))
- (new-error-output
- (make-broadcast-stream *error-output* new-dribble-stream))
- (new-standard-input
- (make-echo-stream *standard-input* new-dribble-stream)))
- (push (list *dribble-stream* *standard-input* *standard-output*
- *error-output*)
- *previous-dribble-streams*)
- (setf *dribble-stream* new-dribble-stream)
- (setf *standard-input* new-standard-input)
- (setf *standard-output* new-standard-output)
- (setf *error-output* new-error-output)))
- ((null *dribble-stream*)
- (error "not currently dribbling"))
- (t
- (let ((old-streams (pop *previous-dribble-streams*)))
- (close *dribble-stream*)
- (setf *dribble-stream* (first old-streams))
- (setf *standard-input* (second old-streams))
- (setf *standard-output* (third old-streams))
- (setf *error-output* (fourth old-streams)))))
+ (let* ((new-dribble-stream
+ (open pathname
+ :direction :output
+ :if-exists if-exists
+ :if-does-not-exist :create))
+ (new-standard-output
+ (make-broadcast-stream *standard-output* new-dribble-stream))
+ (new-error-output
+ (make-broadcast-stream *error-output* new-dribble-stream))
+ (new-standard-input
+ (make-echo-stream *standard-input* new-dribble-stream)))
+ (push (list *dribble-stream* *standard-input* *standard-output*
+ *error-output*)
+ *previous-dribble-streams*)
+ (setf *dribble-stream* new-dribble-stream)
+ (setf *standard-input* new-standard-input)
+ (setf *standard-output* new-standard-output)
+ (setf *error-output* new-error-output)))
+ ((null *dribble-stream*)
+ (error "not currently dribbling"))
+ (t
+ (let ((old-streams (pop *previous-dribble-streams*)))
+ (close *dribble-stream*)
+ (setf *dribble-stream* (first old-streams))
+ (setf *standard-input* (second old-streams))
+ (setf *standard-output* (third old-streams))
+ (setf *error-output* (fourth old-streams)))))
(values))
+
+(defun %byte-blt (src src-start dst dst-start dst-end)
+ (%byte-blt src src-start dst dst-start dst-end))
+
+;;;; some *LOAD-FOO* variables
+
+(defvar *load-print* nil
+ #!+sb-doc
+ "the default for the :PRINT argument to LOAD")
+
+(defvar *load-verbose* nil
+ ;; Note that CMU CL's default for this was T, and ANSI says it's
+ ;; implementation-dependent. We choose NIL on the theory that it's
+ ;; a nicer default behavior for Unix programs.
+ #!+sb-doc
+ "the default for the :VERBOSE argument to LOAD")
projects / sbcl.git / blobdiff