(defpackage slynk-allegro
(:use cl slynk-backend))
(in-package slynk-allegro)
(eval-when (:compile-toplevel :load-toplevel :execute)
(require :sock)
(require :process)
#+(version>= 8 2)
(require 'lldb)
)
(defimplementation gray-package-name ()
'#:excl)
(import-slynk-mop-symbols :clos '(:slot-definition-documentation))
(defun slynk-mop:slot-definition-documentation (slot)
(documentation slot t))
(define-symbol-macro utf8-ef
(load-time-value
(excl:crlf-base-ef (excl:find-external-format :utf-8))
t))
(defimplementation string-to-utf8 (s)
(excl:string-to-octets s :external-format utf8-ef
:null-terminate nil))
(defimplementation utf8-to-string (u)
(excl:octets-to-string u :external-format utf8-ef))
(defimplementation preferred-communication-style ()
:spawn)
(defimplementation create-socket (host port &key backlog)
(socket:make-socket :connect :passive :local-port port
:local-host host :reuse-address t
:backlog (or backlog 5)))
(defimplementation local-port (socket)
(socket:local-port socket))
(defimplementation close-socket (socket)
(close socket))
(defimplementation accept-connection (socket &key external-format buffering
timeout)
(declare (ignore buffering timeout))
(let ((s (socket:accept-connection socket :wait t)))
(when external-format
(setf (stream-external-format s) external-format))
s))
(defimplementation socket-fd (stream)
(excl::stream-input-handle stream))
(defvar *external-format-to-coding-system*
'((:iso-8859-1
"latin-1" "latin-1-unix" "iso-latin-1-unix"
"iso-8859-1" "iso-8859-1-unix")
(:utf-8 "utf-8" "utf-8-unix")
(:euc-jp "euc-jp" "euc-jp-unix")
(:us-ascii "us-ascii" "us-ascii-unix")
(:emacs-mule "emacs-mule" "emacs-mule-unix")))
(defimplementation find-external-format (coding-system)
(let ((e (rassoc-if (lambda (x) (member coding-system x :test #'equal))
*external-format-to-coding-system*)))
(and e (excl:crlf-base-ef
(excl:find-external-format (car e)
:try-variant t)))))
(defimplementation getpid ()
(excl::getpid))
(defimplementation lisp-implementation-type-name ()
"allegro")
(defimplementation set-default-directory (directory)
(let* ((dir (namestring (truename (merge-pathnames directory)))))
(setf *default-pathname-defaults* (pathname (excl:chdir dir)))
dir))
(defimplementation default-directory ()
(namestring (excl:current-directory)))
(defimplementation arglist (symbol)
(handler-case (excl:arglist symbol)
(simple-error () :not-available)))
(defimplementation macroexpand-all (form &optional env)
(declare (ignore env))
#+(version>= 8 0)
(excl::walk-form form)
#-(version>= 8 0)
(excl::walk form))
(defimplementation describe-symbol-for-emacs (symbol)
(let ((result '()))
(flet ((doc (kind &optional (sym symbol))
(or (ignore-errors
(documentation sym kind))
:not-documented))
(maybe-push (property value)
(when value
(setf result (list* property value result)))))
(maybe-push
:variable (when (boundp symbol)
(doc 'variable)))
(maybe-push
:function (if (fboundp symbol)
(doc 'function)))
(maybe-push
:class (if (find-class symbol nil)
(doc 'class)))
result)))
(defimplementation describe-definition (symbol namespace)
(ecase namespace
(:variable
(describe symbol))
((:function :generic-function)
(describe (symbol-function symbol)))
(:class
(describe (find-class symbol)))))
(defimplementation type-specifier-p (symbol)
(or (ignore-errors
(subtypep nil symbol))
(not (eq (type-specifier-arglist symbol) :not-available))))
(defimplementation function-name (f)
(check-type f function)
(cross-reference::object-to-function-name f))
(defvar *sly-db-topframe*)
(defimplementation call-with-debugging-environment (debugger-loop-fn)
(let ((*sly-db-topframe* (find-topframe))
(excl::*break-hook* nil))
(funcall debugger-loop-fn)))
(defimplementation sly-db-break-at-start (fname)
(eval `(trace (,fname
:print-before
((break "Function start breakpoint of ~A" ',fname)))))
`(:ok ,(format nil "Set breakpoint at start of ~S" fname)))
(defun find-topframe ()
(let ((magic-symbol (intern (symbol-name :slynk-debugger-hook)
(find-package :slynk)))
(top-frame (excl::int-newest-frame (excl::current-thread))))
(loop for frame = top-frame then (next-frame frame)
for i from 0
while (and frame (< i 30))
when (eq (debugger:frame-name frame) magic-symbol)
return (next-frame frame)
finally (return top-frame))))
(defun next-frame (frame)
(let ((next (excl::int-next-older-frame frame)))
(cond ((not next) nil)
((debugger:frame-visible-p next) next)
(t (next-frame next)))))
(defun nth-frame (index)
(do ((frame *sly-db-topframe* (next-frame frame))
(i index (1- i)))
((zerop i) frame)))
(defimplementation compute-backtrace (start end)
(let ((end (or end most-positive-fixnum)))
(loop for f = (nth-frame start) then (next-frame f)
for i from start below end
while f collect f)))
(defimplementation print-frame (frame stream)
(debugger:output-frame stream frame :moderate))
(defimplementation frame-locals (index)
(let ((frame (nth-frame index)))
(loop for i from 0 below (debugger:frame-number-vars frame)
collect (list :name (debugger:frame-var-name frame i)
:id 0
:value (debugger:frame-var-value frame i)))))
(defimplementation frame-arguments (index)
(let ((frame (nth-frame index)))
(values-list
(loop for i from 0 below (debugger:frame-number-vars frame)
unless (eq :local (debugger:frame-var-type frame i))
collect (debugger:frame-var-value frame i)))))
(defimplementation frame-var-value (frame var)
(let ((frame (nth-frame frame)))
(debugger:frame-var-value frame var)))
(defimplementation disassemble-frame (index)
(let ((frame (nth-frame index)))
(multiple-value-bind (x fun xx xxx pc) (debugger::dyn-fd-analyze frame)
(format t "pc: ~d (~s ~s ~s)~%fun: ~a~%" pc x xx xxx fun)
(disassemble (debugger:frame-function frame)))))
(defimplementation frame-source-location (index)
(let* ((frame (nth-frame index)))
(multiple-value-bind (x fun xx xxx pc) (debugger::dyn-fd-analyze frame)
(declare (ignore x xx xxx))
(cond ((and pc
#+(version>= 8 2)
(pc-source-location fun pc)
#-(version>= 8 2)
(function-source-location fun)))
(t (cadr (car (fspec-definition-locations
(car (debugger:frame-expression frame))))))))))
(defun function-source-location (fun)
(cadr (car (fspec-definition-locations
(xref::object-to-function-name fun)))))
#+(version>= 8 2)
(defun pc-source-location (fun pc)
(let* ((debug-info (excl::function-source-debug-info fun)))
(cond ((not debug-info)
(function-source-location fun))
(t
(let* ((code-loc (find-if (lambda (c)
(<= (- pc (sys::natural-width))
(let ((x (excl::ldb-code-pc c)))
(or x -1))
pc))
debug-info)))
(cond ((not code-loc)
(ldb-code-to-src-loc (aref debug-info 0)))
(t
(ldb-code-to-src-loc code-loc))))))))
#+(version>= 8 2)
(defun ldb-code-to-src-loc (code)
(declare (optimize debug))
(let* ((func (excl::ldb-code-func code))
(debug-info (excl::function-source-debug-info func))
(start (and debug-info
(loop for i from (excl::ldb-code-index code) downto 0
for bpt = (aref debug-info i)
for start = (excl::ldb-code-start-char bpt)
when start
return (if (listp start)
(first start)
start))))
(src-file (and func (excl:source-file func))))
(cond (start
(buffer-or-file-location src-file start))
(func
(let* ((debug-info (excl::function-source-debug-info func))
(whole (aref debug-info 0))
(paths (source-paths-of (excl::ldb-code-source whole)
(excl::ldb-code-source code)))
(path (if paths (longest-common-prefix paths) '()))
(start 0))
(buffer-or-file
src-file
(lambda (file)
(make-location `(:file ,file)
`(:source-path (0 . ,path) ,start)))
(lambda (buffer bstart)
(make-location `(:buffer ,buffer)
`(:source-path (0 . ,path)
,(+ bstart start)))))))
(t
nil))))
(defun longest-common-prefix (sequences)
(assert sequences)
(flet ((common-prefix (s1 s2)
(let ((diff-pos (mismatch s1 s2)))
(if diff-pos (subseq s1 0 diff-pos) s1))))
(reduce #'common-prefix sequences)))
(defun source-paths-of (whole part)
(let ((result '()))
(labels ((walk (form path)
(cond ((eq form part)
(push (reverse path) result))
((consp form)
(loop for i from 0 while (consp form) do
(walk (pop form) (cons i path)))))))
(walk whole '())
(reverse result))))
(defimplementation eval-in-frame (form frame-number)
(let ((frame (nth-frame frame-number)))
(let ((vars (loop for i below (debugger:frame-number-vars frame)
for name = (debugger:frame-var-name frame i)
if (typep name '(and symbol (not null) (not keyword)))
collect `(,name ',(debugger:frame-var-value frame i)))))
(debugger:eval-form-in-context
`(let* ,vars ,form)
(debugger:environment-of-frame frame)))))
(defimplementation frame-package (frame-number)
(let* ((frame (nth-frame frame-number))
(exp (debugger:frame-expression frame)))
(typecase exp
((cons symbol) (symbol-package (car exp)))
((cons (cons (eql :internal) (cons symbol)))
(symbol-package (cadar exp))))))
(defimplementation return-from-frame (frame-number form)
(let ((frame (nth-frame frame-number)))
(multiple-value-call #'debugger:frame-return
frame (debugger:eval-form-in-context
form
(debugger:environment-of-frame frame)))))
(defimplementation frame-restartable-p (frame)
(handler-case (debugger:frame-retryable-p frame)
(serious-condition (c)
(declare (ignore c))
nil)))
(defimplementation restart-frame (frame-number)
(let ((frame (nth-frame frame-number)))
(cond ((frame-restartable-p frame)
(apply #'debugger:frame-retry frame (debugger:frame-function frame)
(cdr (debugger:frame-expression frame))))
(t "Frame is not retryable"))))
(defvar *buffer-name* nil)
(defvar *buffer-start-position*)
(defvar *buffer-string*)
(defvar *compile-filename* nil)
(defun compiler-note-p (object)
(member (type-of object) '(excl::compiler-note compiler::compiler-note)))
(defun redefinition-p (condition)
(and (typep condition 'style-warning)
(every #'char-equal "redefin" (princ-to-string condition))))
(defun compiler-undefined-functions-called-warning-p (object)
(typep object 'excl:compiler-undefined-functions-called-warning))
(deftype compiler-note ()
`(satisfies compiler-note-p))
(deftype redefinition ()
`(satisfies redefinition-p))
(defun signal-compiler-condition (&rest args)
(apply #'signal 'compiler-condition args))
(defun handle-compiler-warning (condition)
(declare (optimize (debug 3) (speed 0) (space 0)))
(cond ((and #-(version>= 10 0) (not *buffer-name*)
(compiler-undefined-functions-called-warning-p condition))
(handle-undefined-functions-warning condition))
((and (typep condition 'excl::compiler-note)
(let ((format (slot-value condition 'excl::format-control)))
(and (search "Closure" format)
(search "will be stack allocated" format))))
)
(t
(signal-compiler-condition
:original-condition condition
:severity (etypecase condition
(redefinition :redefinition)
(style-warning :style-warning)
(warning :warning)
(compiler-note :note)
(reader-error :read-error)
(error :error))
:message (format nil "~A" condition)
:location (compiler-warning-location condition)))))
(defun condition-pathname-and-position (condition)
(let* ((context #+(version>= 10 0)
(getf (slot-value condition 'excl::plist)
:source-context))
(location-available (and context
(excl::source-context-start-char context))))
(cond (location-available
(values (excl::source-context-pathname context)
(when-let (start-char (excl::source-context-start-char context))
(let ((position (if (listp start-char) (first start-char)
start-char)))
(if (typep condition 'excl::compiler-free-reference-warning)
position
(1+ position))))))
((typep condition 'reader-error)
(let ((pos (car (last (slot-value condition 'excl::format-arguments))))
(file (pathname (stream-error-stream condition))))
(when (integerp pos)
(values file pos))))
(t
(let ((loc (getf (slot-value condition 'excl::plist) :loc)))
(when loc
(destructuring-bind (file . pos) loc
(let ((start
(if (consp pos)
#+(version>= 10 1)
(if (typep
condition
'excl::compiler-inconsistent-name-usage-warning)
(second pos) (first pos))
#-(version>= 10 1)
(first pos)
pos)))
(values file start)))))))))
(defun compiler-warning-location (condition)
(multiple-value-bind (pathname position)
(condition-pathname-and-position condition)
(cond (*buffer-name*
(make-location
(list :buffer *buffer-name*)
(if position
(list :offset 1 (1- position))
(list :offset *buffer-start-position* 0))))
(pathname
(make-location
(list :file (namestring (truename pathname)))
#+(version>= 10 1)
(list :offset 1 position)
#-(version>= 10 1)
(list :position (1+ position))))
(t
(make-error-location "No error location available.")))))
(defun handle-undefined-functions-warning (condition)
(let ((fargs (slot-value condition 'excl::format-arguments)))
(loop for (fname . locs) in (car fargs) do
(dolist (loc locs)
(multiple-value-bind (pos file) (ecase (length loc)
(2 (values-list loc))
(3 (destructuring-bind
(start end file) loc
(declare (ignore end))
(values start file))))
(signal-compiler-condition
:original-condition condition
:severity :warning
:message (format nil "Undefined function referenced: ~S"
fname)
:location (make-location (list :file file)
#+(version>= 9 0)
(list :offset 1 pos)
#-(version>= 9 0)
(list :position (1+ pos)))))))))
(defimplementation call-with-compilation-hooks (function)
(handler-bind ((warning #'handle-compiler-warning)
(compiler-note #'handle-compiler-warning)
(reader-error #'handle-compiler-warning))
(funcall function)))
(defimplementation slynk-compile-file (input-file output-file
load-p external-format
&key policy)
(declare (ignore policy))
(handler-case
(with-compilation-hooks ()
(let ((*buffer-name* nil)
(*compile-filename* input-file)
#+(version>= 8 2)
(compiler:save-source-level-debug-info-switch t)
(excl:*load-source-file-info* t)
#+(version>= 8 2)
(excl:*load-source-debug-info* t))
(compile-file *compile-filename*
:output-file output-file
:load-after-compile load-p
:external-format external-format)))
(reader-error () (values nil nil t))))
(defun call-with-temp-file (fn)
(let ((tmpname (system:make-temp-file-name)))
(unwind-protect
(with-open-file (file tmpname :direction :output :if-exists :error)
(funcall fn file tmpname))
(delete-file tmpname))))
(defvar *temp-file-map* (make-hash-table :test #'equal)
"A mapping from tempfile names to Emacs buffer names.")
(defun write-tracking-preamble (stream file file-offset)
"Instrument the top of the temporary file to be compiled.
The header tells allegro that any definitions compiled in the temp
file should be found in FILE exactly at FILE-OFFSET. To get Allegro
to do this, this factors in the length of the inserted header itself."
(with-standard-io-syntax
(let* ((*package* (find-package :keyword))
(source-pathname-form
`(cl:eval-when (:compile-toplevel :load-toplevel :execute)
(cl:setq excl::*source-pathname*
(pathname ,(sys::frob-source-file file)))))
(source-pathname-string (write-to-string source-pathname-form))
(position-form-length-bound 160) (header-length (+ (length source-pathname-string)
position-form-length-bound))
(position-form
`(cl:eval-when (:compile-toplevel :load-toplevel :execute)
(cl:setq excl::*partial-source-file-p* ,(- file-offset
header-length
1 ))))
(position-form-string (write-to-string position-form))
(padding-string (make-string (- position-form-length-bound
(length position-form-string))
:initial-element #\;)))
(write-string source-pathname-string stream)
(write-string position-form-string stream)
(write-string padding-string stream)
(write-char #\newline stream))))
(defun compile-from-temp-file (string buffer offset file)
(call-with-temp-file
(lambda (stream filename)
(when (and file offset (probe-file file))
(write-tracking-preamble stream file offset))
(write-string string stream)
(finish-output stream)
(multiple-value-bind (binary-filename warnings? failure?)
(let ((sys:*source-file-types* '(nil)) #+(version>= 8 2)
(compiler:save-source-level-debug-info-switch t)
(excl:*redefinition-warnings* nil))
(compile-file filename))
(declare (ignore warnings?))
(when binary-filename
(let ((excl:*load-source-file-info* t)
#+(version>= 8 2)
(excl:*load-source-debug-info* t))
excl::*source-pathname*
(load binary-filename))
(when (and buffer offset (or (not file)
(not (probe-file file))))
(setf (gethash (pathname stream) *temp-file-map*)
(list buffer offset)))
(delete-file binary-filename))
(not failure?)))))
(defimplementation slynk-compile-string (string &key buffer position filename
line column policy)
(declare (ignore line column policy))
(handler-case
(with-compilation-hooks ()
(let ((*buffer-name* buffer)
(*buffer-start-position* position)
(*buffer-string* string))
(compile-from-temp-file string buffer position filename)))
(reader-error () nil)))
(defun buffer-or-file (file file-fun buffer-fun)
(let* ((probe (gethash file *temp-file-map*)))
(cond (probe
(destructuring-bind (buffer start) probe
(funcall buffer-fun buffer start)))
(t (funcall file-fun (namestring (truename file)))))))
(defun buffer-or-file-location (file offset)
(buffer-or-file file
(lambda (filename)
(make-location `(:file ,filename)
`(:position ,(1+ offset))))
(lambda (buffer start)
(make-location `(:buffer ,buffer)
`(:offset ,start ,offset)))))
(defun fspec-primary-name (fspec)
(etypecase fspec
(symbol fspec)
(list (fspec-primary-name (second fspec)))))
(defun find-definition-in-file (fspec type file top-level)
(let* ((part
(or (scm::find-definition-in-definition-group
fspec type (scm:section-file :file file)
:top-level top-level)
(scm::find-definition-in-definition-group
(fspec-primary-name fspec)
type (scm:section-file :file file)
:top-level top-level)))
(start (and part
(scm::source-part-start part)))
(pos (if start
(list :offset 1 start)
(list :function-name (string (fspec-primary-name fspec))))))
(make-location (list :file (namestring (truename file)))
pos)))
(defun find-fspec-location (fspec type file top-level)
(handler-case
(etypecase file
(pathname
(let ((probe (gethash file *temp-file-map*)))
(cond (probe
(destructuring-bind (buffer offset) probe
(make-location `(:buffer ,buffer)
`(:offset ,offset 0))))
(t
(find-definition-in-file fspec type file top-level)))))
((member :top-level)
(make-error-location "Defined at toplevel: ~A"
(fspec->string fspec))))
(error (e)
(make-error-location "Error: ~A" e))))
(defun fspec->string (fspec)
(typecase fspec
(symbol (let ((*package* (find-package :keyword)))
(prin1-to-string fspec)))
(list (format nil "(~A ~A)"
(prin1-to-string (first fspec))
(let ((*package* (find-package :keyword)))
(prin1-to-string (second fspec)))))
(t (princ-to-string fspec))))
(defun fspec-definition-locations (fspec)
(cond
((and (listp fspec) (eq (car fspec) :internal))
(destructuring-bind (_internal next _n) fspec
(declare (ignore _internal _n))
(fspec-definition-locations next)))
(t
(let ((defs (excl::find-source-file fspec)))
(when (and (null defs)
(listp fspec)
(string= (car fspec) '#:method))
(setq defs (excl::find-source-file (second fspec))))
(if (null defs)
(list
(list fspec
(make-error-location "Unknown source location for ~A"
(fspec->string fspec))))
(loop for (fspec type file top-level) in defs collect
(list (list type fspec)
(find-fspec-location fspec type file top-level))))))))
(defimplementation find-definitions (symbol)
(fspec-definition-locations symbol))
(defimplementation find-source-location (obj)
(first (rest (first (fspec-definition-locations obj)))))
(defmacro defxref (name relation name1 name2)
`(defimplementation ,name (x)
(xref-result (xref:get-relation ,relation ,name1 ,name2))))
(defxref who-calls :calls :wild x)
(defxref calls-who :calls x :wild)
(defxref who-references :uses :wild x)
(defxref who-binds :binds :wild x)
(defxref who-macroexpands :macro-calls :wild x)
(defxref who-sets :sets :wild x)
(defun xref-result (fspecs)
(loop for fspec in fspecs
append (fspec-definition-locations fspec)))
(defun map-function-constants (function fn depth)
"Call FN with the elements of FUNCTION's constant pool."
(do ((i 0 (1+ i))
(max (excl::function-constant-count function)))
((= i max))
(let ((c (excl::function-constant function i)))
(cond ((and (functionp c)
(not (eq c function))
(plusp depth))
(map-function-constants c fn (1- depth)))
(t
(funcall fn c))))))
(defun in-constants-p (fun symbol)
(map-function-constants fun
(lambda (c)
(when (eq c symbol)
(return-from in-constants-p t)))
3))
(defun function-callers (name)
(let ((callers '()))
(do-all-symbols (sym)
(when (fboundp sym)
(let ((fn (fdefinition sym)))
(when (in-constants-p fn name)
(push sym callers)))))
callers))
(defimplementation list-callers (name)
(xref-result (function-callers name)))
(defimplementation list-callees (name)
(let ((result '()))
(map-function-constants (fdefinition name)
(lambda (c)
(when (fboundp c)
(push c result)))
2)
(xref-result result)))
(defvar *profiled-functions* ())
(defvar *profile-depth* 0)
(defmacro with-redirected-y-or-n-p (&body body)
`(let* ((pkg (find-package :common-lisp))
(saved-pdl (excl::package-definition-lock pkg))
(saved-ynp (symbol-function 'cl:y-or-n-p)))
(setf (excl::package-definition-lock pkg) nil
(symbol-function 'cl:y-or-n-p)
(symbol-function (slynk-backend:find-symbol2 "slynk:y-or-n-p-in-emacs")))
(unwind-protect
(progn ,@body)
(setf (symbol-function 'cl:y-or-n-p) saved-ynp
(excl::package-definition-lock pkg) saved-pdl))))
(defun start-acl-profiler ()
(with-redirected-y-or-n-p
(prof:start-profiler :type :time :count t
:start-sampling-p nil :verbose nil)))
(defun acl-profiler-active-p ()
(not (eq (prof:profiler-status :verbose nil) :inactive)))
(defun stop-acl-profiler ()
(prof:stop-profiler :verbose nil))
(excl:def-fwrapper profile-fwrapper (&rest args)
(declare (ignore args))
(cond ((zerop *profile-depth*)
(let ((*profile-depth* (1+ *profile-depth*)))
(prof:start-sampling)
(unwind-protect (excl:call-next-fwrapper)
(prof:stop-sampling))))
(t
(excl:call-next-fwrapper))))
(defimplementation profile (fname)
(unless (acl-profiler-active-p)
(start-acl-profiler))
(excl:fwrap fname 'profile-fwrapper 'profile-fwrapper)
(push fname *profiled-functions*))
(defimplementation profiled-functions ()
*profiled-functions*)
(defimplementation unprofile (fname)
(excl:funwrap fname 'profile-fwrapper)
(setq *profiled-functions* (remove fname *profiled-functions*)))
(defimplementation profile-report ()
(prof:show-flat-profile :verbose nil)
(when *profiled-functions*
(start-acl-profiler)))
(defimplementation profile-reset ()
(when (acl-profiler-active-p)
(stop-acl-profiler)
(start-acl-profiler))
"Reset profiling counters.")
(excl:without-redefinition-warnings
(defmethod emacs-inspect ((o t))
(allegro-inspect o)))
(defmethod emacs-inspect ((o function))
(allegro-inspect o))
(defmethod emacs-inspect ((o standard-object))
(allegro-inspect o))
(defun allegro-inspect (o)
(loop for (d dd) on (inspect::inspect-ctl o)
append (frob-allegro-field-def o d)
until (eq d dd)))
(defun frob-allegro-field-def (object def)
(with-struct (inspect::field-def- name type access) def
(ecase type
((:unsigned-word :unsigned-byte :unsigned-natural
:unsigned-long :unsigned-half-long
:unsigned-3byte :unsigned-long32)
(label-value-line name (inspect::component-ref-v object access type)))
((:lisp :value :func)
(label-value-line name (inspect::component-ref object access)))
(:indirect
(destructuring-bind (prefix count ref set) access
(declare (ignore set prefix))
(loop for i below (funcall count object)
append (label-value-line (format nil "~A-~D" name i)
(funcall ref object i))))))))
(defimplementation initialize-multiprocessing (continuation)
(mp:start-scheduler)
(funcall continuation))
(defimplementation spawn (fn &key name)
(mp:process-run-function name fn))
(defvar *process-plist-lock* (mp:make-process-lock :name "process-plist-lock"))
(defvar *thread-id-counter* 0)
(defimplementation thread-id (thread)
#+(version>= 10 0)
(mp:process-sequence thread)
#-(version> 10 0)
(mp:with-process-lock (*process-plist-lock*)
(or (getf (mp:process-property-list thread) 'id)
(setf (getf (mp:process-property-list thread) 'id)
(incf *thread-id-counter*)))))
(defimplementation find-thread (id)
(find id mp:*all-processes*
:key
#+(version>= 10 0)
#'mp:process-sequence
#-(version>= 10 0)
(lambda (p) (getf (mp:process-property-list p) 'id))))
(defimplementation thread-name (thread)
(mp:process-name thread))
(defimplementation thread-status (thread)
(princ-to-string (mp:process-whostate thread)))
(defimplementation thread-attributes (thread)
(list :priority (mp:process-priority thread)
:times-resumed (mp:process-times-resumed thread)))
(defimplementation make-lock (&key name)
(mp:make-process-lock :name name))
(defimplementation call-with-lock-held (lock function)
(mp:with-process-lock (lock) (funcall function)))
(defimplementation current-thread ()
mp:*current-process*)
(defimplementation all-threads ()
(copy-list mp:*all-processes*))
(defimplementation interrupt-thread (thread fn)
(mp:process-interrupt thread fn))
(defimplementation kill-thread (thread)
(mp:process-kill thread))
(defstruct (mailbox (:conc-name mailbox.))
(lock (mp:make-process-lock :name "process mailbox"))
(queue '() :type list)
(gate (mp:make-gate nil)))
(defvar *global-mailbox-ht-lock*
(mp:make-process-lock :name '*global-mailbox-ht-lock*))
(defvar *mailboxes* (make-hash-table :weak-keys t)
"Threads' mailboxes.")
(defun mailbox (thread)
"Return THREAD's mailbox."
(mp:with-process-lock (*global-mailbox-ht-lock*)
(or (gethash thread *mailboxes*)
(setf (gethash thread *mailboxes*) (make-mailbox)))))
(defimplementation send (thread message)
(let* ((mbox (mailbox thread)))
(mp:with-process-lock ((mailbox.lock mbox))
(setf (mailbox.queue mbox)
(nconc (mailbox.queue mbox) (list message)))
(mp:open-gate (mailbox.gate mbox)))))
(defimplementation wake-thread (thread)
(let* ((mbox (mailbox thread)))
(mp:open-gate (mailbox.gate mbox))))
(defimplementation receive-if (test &optional timeout)
(let ((mbox (mailbox mp:*current-process*)))
(flet ((open-mailbox ()
(check-sly-interrupts)
(mp:with-process-lock ((mailbox.lock mbox))
(let* ((q (mailbox.queue mbox))
(tail (member-if test q)))
(when tail
(setf (mailbox.queue mbox) (nconc (ldiff q tail) (cdr tail)))
(return-from receive-if (car tail)))
(mp:close-gate (mailbox.gate mbox))))))
(cond (timeout
(open-mailbox)
(return-from receive-if (values nil t)))
(t
(loop
(mp:process-wait
"receive-if (waiting on gate)"
#'mp:gate-open-p (mailbox.gate mbox))
(open-mailbox)))))))
(let ((alist '())
(lock (mp:make-process-lock :name "register-thread")))
(defimplementation register-thread (name thread)
(declare (type symbol name))
(mp:with-process-lock (lock)
(etypecase thread
(null
(setf alist (delete name alist :key #'car)))
(mp:process
(let ((probe (assoc name alist)))
(cond (probe (setf (cdr probe) thread))
(t (setf alist (acons name thread alist))))))))
nil)
(defimplementation find-registered (name)
(mp:with-process-lock (lock)
(cdr (assoc name alist)))))
(defimplementation set-default-initial-binding (var form)
(push (cons var form)
#+(version>= 9 0)
excl:*required-thread-bindings*
#-(version>= 9 0)
excl::required-thread-bindings))
(defimplementation quit-lisp ()
(excl:exit 0 :quiet t))
(defimplementation toggle-trace (spec)
(ecase (car spec)
((setf)
(toggle-trace-aux spec))
(:defgeneric (toggle-trace-generic-function-methods (second spec)))
((setf :defmethod :labels :flet)
(toggle-trace-aux (process-fspec-for-allegro spec)))
(:call
(destructuring-bind (caller callee) (cdr spec)
(toggle-trace-aux callee
:inside (list (process-fspec-for-allegro caller)))))))
(defun tracedp (fspec)
(member fspec (eval '(trace)) :test #'equal))
(defun toggle-trace-aux (fspec &rest args)
(cond ((tracedp fspec)
(eval `(untrace ,fspec))
(format nil "~S is now untraced." fspec))
(t
(eval `(trace (,fspec ,@args)))
(format nil "~S is now traced." fspec))))
(defun toggle-trace-generic-function-methods (name)
(let ((methods (mop:generic-function-methods (fdefinition name))))
(cond ((tracedp name)
(eval `(untrace ,name))
(dolist (method methods (format nil "~S is now untraced." name))
(excl:funtrace (mop:method-function method))))
(t
(eval `(trace (,name)))
(dolist (method methods (format nil "~S is now traced." name))
(excl:ftrace (mop:method-function method)))))))
(defun process-fspec-for-allegro (fspec)
(cond ((consp fspec)
(ecase (first fspec)
((setf) fspec)
((:defun :defgeneric) (second fspec))
((:defmethod) `(method ,@(rest fspec)))
((:labels) `(labels ,(process-fspec-for-allegro (second fspec))
,(third fspec)))
((:flet) `(flet ,(process-fspec-for-allegro (second fspec))
,(third fspec)))))
(t
fspec)))
(defimplementation make-weak-key-hash-table (&rest args)
(apply #'make-hash-table :weak-keys t args))
(defimplementation make-weak-value-hash-table (&rest args)
(apply #'make-hash-table :values :weak args))
(defimplementation hash-table-weakness (hashtable)
(cond ((excl:hash-table-weak-keys hashtable) :key)
((eq (excl:hash-table-values hashtable) :weak) :value)))
(defimplementation character-completion-set (prefix matchp)
(loop for name being the hash-keys of excl::*name-to-char-table*
when (funcall matchp prefix name)
collect (string-capitalize name)))
(defimplementation wrap (spec indicator &key before after replace)
(let ((allegro-spec (process-fspec-for-allegro spec)))
(excl:fwrap allegro-spec
indicator
(excl:def-fwrapper allegro-wrapper (&rest args)
(let (retlist completed)
(unwind-protect
(progn
(when before
(funcall before args))
(setq retlist (multiple-value-list
(if replace
(funcall replace args)
(excl:call-next-fwrapper))))
(setq completed t)
(values-list retlist))
(when after
(funcall after (if completed
retlist
:exited-non-locally)))))))))
(defimplementation unwrap (spec indicator)
(let ((allegro-spec (process-fspec-for-allegro spec)))
(excl:funwrap allegro-spec indicator)
allegro-spec))
(defimplementation wrapped-p (spec indicator)
(getf (excl:fwrap-order (process-fspec-for-allegro spec)) indicator))
#+(version>= 10 0)
(defimplementation package-local-nicknames (package)
(excl:package-local-nicknames package))