2012-05-25  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-oneliner): Use minibuffer width instead of the
	width of the current frame, minibuffer can be in a separate frame
	with a different width.
	Patch by Greg Pfeil (lp#1004252).

2012-05-21  Helmut Eller  <heller@common-lisp.net>

	Reduce dependecy on pre-defined faces.

	* slime.el (slime-apropos-symbol, slime-apropos-label): New faces.
	(slime-print-apropos): Use them.

	Reported by: Daimrod <daimrod@gmail.com>

2012-05-12  Helmut Eller  <heller@common-lisp.net>

	* swank-sbcl.lisp (stream-force-output): Undo last few changes.

2012-05-11  Helmut Eller  <heller@common-lisp.net>

	* swank-sbcl.lisp (stream-force-output): Use with-world-lock
	i.e. with-recursive-lock instead of with-mutex.
	* slime.el (sbcl-world-lock): New test.

2012-05-11  Helmut Eller  <heller@common-lisp.net>

	* swank-sbcl.lisp (stream-force-output): Don't use
	with-deadline. Grab the world-lock instead.
	(condition-timed-wait): Use the :timeout argument for real.

2012-05-11  Helmut Eller  <heller@common-lisp.net>

	* swank-backend.lisp (call-with-io-timeout): Not used. Deleted.
	* swank-sbcl.lisp (call-with-io-timeout): Deleted.

2012-05-07  Helmut Eller  <heller@common-lisp.net>

	Ignore linebreaks for the macroexpand test.
	SBCL should now also pass it.

	* slime.el (slime-test-macroexpansion=): New function.
	([test] macroexpand): Use it.

2012-05-06  Helmut Eller  <heller@common-lisp.net>

	* swank-sbcl.lisp (condition-timed-wait): Undo previous change.
	The :timeout arg doesn't seem ready for production use.

2012-05-06  Helmut Eller  <heller@common-lisp.net>

	* swank-sbcl.lisp (condition-timed-wait): Use the :timeout
	argument of sb-thread:condition-wait if supported.


2012-05-06  Helmut Eller  <heller@common-lisp.net>

	* swank-sbcl.lisp (with-definition-source): Forgot to commit this
	one.

	* swank-allegro.lisp (string-to-utf8): Set the :null-terminate
	argument of excl:string-to-octets to nil.

2012-05-06  Helmut Eller  <heller@common-lisp.net>

	* swank-backend.lisp (with-struct): Undo damage.
	* swank-sbcl.lisp (with-definition-source): New macro.

2012-05-06  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp, swank-rpc.lisp: iso-8859-1 is not same as
	latin-1-unix.

2012-05-06  Cyrus Harmon <ch-slime@bobobeach.com>
	    Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-pprint-eval-region): New command. No keybinding
	though.

2012-05-04  Nikodemus Siivola  <nikodemus@random-state.net>

	* swank-sbcl.lisp: Remove the SB-C::MERGE-TAIL-CALLS proclamation.
	It does nothing, and never did, actually.

2012-05-03  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-goto-source-location): Allow for
	:buffer-and-file locations, prefer buffer if the buffer exists.

	* swank-sbcl.lisp (definition-source-for-emacs): Send
	:buffer-and-file when both are available.
	(quit-lisp): Use sb-ext:exit when it's present.

2012-05-03  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (find-definitions-find-symbol): Put back accidentally
	removed with-buffer-syntax.

2012-05-02  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (*find-definitions-right-trim*)
	(*find-definitions-left-trim*): New variables. ",:." and "#:"
	default values.
	(find-definitions-for-emacs): Trim names with using the above
	variables when a symbol is not found.

2012-05-01  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-xrefs-for-notes): Format location in a proper
	way.
	Reported by Max Mikhanosha.

2012-04-27  Nikodemus Siivola  <nikodemus@random-state.net>

	* swank-sbcl.lisp (lisp-source-location): How hard can it be to
	get this right? (3-legged IF, FFS!)

2012-04-24  Douglas Crosher <dcrosher@common-lisp.net>

	* swank-scl.lisp (create-socket): correct variable name typo.

	* swank.lisp, swank-rpc.lisp (file options): use #\; to separate the
	file options.

2012-04-23  Christophe Rhodes  <csr21@cantab.net>

	* slime.el (slime-operator-before-point-function): new variable.
	(slime-operator-before-point): use it.
	(slime-lisp-operator-before-point): default implementation for
	slime-operator-before-point-function (unchanged from before).

2012-04-20  Nikodemus Siivola  <nikodemus@random-state.net>

	* swank-sbcl.lisp (stream-force-output :around): Workaroud for
	deadlocks between auto-flush-thread buffer write lock and world
	lock.
	(slime-output-stream): Dummy forward definition for the benefit of
	the defmethod.

2012-04-20  Nikodemus Siivola  <nikodemus@random-state.net>

	* swank-sbcl.lisp (swank-value): New function, makes it easy to
	refer to variables in SWANK -- which doesn't exist when the
	backend is loaded.
	(lisp-source-location): One of the strings being interned was
	downcased. Fix using SWANK-VALUE.
	(make-socket-io-stream): Use SWANK-VALUE instead of INTERN &
	SYMBOL-VALUE.

2012-04-11  Helmut Eller  <heller@common-lisp.net>

	* slime.el ([test] utf-8-source): Use the encoded byte sequence of
	the Unicode string.

2012-04-10  Stas Boukarev  <stassats@gmail.com>

	* slime.el (def-slime-test utf-8-source): Define only when
	(and (featurep 'emacs) (>= emacs-major-version 23)).

2012-04-10  Stas Boukarev  <stassats@gmail.com>

	* slime.el (def-slime-test utf-8-source): Another try at fixing
	utf8 literals in code.

2012-04-09  Stas Boukarev  <stassats@gmail.com>

	* slime.el (def-slime-test utf-8-source): Remove literal Unicode
	characters in the form of \xFFFF, it causes problems for some
	people.

2012-04-07  Helmut Eller  <heller@common-lisp.net>

	Fix long lines.

	* swank.lisp:
	* slime.el:
	* ChangeLog:
	* swank-cmucl.lisp:
	* swank-lispworks.lisp:
	* contrib/ChangeLog
	* hyperspec.el
	* metering.lisp
	* swank-abcl.lisp
	* swank-allegro.lisp
	* swank-backend.lisp
	* swank-clisp.lisp
	* swank-corman.lisp
	* swank-ecl.lisp
	* swank-sbcl.lisp
	* swank-scl.lisp
	* swank-source-path-parser.lisp
	* xref.lisp

2012-04-06  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (interrupt-worker-thread): Interrupt the REPL thread if
	there are no threads found. Send Emacs an error message if no
	threads are found at all.

2012-03-30  Nikodemus Siivola  <nikodemus@random-state.net>

	* swank-sbcl.lisp (lisp-source-location): When processing a
	STEP-FORM-CONDITION, don't show the initial form from expansion of
	STEP. (Currently SBCL doesn't give the form at all, but when it
	does seeing it is distinctly useless.)

2012-03-26  Helmut Eller  <heller@common-lisp.net>

	* slime.el (utf-8-source): XEmacs has no set-buffer-multibyte.
	(slime-create-test-results-buffer): Set file-coding-system.

	* swank-lispworks.lisp (swank-compile-string): Don't include the
	source-string in the dspec::*location*.  As LW has the habbit to
	print the entire *location* on redefinition the source-string
	would causes troubles for the test case.

	* swank-sbcl.lisp (swank-compile-string): Use utf8.

	* swank-cmucl.lisp (swank-compile-file): Use external-format arg.

	* swank-ccl.lisp (swank-compile-string, compile-temp-file): Use
	utf8.

	* slime.el (utf-8-source): New test case.

2012-03-14  Paulo Madeira <acelent@gmail.com>

	Use Unix-EOL convention even on Windows.

	* swank-allegro.lisp (string-to-utf8, utf8-to-string): Use
	excl:crlf-base-ef.
	* swank-lispworks.lisp (string-to-utf8,  utf8-to-string): Use
	'(:utf-8 :eol-style :lf)

2012-03-06  Helmut Eller  <heller@common-lisp.net>

	* swank-ccl.lisp: If 'xref is not provided warn about it but
	continue.

2012-03-06  Helmut Eller  <heller@common-lisp.net>

	Fix SBCL backend for Windows.

	* swank-sbcl.lisp (fd-stream-input-buffer-empty-p): Restore it.

2012-03-06  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (swank-require): Ensure that provide as called.

2012-02-12  Stas Boukarev  <stassats@gmail.com>

	* swank-ecl.lisp (accept-connection): Use the proper element-type
	for the stream.

2012-02-12  Stas Boukarev  <stassats@gmail.com>

	* swank-clisp.lisp (c-error): The number of parameters to
	sys::c-warn was changed, accommodate both versions.

2012-02-07  Martin Simmons <martin@lispworks.com>

	* swank-lispworks.lisp (dspec-file-position): Fall back to regexp
	search if dspec-stream-position gets an error.

2012-01-06  Helmut Eller  <heller@common-lisp.net>

	Add a "sentinel thread" to protect access to global lists.

	* swank.lisp (start-sentinel, sentinel, send-to-sentinel)
	(sentinel-serve, sentinel-stop-server, sentinel-maybe-exit): New.
	(make-connection, close-connection, setup-server, stop-server):
	Use the sentinel.
	(close-connection%): Factored out.
	* swank-backend.lisp (register-thread, find-registered): New.
	* swank-allegro.lisp: Implement it.
	* swank-ccl.lisp:
	* swank-lispworks.lisp:
	* swank-sbcl.lisp:

2012-01-02  Stas Boukarev  <stassats@gmail.com>

	* swank-loader.lisp (lisp-version-string): Append -no-threads to
	SBCL without threads.

2011-12-24  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-init-command): Don't call
	`slime-to-lisp-filename', the lisp is not yet connected and if
	there's another connection it will use the wrong translation.

2011-12-24  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (throw-to-toplevel): If *sldb-quit-restart* is not
	found, try to invoke the last restart, which usually is a
	top-level abort restart. This is useful when the debugger is
	invoked from a non-slime thread.

2011-12-23  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-cycle-connections): Add
	`slime-cycle-connections-hook', to be used by slime-repl.

2011-12-21  Stas Boukarev  <stassats@gmail.com>

	* swank-sbcl.lisp (input-ready-p): Don't use
	sb-impl::fd-stream-fd-type if it's not present.

2011-12-12  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-compile-region): Run slime-flash-region
	directly, not from `slime-before-compile-functions', which is run
	also for C-c C-k.

2011-12-10  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (auto-flush-loop): Don't use call-with-io-timeout.
	Removing it had no effect on the number of failed tests.  If you
	want it back, first create a test case to demonstrate the problem.
	* swank-backend.lisp: Mention that locks should only be used in
	swank-gray.lisp.

2011-12-10  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp: Move io-redirection to contrib/swank-repl.lisp.

2011-12-10  Helmut Eller  <heller@common-lisp.net>

	Make *active-threads* a slot of the connection struct.

	* swank.lisp (*active-threads*): Deleted
	([struct] multithreaded-connection): New slot active-threads.
	(find-worker-thread, interrupt-worker-thread)
	(thread-for-evaluation): Update accordingly.
	(add-active-thread, remove-active-thread): New helpers.

2011-12-10  Helmut Eller  <heller@common-lisp.net>

	* swank-loader.lisp (delete-stale-contrib-fasl-files): New.
	(compile-contribs): Use it.

2011-12-09  Helmut Eller  <heller@common-lisp.net>

	Create an extra thread for the indentation cache.

	* swank.lisp (indentation-cache-loop): New.
	([struct] multithreaded-connection): New slot
	indentation-cache-thread.
	(control-thread, cleanup-connection-threads): Create/kill it.
	(send-to-indentation-cache): New function.
	(update-indentation-information, sync-indentation-to-emacs): Use
	it.
	(perform-indentation-update, update-indentation/delta-for-emacs):
	Add package as argument; that used to be *buffer-package.  Can
	again be simpler as the indentation-cache-thread doesn't share the
	cache with others.
	(handle-indentation-cache-request, symbol-packages): New helpers.

2011-12-07  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (*slime-interrupts-enabled*): Describe the idea
	behind the interrupt handling code a bit.

2011-12-07  Helmut Eller  <heller@common-lisp.net>

	Make *event-queue* and *events-enqueued* slots of the connection
	struct.

	* swank.lisp (*event-queue*, *events-enqueued*): Deleted
	([struct] singlethreaded-connection): New slots event-queue and
	events-enqueued.
	(poll-for-event, send-event, wait-for-event/event-loop): Update
	accordingly.

2011-12-07  Helmut Eller  <heller@common-lisp.net>

	* slime.el ([xemacs]): Use (find-coding-system 'utf-8-unix)
	instead of checking the XEmacs version to decide when 'un-define
	is required.

2011-12-07  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (send-to-emacs): Add a without-slime-interrupts to
	protect send/receive from arbitrary interrupts.

2011-12-07  Helmut Eller  <heller@common-lisp.net>

	Move flow control from dispatch-event to send-to-emacs.

	* swank.lisp (*send-counter*): New thread local variable.
	(with-connection): Bind it.
	(send-to-emacs): Call maybe-slow-down.
	(maybe-slow-down, ping-pong): Go through dispatch-event instead of
	writing to the socket directly.
	(dispatch-event): Re-add thread arg to :ping/:emacs-pong.
	Also add a :test-delay event.
	(perform-indentation-update): Use with-connection to bind
	*emacs-connection* and *send-counter*.
	(background-message): Remove reference to connection.slowdown.
	(flow-control-test): New support code for testing flow-control.
	([defstruct] connection): Delete send-counter and slowdown slots.

	* slime.el (slime-dispatch-event): Re-add thread arg to
	:ping/:emacs-pong and :test-delay event.
	([test] flow-control): New test.

2011-12-07  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-update-system-indentation): Moved to
	contrib/slime-indentation.el.

2011-12-07  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-batch-test): Forgot to rename slime-run-one-test
	to slime-run-test here.
	(slime-net-connect): Remove coding-system argument.
	(slime-xref-insert-recompilation-flags): Use insert-char instead
	of (dotimes (i ..) (insert " " ..)) to avoid the compiler warning.
	([test] break, slime-forward-sexp): Use _i in dotimes.

2011-12-07  Stas Boukarev  <stassats@gmail.com>

	* doc/.cvsignore: Add html.tgz

2011-12-07  Didier Verna  <didier@xemacs.org>

	* doc/.cvsignore: Add more files generated by Texinfo (.kys, .fns
	and .vrs).

2011-12-05  Didier Verna  <didier@xemacs.org>

	* slime.el ([xemacs]): Don't require 'un-define in XEmacs 21.5 and
	later. Mule-UCS is not needed anymore because of internal Unicode
	support (and conflicts with it).

2011-12-06  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-compile-region): Check connection before running
	hooks, invoking slime-flash-region doesn't make much sense when
	there's no connection.

2011-12-05  Helmut Eller  <heller@common-lisp.net>

	Move flow control into dispatch-event.

	* swank.lisp (maybe-slow-down, ping-pong): New functions.
	(dispatch-event): Use it. Also require connection argument.
	Update callers accordingly.
	([defstruct] connection): New slots: send-counter and slowdown.
	* slime.el (slime-dispatch-event): Drop thread from
	:ping/:emacs-ping messages.

	Use subclasses of connection.  Wasn't neccessary for flow control
	but seems like a good idea for the future.

	* swank.lisp (multithreaded-connection)
	(singlethreaded-connection): New
	(make-connection): Create multi/single threaded variant depending
	on style argument.
	([defstruct] serve-requests, cleanup): Delete slots.  Dispatch on
	connection type instead.
	(stop-serving-requests): New.
	(close-connection): Use it.  Can't use
	*use-dedicated-output-stream* here.

	* swank.lisp (background-message): Do nothing if
	connection.slowdown is set.

2011-12-05  Helmut Eller  <heller@common-lisp.net>

	* slime.el ([test] arglist): swank::create-server now has an
	optional argument.  Use swank::compute-backtrace instead.

2011-12-05  Stas Boukarev  <stassats@gmail.com>

	* start-swank.lisp: Remove :coding-system argument.

2011-12-04  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (interrupt-worker-thread): Don't use find-repl-thread
	as fallback.

2011-12-04  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp: Minor cleanups.
	* swank-rpc.lisp:

2011-12-04  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (create-repl): Moved to contrib/swank-repl.lisp.
	(*use-dedicated-output-stream*, *dedicated-output-stream-port*
	(*dedicated-output-stream-buffering*, open-streams)
	(make-output-function, send-user-output)
	(make-output-function-for-target, make-output-stream-for-target)
	(open-dedicated-output-stream, find-repl-thread)
	(spawn-repl-thread, repl-loop, initialize-streams-for-connection)
	(read-user-input-from-emacs,  *listener-eval-function*)
	(listener-eval, *send-repl-results-function*, repl-eval)
	(clear-repl-variables, track-package, send-repl-results-to-emacs)
	(redirect-trace-output);
	* swank-loader.lisp (*contribs*): Add swank-repl.

2011-12-04  Helmut Eller  <heller@common-lisp.net>

	* swank-loader.lisp (*contribs*): Add swank-mrepl.

2011-12-04  Helmut Eller  <heller@common-lisp.net>

	* swank-rpc.lisp (read-chunk): Signal end-of-file we had no input.

2011-12-03  Nikodemus Siivola  <nikodemus@random-state.net>

	* swank-sbcl.lisp (wait-for-input): Another go at this. Rip out POLL,
	build on top of just INPUT-READY-P.
	(input-ready-p): Outside Windows, use SYSREAD-MAY-BLOCK-P to check.

2011-12-03  Gbor Melis  <mega@retes.hu>

	* swank-allegro.lisp (set-default-initial-binding): In 9.0 alpha,
	*CL-DEFAULT-SPECIAL-BINDINGS* is [soon to be] deprecated.  It's
	otherwise the same EXCL:*REQUIRED-TOP-LEVEL-BINDINGS* (i.e. no
	change in behavior).

2011-12-03  Helmut Eller  <heller@common-lisp.net>

	* swank-clisp.lisp (wait-for-input): Add a version for windows.

2011-12-02  Stas Boukarev  <stassats@gmail.com>

	* swank-sbcl.lisp (wait-for-input): Define only if
	#+os-provides-poll or #+win32.

2011-12-02  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (listener-channel): Moved to contrib/swank-mrepl.lisp
	(create-listener, initial-listener-bindings, spawn-listener-thread).

2011-12-01  Helmut Eller  <heller@common-lisp.net>

	* swank-sbcl.lisp (wait-for-input): Call poll(2).
	* swank-backend.lisp (wait-for-streams, wait-for-one-stream):
	Deleted. Wouldn't work on binary streams.

2011-12-01  Helmut Eller  <heller@common-lisp.net>

	* swank-loader.lisp (*contribs*): Add swank-util.

2011-12-01  Helmut Eller  <heller@common-lisp.net>

	* swank-cmucl.lisp (method-location): Special case accessors.

2011-11-29  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (do-symbols*, classify-symbol)
	(symbol-classification-string): Moved to contrib/swank-util.lisp.

2011-11-29  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (to-line): Increase default limit to 512.
	(frame-locals-for-emacs): Let *print-right-margin* override
	default line width.

2011-11-27  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (create-server): Add a :backlog argument.
	(setup-server): Pass it along.

	* swank-backend.lisp (create-socket): Backlog argument.
	* swank-abcl.lisp: Implement it.
	* swank-allegro.lisp:
	* swank-ccl.lisp:
	* swank-clisp.lisp:
	* swank-cmucl.lisp:
	* swank-corman.lisp:
	* swank-ecl.lisp:
	* swank-lispworks.lisp:
	* swank-sbcl.lisp:
	* swank-scl.lisp:

2011-11-27  Helmut Eller  <heller@common-lisp.net>

	* swank-cmucl.lisp (make-socket-io-stream): Create character
	stream if external-format is non-nil.

2011-11-27  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (create-server): Remove coding-system argument.
	([defstruct] connection): Remove coding-system slot.
	(connection.external-format, *coding-system*): Deleted.
	(make-connection, start-server, create-server, setup-server)
	(accept-connections): Drop coding-system arg.

	(connection-info): Return supported coding systems.
	(create-repl, open-dedicated-output-stream)
	(open-streams, initialize-streams-for-connection): Add
	coding-system arg.

	* slime.el (slime-init-command): Ignore the coding-system arg.
	(slime-connection-coding-systems): New connection variable.
	(slime-set-connection-info): Set it.

2011-11-27  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (eval-in-frame-aux): Don't bind *package* during
	eval.

2011-11-21  Helmut Eller  <heller@common-lisp.net>

	* swank-cmucl.lisp: Trigger compilation of utf8 stuff before first
	real use.

2011-11-21  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (*sldb-printer-bindings*): Removed.  Rather useless
	since the change from 2009-02-26.  It could at best have some
	influence on the way conditions are printed.  *sldb-string-length*
	and *sldb-bitvector-length* where both nil so
	*sldb-pprint-dispatch-table* was also not used by default.  In
	summary, spending 3 pages for something that's not used by default
	was pretty silly.  One variable less where we can get the defaults
	wrong.

2011-11-21  Helmut Eller  <heller@common-lisp.net>

	* slime.el (sldb-eval-in-frame): Try to figure the package out.
	Ask Lisp if the function for frame was defined in a particular
	package and use it to read the form.
	(sldb-read-form-for-frame): New helper.

	* swank-backend (frame-package): New.
	* swank-cmucl (frame-package): Implement it.

	* swank.lisp (frame-package-name, eval-in-frame-aux): New.
	(eval-string-in-frame, pprint-eval-string-in-frame): Use package
	argument.

2011-11-19  Nikodemus Siivola  <nikodemus@random-state.net>

	* swank-sbcl.lisp (restart-frame): Make it possible to restart
	frames of anonymous functions -- at least some of the time.

2011-11-16  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (open-dedicated-output-stream): Open a stream with
	the right coding system.
	Change (:open-dedicated-output-stream port) message to
	(:open-dedicated-output-stream port coding-system), because Emacs
	can no longer determine the coding system based on the main
	network streams since they are binary now.

2011-11-11  Anton Kovalenko  <anton@sw4me.com>

	* slime.el (slime-ed): add bytep argument to destructure-case.
	When it's true, position is interpreted as byte offset.

2011-11-08  Helmut Eller  <heller@common-lisp.net>

	Restore old header format.

	* swank-rpc.lisp (parse-header, write-header)
	* slime.el (slime-net-decode-length, slime-net-encode-length)

2011-11-06  Helmut Eller  <heller@common-lisp.net>

	* swank-ecl.lisp (accept-connection): Fix buffering arg.
	* swank-cmucl.lisp (accept-connection): Fix buffering arg.

2011-11-06  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-run-test): Renamed from slime-run-one-test.
	(slime-toggle-test-debug-on-error): New.
	([test] break): Longer timeouts.

2011-11-06  Helmut Eller  <heller@common-lisp.net>

	Add portable versions for string-to-utf8 and utf8-to-string.

	* swank-backend.lisp (default-string-to-utf8)
	(default-utf8-to-string): New.
	(string-to-utf8, utf8-to-string): Use default implementations.

	* swank-lispworks.lisp (make-flexi-stream): Restored.
	(utf8-stream): Deleted.  The utf8 stuff is now used for the
	default implementation of utf8-to-string and would cause name
	clashes.

2011-11-06  Helmut Eller  <heller@common-lisp.net>

	* swank-allegro.lisp (swank-compile-string): For reader errors
	return nil not (values nil nil t).

2011-11-06  Helmut Eller  <heller@common-lisp.net>

	New wire format.

	Switch from character streams to binary streams.  Counting
	characters was error prone because some Lisps use utf-16
	internally and so READ-SEQUENCE can't be used easily.

	The new format looks so:

	  | byte0 | 3 bytes length |
	  |    ... payload ...     |

	The playload is an s-exp encoded as UTF-8 string.  byte0 is
	currently always 0; other values are reserved for future use.

	* swank-rpc.lisp (write-message): Use new format.
	(write-header, parse-header, asciify, encoding-error): New.

	* swank.lisp (accept-connections): Create a binary stream.
	(input-available-p): Can't read-char-no-hang on binary streams.

	* slime.el (slime-net-connect): Use binary as coding system.
	(slime-net-send, slime-net-read, slime-net-decode-length)
	(slime-net-encode-length, slime-net-have-input-p): Use new format.
	(slime-unibyte-string, slime-handle-net-read-error): New.
	(featurep): Require 'un-define for XEmacs.

	* swank-sbcl.lisp (input-ready-p): Use sb-sys:wait-until-fd-usable.

2011-11-06  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (close-connection): Fix thinko.

2011-11-06  Helmut Eller  <heller@common-lisp.net>

	* swank-backend.lisp (accept-connection): Improve docstring.  In
	particular say that we want a binary stream if the EXTERNAL-FORMAT
	argument is nil.

	* swank-abcl.lisp (accept-connection): Make it so.
	* swank-clisp.lisp (accept-connection): Make it so.
	* swank-cmucl.lisp (accept-connection): Make it so.
	* swank-lispworks.lisp (accept-connection): Make it so.
	* swank-sbcl.lisp (accept-connection): Make it so.
	* swank-scl.lisp (accept-connection): Make it so.

2011-11-06  Helmut Eller  <heller@common-lisp.net>

	* swank-backend.lisp (utf8-to-string, string-to-utf8): New.

	* swank-sbcl.lisp (string-to-utf8, string-to-utf8): Implemented.
	* swank-lispworks.lisp (string-to-utf8, string-to-utf8): Implemented.
	* swank-cmucl.lisp (string-to-utf8, string-to-utf8): Implemented.
	* swank-clisp.lisp (string-to-utf8, string-to-utf8): Implemented.
	* swank-ccl.lisp (string-to-utf8, string-to-utf8): Implemented.
	* swank-allegro.lisp (string-to-utf8, string-to-utf8): Implemented.
	* swank-abcl.lisp (string-to-utf8, string-to-utf8): Implemented.
	(octets-to-jbytes, jbytes-to-octets): New helpers.

2011-11-03  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (close-connection): Be more careful with non-ascii.

2011-11-03  Helmut Eller  <heller@common-lisp.net>

	Remove dependecy on FLEXI-STREAMS for Lispworks.

	* swank-lispworks.lisp (make-flexi-stream): Deleted.
	(utf8-stream): New class to do the transcoding.
	(accept-connection): Use it.

2011-10-19  Andrew Myers <asm198@gmail.com>

	* swank-allegro.lisp (frob-allegro-field-def): Add missing type to
	ecase for inspector.

2011-10-13  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (all-completions): Remove mixed case syms e.g |Foo|.
	"fo" is not a prefix of "|Foo|" and it would be problematic later.

2011-10-05  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (clear-repl-variables): New functions, clears *, /,
	and + variables.

2011-09-28  Stas Boukarev  <stassats@gmail.com>

	* slime.el: Remove (require 'hideshow), it's not used anymore.
	Spotted by Leo Liu.

2011-09-27  Mark Evenson  <evenson@panix.com>

	* swank-abcl.lisp (describe-symbol-for-emacs): Differentiate
	between function, generic function, special forms, and macros by
	copying SBCL implementation.

2011-09-13  Christophe Rhodes  <csr21@cantab.net>

	* slime.el (slime-simple-complete-symbol): only display "Complete
	but not unique" message if the partial completion figures in the
	completion list.

2011-08-31  Anton Kovalenko  <anton@sw4me.com>

	* swank-sbcl.lisp (preferred-communication-style): check for
	:sb-thread before :win32, so :spawn is preferred for threaded
	Windows builds.

2011-08-31  Nikodemus Siivola  <nikodemus@random-state.net>

	* swank-sbcl.lisp (make-socket-io-stream): Backwards compatibility with
	SBCL < 1.0.42.43 -- and bugfix.

2011-08-26  Mark Evenson  <evenson@panix.com>

	* swank-abcl.lisp (class-slots): Use exported symbol allowing
	classes with non-standard metaobjects to be inspected.

2011-08-18  Helmut Eller  <heller@common-lisp.net>

	Fix line numbers for compiler notes if is narrowing was in effect.

	* slime.el (slime-canonicalized-location): Widen before calling
	line-number-at-pos.

2011-08-17  Stas Boukarev  <stassats@gmail.com>

	* swank-allegro.lisp (with-redirected-y-or-n-p): Fix modern-mode
	issues.
	Patch by Andrew Myers.

2011-08-09  Nikodemus Siivola  <nikodemus@random-state.net>

	* swank-sbcl.lisp (make-socket-io-stream): Use :SERVE-EVENTS T when
	using :FD-HANDLER as the communication style. SBCL will soon stop
	serving events by default on socket streams.

2011-08-08  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-unintern-symbol): New command.
	* swank.lisp (unintern-symbol): Lisp-side implementation.

2011-07-03  Nikodemus Siivola  <nikodemus@random-state.net>

	* swank-sbcl.lisp (debug-var-info): New function: calls
	SB-DI::DEBUG-VAR-INFO when available.
	(frame-locals, frame-var-value): Treat more-context and more-count
	vars specially.

2011-06-21  Nikodemus Siivola  <nikodemus@random-state.net>

	* swank.lisp (*indentation-cache-lock*): Deleted.
	(perform-indentation-update): Spawn a new thread to handle the
	indentation update when using threads. Move cache-clearing to
	UPDATE-INDENTATION/DELTA-FOR-EMACS. Replace the old cache by
	the one returned from U-I/D-F-E.
	(update-indentation/delta-for-emacs): When clearing the cache,
	allocate a new table. When threads are being used, copy the
	cache before mutation, to ensure that caches possibly seen by other
	threads are write-only by then.

2011-06-18  Nikodemus Siivola  <nikodemus@random-state.net>

	* swank.lisp (*indentation-cache-lock*): New variable:
	hash-table updates aren't necessarily thread-safe.
	(perform-indentation-update, update-indentation/delta-for-emacs):
	Grab the lock when necessary -- in delta-for-emacs we hold on to
	it a bit longer than necessary, but the code is easier to read
	this way.

2011-06-16  Nikodemus Siivola  <nikodemus@random-state.net>

	* swank.lisp (macro-indentation): Restore the old simple version.

	* swank-sbcl.lisp (compiling-from-buffer-p): PROBE-FILE to
	handle cases there the tmp-directory is a symlink.
	(compiling-from-file-p): Ditto.

2011-06-14  Nikodemus Siivola  <nikodemus@random-state.net>

	* swank-backend.lisp (call-with-io-timeout): New DEFINTERFACE.
	* swank-sbcl.lisp (call-with-io-timeout): DEFIMPLEMENTATION for it.
	* swank.lisp (auto-flush-loop): Call FINISH-OUTPUT using
	CALL-WITH-IO-TIMEOUT to prevent deadlocks.

	* swank.lisp (macro-indentation): Fix handling of lambda-list
	keywords other than &rest and &body.

	* slime.el (slime-update-system-indentation): Remove stale specs
	from common-lisp-system-indentation when new one arrives.

2011-06-10  Nikodemus Siivola  <nikodemus@random-state.net>

	* swank.lisp (macro-indentation): Walk the lambda-list
	to construct a better indentation spec instead of just
	looking for &BODY.

2011-06-09  Nikodemus Siivola  <nikodemus@random-state.net>

	* swank-sbcl.lisp (execv): Stupid SBCL hackers breaking backwards
	compatibility again: SB-POSIX:SYSCALL-ERROR has a required
	argument in 1.0.49, but accepts no arguments in older ones. Use
	plain ERROR instead.

	Support for per-package derived indentation, when
	slime-indentation is used.

	* swank.lisp (update-indentation/delta-for-emacs): Tell Emacs
	which packages the symbol is available in. Unless
	slime-indentation is used, this information is just dropped on the
	floor.

	* slime.el (slime-update-system-indentation): New function. Use
	this to inform indentation about derived specs when
	`common-lisp-system-indentation' is bound.
	(slime-handle-indentation-update): Adjust to support per-package
	derived indentation specs when slime-indentation is available.

2011-05-27  Helmut Eller  <heller@common-lisp.net>

	Fix "wrong number of args" problem with slime-inspector-quit.
	Reported by Anton Kovalenko.

	* slime.el (slime-popup-buffer-quit-function)
	(slime-quit-threads-buffer): Drop the kill-buffer-p argument.

2011-05-24  Helmut Eller  <heller@common-lisp.net>

	* slime.el (destructure-case): Fix "`_' not left unused" warnings.
	Insert an (ignore) form for empty bodies; this inhibts the
	compiler transformation that leads to the spurios warning.  This
	has no runtime cost in compiled code, since the compiler
	recognizes (ignore) and emits no code for it.
	(slime-flatten-tree): Deleted. No longer used.

2011-05-23  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (sdlb-print-condition): New (or old new)
	function. It was bound by P in sldb-mode, but for some reason it
	was lost.

2011-05-23  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-apropos-label-properties): Deleted.  Just
	auto-load apropos-mode.
	(slime-print-apropos): Use the variable apropos-label-face
	which seems to exist in all relevant Emacsen.

2011-05-22  Helmut Eller  <heller@common-lisp.net>

	Turn on lexical-binding for slime.el.
	This mostly involves prefixing unused variables
	with underscores to shut up the compiler, but
	also some less harmless changes.

	* slime.el (slime-dispatching-connection, slime-current-thread):
	Add defvars.
	(slime-connect): called-interactively-p wants 1 arg in Emacs 24
	but none in Emacs 22.  So we can't use it; instead add an extra
	optional arg and set that to non-nil in the interactive spec.
	(slime-read-from-minibuffer): Actually use the history arg.
	(slime-inspector-quit): Drop the unused kill-buffer arg from the
	lambda-list.
	(slime-run-tests): Can't specbind slime-repl-history-file without
	variable declation.  I don't want to declare it here so I just
	eliminated it and let somebody else fix slime-repl.el.

2011-05-21  Helmut Eller  <heller@common-lisp.net>

	Minor tweaks to avoid some compiler warnings.

	* slime.el (slime-modeline-string, slime-buffer-connection):
	Declare variables.
	(slime-flatten-tree): Helper function.
	(destructure-case): Use it, and make '_ ignorable if
	it occurs in some pattern.
	(slime-connect): Avoid obsolete functions:
	string-to-int -> string-to-number
	interactive-p -> called-interactively-p
	(slime-complete-maybe-restore-window-configuration)
	last-command-char -> last-command-event
	completion-base-size ->  completion-base-position
	(slime-xref-mode-map): Use call-interactively
	when calling the remapped next-line/previous-line commands.

2011-05-09  Nikodemus Siivola  <nikodemus@random-state.net>

	* swank-sbcl.lisp (swank-compile-string): Use :SOURCE-NAMESTRING
	to provide the name of the actual source file, and
	:ALLOW-OTHER-KEYS for compatibility with pre-1.0.48.1 versions.
	This allows SBCL to get uninteresting redefinition muffling right.
	(*trap-load-time-warnings*): Default to T to make the redefinition
	notes more visible, especially now that redefinition muffling hides
	the boring ones.

2011-05-08  Nikodemus Siivola  <nikodemus@random-state.net>

	* slime.el (slime-intern-indentation-spec): New function. Converts
	strings in an indentation spec to symbols.
	(slime-handle-indentation-update): Intern the indentation spec
	using slime-intern-indentation-spec, so that lisp side can pass
	complex indentation specs.
	* contrib/swank-indentation.lisp (application-indentation-hint):
	Downcase symbol names -- any symbol in an indentation spec is
	pretty much guaranteed to have a lowecase name on the Emacs side.

2011-04-16  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-load-failed-fasl): New variable. Accepts `ask',
	`always', and `never' symbols. Loads or not loads fasls produced by
	compile-file which returned non-nil failure-p.

2011-04-14  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (list-threads): Call `use-threads-p' only when
	*emacs-connection* is non-nil. `use-threads-p' wouldn't work in
	this case, and there is no need to remove a worker thread from the
	list if it's not connected.
	This fixes an issue with calling swank:stop-server when slime
	isn't connected.

2011-03-13  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (format-restarts-for-emacs): Add
	without-printing-errors around restart printing.

2011-03-09  Helmut Eller  <heller@common-lisp.net>

	Remove slime-sexp-at-point-for-macroexpansion.

	* slime.el (slime-sexp-at-point-for-macroexpansion): Deleted.
	(slime-eval-macroexpand): Use slime-sexp-at-point instead.
	(slime-eval-macroexpand-inplace): Use
	slime-bounds-of-sexp-at-point directly.

2011-03-09  Helmut Eller  <heller@common-lisp.net>

	Move some of the logic from slime-sexp-at-point-for-macroexpansion
	into slime-sexp-at-point.

	* slime.el (slime-bounds-of-sexp-at-point): New.  Special case if
	we are at '( as slime-sexp-at-point-for-macroexpansion does.
	(slime-bounds-of-symbol-at-point): New.
	(slime-symbol-at-point, slime-sexp-at-point): Use the above.

2011-02-24  Stas Boukarev  <stassats@gmail.com>

	* swank-allegro.lisp (find-topframe): Fix excl::int-newest-frame
	invocation for the latest alpha version of Allegro.
	Patch by Gbor Melis.

2011-02-18  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-init-popup-buffer): Don't use
	multiple-value-setq on a list, XEmacs doesn't like it.

2011-02-18  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-insert-threads): Make sure newlines have the
	same thread-id property as the rest of the line. This fixes
	confusion when point is at the end of a line.

2011-02-13  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-inspector-operate-on-point): Don't save the
	point when inspecting a different object.
	(slime-inspector-operate-on-point): If there is no action property
	directly at the point, try looking at (1- (point)), many
	inspectable objects are presented the end of the line, so it's
	easier to navigate to them by C-e and still being able to activate
	it.

2011-02-08  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-choose-overlay-region): Don't use `list' instead
	of `values', GNU Emacs fakes multiple values with lists, but
	XEmacs uses real multiple values.
	Reported by Raymond Toy.

2011-02-04  Helmut Eller  <heller@common-lisp.net>

	Be careful with interning.

	* swank.lisp (find-definitions-for-emacs): Use parse-symbol.

2011-02-04  Helmut Eller  <heller@common-lisp.net>

	Don't double encode results for eval-in-emacs.

	* slime.el (slime-check-eval-in-emacs-result): New.
	(slime-eval-for-lisp): Use it.
	* swank.lisp (unreadable-object): Removed.

2011-02-02  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (eval-in-emacs): Return unreadable results from Emacs
	as an unreadable-object, not as a string.

2011-02-02  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-eval-for-lisp): Return value as a string,
	because it can be unreadable, e.g. #<buffer foo>
	* swank.lisp (eval-in-emacs): Prevent reader errors.

2011-02-02  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (eval-in-emacs): Export it.

2011-01-28  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-check-location-filename-sanity): Guard
	against target-filename being NIL.

2011-01-26  Helmut Eller  <heller@common-lisp.net>

	Allow tail-merging in call-with-bindings.

	* swank.lisp (call-with-bindings): Don't use progv if alist is
	empty alist is empty.

2011-01-20  Stas Boukarev  <stassats@gmail.com>

	* swank-ecl.lisp (+TAGS+): change
	(translate-logical-pathname #P"SYS:TAGS") to
	(merge-pathnames "TAGS" (translate-logical-pathname "SYS:"))
	because of case conversion the former results in a pathname with a
	name "tags", which doesn't exist.

2010-12-10  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-with-popup-buffer): Correct the docstring.

2010-12-09  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-toggle-break-on-signals): New command.
	* swank.lisp (toggle-break-on-signals): The corresponding Lisp code.

2010-12-02  Martin Simmons  <martin@lispworks.com>

	* swank-lispworks.lisp (frame-actual-args): Reimplement to include
	only the values like on other platforms and deal with, optional
	key and rest args.
	(print-frame): Format the frame as a call like in other backends.

2010-11-13  Helmut Eller  <heller@common-lisp.net>

	Improve source locations for compiler messages in Lispworks.

	* swank-lispworks.lisp (map-error-database)
	(signal-error-data-base, make-dspec-progenitor-location): Pass the
	edit-path along.
	(signal-undefined-functions): No edit-path available so just use
	nil.

2010-11-12  Helmut Eller  <heller@common-lisp.net>

	Improve frame-source-location for Lispworks.

	* swank-lispworks.lisp (frame-source-location): Exctract the
	edit-path from the frame and pass it to Emacs.
	(edit-path-to-cmucl-source-path): New function.
	(frame-location): Use it.

	* slime.el (slime-location-offset): Add a :edit-path property.
	(slime-search-edit-path): New function.
	(slime-search-call-site): Fix regexp to match
	zero arg functions.

2010-11-07  Helmut Eller  <heller@common-lisp.net>

	* swank-backend.lisp (label-value-line): Remove display-nil-value.
	And the other stuff too.
	(label-value-line*): Idem.

2010-11-07  Helmut Eller  <heller@common-lisp.net>

	* swank-loader.lisp: ASDF free again.  And proud of it!
	(default-fasl-dir, load-swank): Remove asdf stuff.

2010-11-03  Stas Boukarev  <stassats@gmail.com>

	* swank-loader.lisp (*architecture-features*): Add :arm for CCL
	ARM port.

2010-11-02  Martin Simmons  <martin@lispworks.com>

	* swank-lispworks.lisp (list-callers-internal): Revert to previous
	low level implementation, fixed for LW6.
	(list-callees-internal): Reimplement using low level instead of
	the compiler's xref.

2010-10-23  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-goto-location-position): In case of
	(:function-name name) go to (point-min) before searching for
	function. Remove redundant regexp and regexp-quote function name
	before inserting it into a regexp.

2010-10-21  Helmut Eller  <heller@common-lisp.net>

	In ABCL, try harder to find the source of stack frames.

	* swank-abcl.lisp (source-location): Now a GF.
	(source-location [java-stack-frame]): New.
	(source-location [lisp-stack-frame]): New.
	(source-location [function]): New.
	(frame-source-location, find-definitions): Use them.
	(*source-path*, find-definitions): New.
	(system-property, pathname-parent, pathname-absolute-p)
	(split-string, path-separator, search-path-property)
	(jdk-source-path, class-path, zipfile-contains-p)
	(find-file-in-path): Noise for filename frobbing.

2010-10-21  Helmut Eller  <heller@common-lisp.net>

	Require ABCL 0.22 and remove obsolete conditionalisation.

	* swank-abcl.lisp (call-with-debugger-hook)
	(install-debugger-globally)
	(call-with-debugging-environment, backtrace, print-frame, spawn):
	Remove #+/#- stuff.
	(preferred-communication-style): Return :spawn unconditionally.
	(sys::break): Removed.

2010-10-20  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-connect): Convert the port number read from
	minibuffer to an integer, passing it as a string to
	`make-network-process' isn't portable.
	Patch by Marko Kocic.

2010-10-19  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (invoke-nth-restart): Make sure there is such restart
	before invoking it.

2010-10-19  Stas Boukarev  <stassats@gmail.com>

	* swank-sbcl.lisp (deinit-log-output): Use the right symbol for
	*LOG-OUTPUT*, swank package isn't available at the time
	swank-backend is compiled.

2010-10-16  Stas Boukarev  <stassats@gmail.com>

	* swank-loader.lisp (default-fasl-dir): Guard against using :asdf
	package if it doesn't exist.
	Patch by Anton Vodonosov.

2010-10-16  Attila Lendvai  <attila.lendvai@gmail.com>

	* swank-fuzzy.lisp: speed up by 2-4 times (on sbcl).

	* fuzzy.el: Clean up fuzzy completion's keymap code, drop
	mimic-key-bindings.

	* slime.el: Added separate host and port history for
	slime-connect.
	(slime-lookup-lisp-implementation): better error reporting and
	allow using a functionp to generate the arguments.

	* swank.lisp: Smarten up the label-value-line macros:
	  - support a :label emacs font property
	  - added key args: padding-length, display-nil-value,
	    hide-when-nil, splice-as-ispec, value-text
	  - label-value-line* will evaluate and splice the result
	    of the form after a @ character

	* swank-loader.lisp: Optional integration with ASDF. When ASDF is
	available, store slime fasl's where ASDF would store them. Also
	make sure swank.asd is visible to ASDF.

2010-10-09  Raymond Toy  <toy.raymond@gmail.com>

	* swank-cmucl.lisp (codepoint-length): Implement codepoint-length
	to return the number of codepoints in cmucl's utf-16 strings.

	* swank-backend.lisp (:swank-backend): Export codepoint-length.
	(codepoint-length): definterface codepoint-length.  Default is to
	use LENGTH.

	* swank-rpc.lisp (write-message): Call
	swank-backend:codepoint-length to get the correct length for
	emacs.

2010-10-08  Christophe Rhodes  <csr21@cantab.net>

	Pass more detailed source location information to
	swank:compile-string-for-emacs.  Motivated by R's source location
	needs (where srcrefs are line/column based).

	* slime.el (slime-compile-string): Generate :line location format
	from start-offset, passing it through to
	swank:compile-file-for-emacs.
	(find-definition.2): Use new-style position.

	* swank.lisp (compile-string-for-emacs): Use only the offset from
	the position argument.

	* swank-backend.lisp (swank-compile-string): Fix docstring typo.

2010-10-07  Nikodemus Siivola  <nikodemus@random-state.net>

	Hanging on to a *log-output* from a previous image is bad on SBCL
	at least: it is initialized to an FD-STREAM, which cannot be
	reused from one image to another.

	Deal with this by using sb-ext:*save-hooks* to clear the stream.

	* swank-sbcl.lisp (deinit-log-output): New function.

2010-10-02  Helmut Eller  <heller@common-lisp.net>

	Rename slime-macro/compiler-macro-expand-1 => slime-expand-1

	* slime.el (slime-expand-1): Renamed from
	slime-macro/compiler-macro-expand-1.
	(slime-expand-1-inplace): Renamed from
	slime-macro/compiler-macro-expand-1-inplace.

	* swank.lisp (swank-expand-1): Renamed from
	swank-macro/compiler-macro-expand-1.
	(swank-expand): Renamed from swank-macro/compiler-macro-expand.
	(expand-1): Renamed from macro/compiler-macro-expand-1.
	(expand): Renamed from macro/compiler-macro-expand.

2010-10-01  Helmut Eller  <heller@common-lisp.net>

	Don't use indent-sexp for macroexpanded code.
	indent-sexp is potentially slow and usually redundant.

	* slime.el (slime-initialize-macroexpansion-buffer): Don't use
	indent-sexp.
	(slime-eval-macroexpand-inplace): Avoid indent-sexp but
	use slime-insert-indented.

2010-10-01  Helmut Eller  <heller@common-lisp.net>

	Save result in kill ring for M-- C-x C-e.
	For C-u C-x C-e set mark before inserting.

	* slime.el (slime-eval-save): New function.
	(slime-eval-print): Set mark before inserting.
	(slime-interactive-eval): Use it.

2010-09-22  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (eval-for-emacs): Send (:abort condition) where
	condition is a condition which was aborted instead of just (:abort).
	* slime.el: Handle the above change.

2010-09-22  Stas Boukarev  <stassats@gmail.com>

	* swank-clisp.lisp (*external-format-to-coding-system*): Remove
	stray :latin-1 argument for ext:make-encoding.
	Reported by Mirko Vukovic.

2010-09-20  Stas Boukarev  <stassats@gmail.com>

	* swank-cmucl.lisp (character-completion-set): Implement. Requires
	recent versions of CMUCL.
	Patch by Raymond Toy.

2010-09-18  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (valid-function-name-p): New interface.
	(compiler-macroexpand-1): Use it to guard against type errors
	from COMPILER-MACRO-FUNCTION.

2010-09-18  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (before-init): push :SWANK to *FEATURES*. (lp#627313)

2010-09-18  Tobias C. Rittweiler <tcr@freebits.de>

	Make C-c C-m also expand compiler macros. (lp#638720)

	* slime.el (slime-macro/compiler-macro-expand-1): New.
	(slime-macro/compiler-macro-expand-1-inplace): New.
	(slime-editing-keys): Map `C-c C-m' to first above.
	(slime-compiler-macroexpand-1): Take prefix-arg like others.
	(slime-compiler-macroexpand-1-inplace): Ditto.
	(slime-compiler-macroexpand): Thus deleted.
	(slime-compiler-macroexpand-inplace): Ditto.

	* swank.lisp (swank-macro/compiler-macro-expand-1): New defslimefun.
	(swank-macro/compiler-macro-expand): New defslimefun.
	(macro/compiler-macro-expand-1): New.
	(macro/compiler-macro-expand): New.
	(expand-repeatedly): New helper.

2010-09-03  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-forward-cruft): Use " \t\n" to match whitespaces
	instead of [:space:], XEmacs compatibility.

2010-09-03  Helmut Eller  <heller@common-lisp.net>

	For C-c C-k, ask before loading possibly broken fasl files.

	* slime.el (slime-compilation-result): Add 2 slots: loadp and
	faslfile.
	(slime-compilation-finished): Use them to load the faslfile.
	* swank.lisp (:compilation-result): Add 2 slots. Use keyword
	constructor.
	(compile-file-for-emacs): Return loadp and faslfile to Emacs.
	(collect-notes): Pass loadp and falsfile along.

2010-09-02  Stas Boukarev  <stassats@gmail.com>

	* swank-cmucl.lisp: #-cmu19 -> #+cmu18, cmu18 is allegedly the
	oldest supported CMUCL.

2010-09-01  Stas Boukarev  <stassats@gmail.com>

	* swank-sbcl.lisp (background-save-image): add #-win32, because it
	uses symbols not present on win32.
	Reported by Holly Styles.

2010-08-31  Stas Boukarev  <stassats@gmail.com>

	* swank-cmucl.lisp (foreign-frame-p, gdb-exec, frame-ip): Sparc
	support.
	Patch by Raymond Toy.

2010-08-31  Nikodemus Siivola  <nikodemus@random-state.net>

	* swank-sbcl.lisp (make-dspec): Elide the function name when
	generating a VOP description, since the VOP name is more useful
	and is the first part of the source-description list.

2010-08-28  Stas Boukarev  <stassats@gmail.com>

	* swank-cmucl.lisp (*gdb-program-name*): Determine gdb location
	from PATH.
	(gdb-exec): Use *gdb-program-name* instead of "gdb".
	(gdb-command): Mac OS X compatibility.
	Patch by Raymond Toy.

2010-08-25  Stas Boukarev  <stassats@gmail.com>

	* swank-sbcl.lisp (exec-image): Use (car sb-ext:*posix-argv*) if
	SBCL doesn't have sb-ext:*runtime-pathname*.
	Reported by Vinay.

2010-08-22  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-xemacs-recompute-modelines): Add
	`slime-xemacs-recompute-modelines' to `pre-idle-hook', this solves
	the problem of synchronization of modelines.
	Thanks to Aidan Kehoe.

2010-08-21  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-recompute-modelines): Recompute modelines only
	for visible buffers. Kludge: modeline can be out of sync if the buffer
	becomes visible and no slime/lisp interaction took place yet.
	Patch by Raymond Toy.
	(slime-search-buffer-package): Revert, with the above
	change caching shouldn't be necessary.

2010-08-21  Helmut Eller  <heller@common-lisp.net>

	Add commands to enable/disable contribs.

	* slime.el (slime-enable-contrib, slime-disable-contrib): New.
	(slime-contrib): New struct to collect meta-data about contribs.
	(define-slime-contrib): Store meta-data in 'slime-contribs plist.
	(slime-all-contribs, slime-find-contrib, slime-read-contrib-name):
	New helpers.

2010-08-21  Anton Kovalenko <anton@sw4me.com>

	Snapshot restore support for SBCL.

	* swank-backend.lisp (background-save-image): New.
	* swank-sbcl.lisp (command-line-args, dup, sys-execv, exec-image)
	(make-fd-stream, background-save-image): New.

2010-08-20  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-maybe-complete-as-filename): Limit backward
	search for #\", it slows down on large buffers.
	Reported by Raymond Toy.
	(slime-search-buffer-package): Cache the package, searching every time
	on large buffers may be slow.

2010-08-15  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (setup-server): Check the coding system before doing
	anything, otherwise it may be eaten by ignore-errors later.

2010-08-13  Helmut Eller  <heller@common-lisp.net>

	Find definition for (def-vm-support-routine NAME ...)

	* swank-cmucl.lisp (vm-support-routine-definitions): New.
	(find-definitions): Use it.

2010-08-12  Stas Boukarev  <stassats@gmail.com>

	* swank-sbcl.lisp (save-image): Fix save-lisp-and-die invocation.
	Based on a patch by Anton Kovalenko.

2010-08-11  Helmut Eller  <heller@common-lisp.net>

	Bind *print-readably* to nil when printing the title.

	* swank.lisp (prepare-title): Factored out into new function.
	(*inspector-printer-bindings*)
	(*inspector-verbose-printer-bindings*): New.
	(with-string-stream): New.
	(emacs-inspect/istate): Renamed from emacs-inspect/printer-bindings.

2010-08-06  Stas Boukarev  <stassats@gmail.com>

	* swank-ccl.lisp (spawn): Revert the previous change, using
	:use-standard-initial-bindings nil might be not thread-safe.

2010-08-05  Stas Boukarev  <stassats@gmail.com>

	* swank-ccl.lisp (spawn): Specify
	:use-standard-initial-bindings nil, so that *readtable*
	etc. modifications persist.

2010-08-04  Stas Boukarev  <stassats@gmail.com>

	* swank-allegro.lisp (fspec-definition-locations): Default
	&optional position to 0, otherwise it may cause errors later.
	Reported by: Paulo Madeira.

2010-08-04  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-dispatch-event): :eval-no-wait, lisp sends a
	form in a string, not a function name and arguments. Add
	slime-check-eval-in-emacs-enabled.
	* swank.lisp (defpackage): export eval-for-emacs.

2010-07-30  Helmut Eller  <heller@common-lisp.net>

	Don't get confused by END-OF-FILE on unrelated streams.
	Fixes bug "slime connection broken on trivial condition..."
	Reported by Pascal J. Bourguignon.

	* swank.lisp (end-of-repl-input): New condition.
	(simple-repl, read-non-blocking): Use it.
	* slime.el ([test] end-of-file): Test it.

2010-07-30  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (print-part-to-string): Bind *print-readably* to nil.
	Useful when debugging broken printer methods.

2010-07-22  Vitaly Mayatskikh  <v.mayatskih@gmail.com>

	* swank-lispworks.lisp (list-callers-internal): Fix for LW6.
	(list-callees-internal): New function, use it.

2010-07-21  Stas Boukarev  <stassats@gmail.com>

	* swank-sbcl.lisp (quit-lisp): Use sb-thread:terminate-thread
	instead of sb-ext:quit :recklessly-p t. This way
	sb-ext:*exit-hooks* will be run.
	Reported by Lorenz Msenlechner.

2010-07-06  Helmut Eller  <heller@common-lisp.net>

	Find definition for (%primitive NAME ...)

	* swank-cmucl.lisp (template-definitions, primitive-definitions):
	New functions.
	(find-definitions): Use them.

2010-06-22  Helmut Eller  <heller@common-lisp.net>

	* swank-loader.lisp (*architecture-features*): ECL uses :x86_64.

2010-06-18  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-current-tlf-number,slime-current-form-path):
	Moved to contrib/slime-parse.el.

2010-06-18  Helmut Eller  <heller@common-lisp.net>

	Don't use goto-line.

	* slime.el (slime-goto-line): New function as replacement without
	goto-line's cruft that we don't want.

2010-06-04  Helmut Eller  <heller@common-lisp.net>

	* slime.el, swank.lisp: #'(lambda -> (lambda

2010-06-04 Stelian Ionescu <sionescu@cddr.org>

	* swank.lisp: Move definition of LCONS before first use.

2010-06-04  Helmut Eller  <heller@common-lisp.net>

	* swank-allegro.lisp (socket-fd): Add support for allegro.

2010-06-04  Helmut Eller  <heller@common-lisp.net>

	Some *sldb-quit-restart* related fixes.

	* swank.lisp (*sldb-quit-restart*): Set to nil by default.
	(throw-to-toplevel, debug-in-emacs): Get rid of boundp tests.
	(format-restarts-for-emacs): Add a mark for *sldb-quit-restart*.
	(handle-requests): Always bind *emacs-connection*.
	(with-connection): Get rid of call-with-connection so that
	compilers can remove the call frame more easily.
	(repl-input-stream-read): Factored out from
	make-repl-input-stream.  Bind a *sldb-quit-restart* here too; no
	need to restart the repl and a extra prompt for errors in Emacs
	requests.

2010-05-28  Helmut Eller  <heller@common-lisp.net>

	Fix last change.

	* slime.el (define-slime-contrib): Fix names.
	Remove provide; makes no sense to call provide before file is
	completely loaded.

2010-05-28  Helmut Eller  <heller@common-lisp.net>

	* slime.el (define-slime-contrib): Use destructuring-bind.

2010-05-28  Helmut Eller  <heller@common-lisp.net>

	Move some var-defs before first use.

	* slime.el (slime-show-xref-buffer, slime-read-connection)
	(slime-thread-index-to-id):

2010-05-28  Helmut Eller  <heller@common-lisp.net>

	Move wacky parsing code to contrib.

	* slime.el (slime-extract-context, slime-parse-context)
	(slime-in-expression-p, slime-pattern-path)
	(slime-beginning-of-list, slime-end-of-list)
	(slime-parse-toplevel-form, slime-arglist-specializers)
	(slime-definition-at-point, slime-current-parser-state): Moved to
	contrib/slime-parse.el
	(slime-inspect-definition, slime-disassemble-definition): Moved to
	contrib/slime-fancy-inspector.el

2010-05-27  Helmut Eller  <heller@common-lisp.net>

	* slime.el ([test] interactive-eval): Fix test.

2010-05-27  Helmut Eller  <heller@common-lisp.net>

	* swank-ccl.lisp (socket-fd): Implement backend function.

2010-05-27  Helmut Eller  <heller@common-lisp.net>

	Clean up some of the confusion regarding *sldb-quit-restart*.

	* swank.lisp (top-level-restart-p, *toplevel-restart-available*)
	(coerce-restart): Deleted.
	(with-top-level-restart, simple-repl): Simplify.

2010-05-26  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (swank-error): Unrename from swank-protocol-error.

2010-05-26  Helmut Eller  <heller@common-lisp.net>

	* swank-cmucl.lisp (parse-gdb-line-info): Try working dir first.

2010-05-26  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-defun-if-undefined): Renamed from
	slime-DEFUN-if-undefined. No need to yell.

2010-05-26  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-compile-file): Only send non-nil keyword args.
	(slime-hack-quotes): New function.

2010-05-18  Stas Boukarev  <stassats@gmail.com>

	* slime.el (sldb-insert-condition): Don't create a mouse tooltip
	for long error message, tooltip shows the same text and doesn't
	add any value.
	(slime-definition-at-point): factor out of `slime-inspect-definition'.
	(slime-disassemble-definition): New, similar to
	`slime-inspect-definition'.

	* swank.lisp (disassemble-form): rename from disassemble-symbol,
	do the same as before but evaluate the argument.


2010-05-16  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-close-popup-window): Don't kill
	slime-popup-restore-data local variable in another buffer.

2010-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (define-slime-contrib): New macro.

2010-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (*after-init-hook*, simple-break)
	(coerce-to-condition, use-threads-p, current-thread-id): Moved
	around in swank.lisp.
	(with-temp-package): Deleted; not used anywhere.
	(ensure-list): Use in SWANK-REQUIRE.

2010-05-11  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-inspect-definition): New function,
	inspects definition at point.
	(slime-parse-context): Add :defstruct and :defpackage.

2010-05-10  Mark Evenson  <evenson@panix.com>

	* swank-loader.lisp (*architecture-features*): Add Java platforms
	as features for ABCL.

2010-05-06  Helmut Eller  <heller@common-lisp.net>

	Remove some non-standard file variables.

	* swank-cmucl.lisp, swank-scl.lisp: Remove pbook vars.
	* swank-clisp.lisp: Remove indentation settings. Slime does it
	automatically.

2010-05-05  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-dispatch-event): Fix typo in the previous commit.

2010-05-05  Stas Boukarev  <stassats@gmail.com>

	* Make buffer names more consistent.
	Patch by Leo Liu.

2010-05-05  Helmut Eller  <heller@common-lisp.net>

	* swank-cmucl.lisp (gdb-command): Use gdb's MI.

2010-05-05  Mark Evenson <evenson@panix.com>

	Fix for Cygwin Emacs filename problem.

	* slime.el (slime-init-command): Use slime-to-lisp-filename.

2010-05-05  Helmut Eller  <heller@common-lisp.net>

	* slime.el (sldb-exit): When stepping, close buffer after a delay.
	(sldb-close-step-buffer): New function.

2010-05-01  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-restart-sentinel): Don't pop to the inferior
	buffer, since this command is usually run either from
	*inferior-lisp* buffer or from REPL, it makes sense to reuse
	current window instead of messing up window configuration.
	(slime-move-point): New function, moves point in a buffer and
	its window.

2010-04-29  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-compile-file): Run check-parens after checking
	that the buffer is associated with a file.

2010-04-27  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-info): New function, opens the manual.

2010-04-24  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (format-values-for-echo-area): Also print the length of an
	integer in bits.

2010-04-23  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-update-threads-buffer): Use slime-eval-async.

2010-04-23  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-inspector-buffer): Use slime-with-popup-buffer,
	that solves the problem with keybindings shadowed by slime-mode.
	Reported by Nathan Bird.

	* README: Better wording.

2010-04-22  Stas Boukarev  <stassats@gmail.com>

	* swank-backend.lisp (with-symbol): Test for package before doing
	find-symbol.
	* swank-sbcl.lisp(Multiprocessing): use with-symbol.
	(emacs-inspect t): Remove newlines from text returned by
	sb-impl::inspected-parts, otherwise there will be ".." inserted by
	the printer due to (*print-lines* 1).

2010-04-21  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-open-inspector): Use forward-line instead of
	goto-line, since it doesn't result in  "Mark set" message.
	(slime-inspector-buffer): Enable slime-mode after enabling
	slime-inspector-mode, otherwise the former will be disabled by the
	latter.

2010-04-20  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-sbcl.lisp (condition-timed-wait): New helper. Use
	WITH-DEADLINE rather than WITH-TIMEOUT because the latter conses a
	new timer, and this function is called _a lot_.
	(receive-if): Use it.

2010-04-20  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-update-threads-buffer): Save point position
	on updates.

2010-04-20  Stas Boukarev  <stassats@gmail.com>

	* README: advertise additional contribs, especially slime-fancy.

2010-04-19  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (symbol-classification-string): New function to
	replace (symbol-classification->string (classify-symbol
	symbol)). It's faster and conses much less, while it is called
	many times by fuzzy completion and fancy inspector.
	(symbol-classification->string): Removed.
	(list-threads): Exclude the current thread only if its name is
	"worker".

2010-04-18  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-threads-update-interval): Add :group and :type
	parameters to this customization.
	Thanks to Mark Harig.

2010-04-17  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-threads-update-interval): New customization
	variable, if set to a number the threads buffer will
	updated with this interval.
	(slime-with-popup-buffer): Rename modes option to mode,
	for a major mode. Enabling minor modes from within the body
	doesn't cause troubles. End that way it is compatible with XEmacs
	since it doesn't need to use minor-mode-list to distinguish
	between minor and major modes.

	* swank.lisp (list-threads): Delete the current thread from the
	listing.

2010-04-15  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (sldb-mode): Include some more commands in its help.
	(sldb-goto-last-frame): Do not center to the middle but to the
	bottom of the window.

2010-04-14  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (compile-file-for-emacs): Actually commit the change
	described in 2010-04-12.

2010-04-14  Helmut Eller  <heller@common-lisp.net>

	* slime.el ([test] interrupt-encode-message): New test.

2010-04-14  Helmut Eller  <heller@common-lisp.net>

	Handle errors during interrupt processing with SLDB.
	Bugfix for http://article.gmane.org/gmane.lisp.slime.devel/9641

	* swank.lisp (invoke-or-queue-interrupt): When the queue is full,
	process the interrupt immediately and also handle
	SERIOUS-CONDITIONs during interrupt processing in SLDB.  SLDB
	should work more likely than the interrupted code is expected to
	handle the condition.
	(with-interrupts-enabled%): Don't check for interrupts when
	toggling interrupts off.
	(wait-for-event): Add docstring.

2010-04-14  Helmut Eller  <heller@common-lisp.net>

	Move error handling and logging from swank-rpc.lisp to swank.lisp

	* swank.lisp (log-event, destructure-case, decode-message)
	(encode-message, decode-message, swank-protocol-error): Moved back
	to swank.lisp from swank-rpc.lisp.  It never belonged there
	anyway.

	* swank-rpc.lisp (read-message, write-message): New functions.
	(swank-reader-error): New condition.

2010-04-12  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-doc-bindings): Restore key for slime-apropos.

2010-04-12  Helmut Eller  <heller@common-lisp.net>

	Fix compile-file for various backends.

	* slime.el (slime-compile-file): Only pass non-nil keyword args to
	Lisp.
	(slime-simplify-plist): New helper.
	(slime-compile-and-load-file): Pass policy parameter directly
	without using global variables.

	* swank.lisp (compile-file-for-emacs): Change singature sightly.

2010-04-06  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-create-compilation-log): Enable
	compilation-mode, which was enabled previously by
	slime-insert-compilation-log.

2010-04-05  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-doc-bindings): Move slime-apropos to C-c C-d A,
	C-c C-d a will be bound to slime-autodoc-manually.

	* doc/slime.texi: Document the above change.

2010-04-05  Stas Boukarev  <stassats@gmail.com>

	* slime.el: Some further adaptations to the new
	slime-with-popup-buffer.

2010-04-04  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-insert-threads): Use header-line-format only when
	it's present (XEmacs doesn't support it).

2010-04-04  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-with-popup-buffer): Make &optional parameters
	&key parameters, add modes parameter.
	slime-with-popup-buffer sets up some buffer local variables,
	but enabling major modes kills all buffer locals, so modes should
	be enabled before setting them.
	Adopt changes to slime-with-popup-buffer where needed.
	This fixes several bugs with popup buffers on non-default connections.

2010-04-03  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-update-threads-buffer): New formatting, with labels
	and additional information provided by the backend.
	* swank-allegro.lisp (thread-attributes): Move process-priority from
	thread-status.

2010-03-29  Helmut Eller  <heller@common-lisp.net>

	* slime.el: Add gud as compile-time dependency.

2010-03-29  Helmut Eller  <heller@common-lisp.net>

	Compile swank-sbcl-exts only for SBCL.

	* swank-loader.lisp (*contribs*): Add #+sbcl.

2010-03-29  Helmut Eller  <heller@common-lisp.net>

	Minor cleanups

	* swank.lisp (connection): Make socket-io read-only again.
	(*connections*): Move declaration before first use.
	(finish-connection-setup): Merged into make-connection.
	(accept-connections): Renamed from serve-connection and
	reorganized so that the socket-io slot can be read-only.
	(accept-authenticated-connection): Renamed to authenticate-client.
	Update callers accordingly.

2010-03-29  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (connection-info): Use princ-to-string rather than
	prin1-to-string as the latter may barf if *print-readably* is nil.

2010-03-27  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-check-location-buffer-name-sanity): Less duplication,
	reuse slime-check-location-filename-sanity.
	(slime-check-location-filename-sanity): Do any work only when
	slime-warn-when-possibly-tricked-by-M-. is non-nil.

2010-03-21  Stas Boukarev  <stassats@gmail.com>

	* start-swank.lisp: Document options to swank-loader:init.

	* doc/slime.texi (Miscellaneous): mention
	`sldb-break-with-system-debugger'.

2010-03-21  Stas Boukarev  <stassats@gmail.com>

	* start-swank.lisp: New file for starting swank by simply loading
	sbcl --load start-swank.lisp

2010-03-19  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-lisp-implementation-program): New connection
	variable.
	(slime-set-connection-info): Adapted to set it.
	(slime-attach-gdb): Use it to invoke gdb so gdb is able to find
	debugging symbols on non-Linux platforms.

	* swank.lisp (connection-info): Include lisp-implementation-program.

	* swank-backend.lisp (lisp-implementation-program): New interface.
	Default implementation based on command-line-args.

	* swank-ecl.lisp (command-line-args): Implement.

2010-03-18  Tobias C. Rittweiler <tcr@freebits.de>

	Remove attach-gdb restart. Instead add SLDB shortcut `A'.

	* slime.el (slime-dispatch-event): Remove :gdb-attach.
	(slime-attach-gdb): Changed API. Takes connection not pid now and
	lightweight &optional arg. If not lightweight, get the default gdb
	config from the inferior Lisp.
	(sldb-break-with-system-debugger): New command, bound to `A' in
	sldb. Called this way to mimick
	`sldb-break-with-default-debugger', and because it may make sense
	to go beyond gdb in future, e.g. to invoke the Java Debugger for
	ABCL.

	* swank.lisp (call-with-gdb-restart, with-gdb-restart): Removed.
	(with-top-level-restart): Remove use of with-gdb-restart.
	(make-connection, start-server, create-server, setup-server):
	Remove inferior-lisp flag again. Not needed anymore.

2010-03-18  Tobias C. Rittweiler <tcr@freebits.de>

	Add M-x slime-attach-gdb as an interactive function.

	The ATTACH-GDB restart is nice because it's convenient and the
	backends can specify customized gdb configuration.

	Sometimes, if the Lisp is too screwed up, going over a restart
	involving the SWANK middle layer may not be possible. For that, a
	manual M-x slime-attach-gdb may come in handy.

	* slime.el (slime-read-connection): New helper.
	(slime-attach-gdb): Use it. Make it an interactive function.

2010-03-18  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (call-with-gdb-restart): Forgot to remove trailing T.

2010-03-18  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (open-dedicated-output-stream): Forgot to rename
	accept-authenticated-connection to accept-authenticated-client
	here.

2010-03-18  Tobias C. Rittweiler <tcr@freebits.de>

	Add an ATTACH-GDB restart to SLDB.

	* swank.lisp (call-with-gdb-restart): New. Sends the new
	:gdb-attach event to Emacs.
	(with-gdb-restart): Sugar.
	(with-top-level-restart): Also expand to with-gdb-restart.
	(dispatch-event): Add :gdb-attach event.

	* swank-backend.lisp (gdb-initial-commands): New interface
	function so backends can customize how gdb needs to be configured
	for their implementation.

	* swank-ecl.lisp (gdb-initial-commands): Implement.

	* slime.el (slime-dispatch-event): Add clause for :gdb-attach.
	(slime-attach-gdb): New.

2010-03-18  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (connection): Add socket slot, make socket-io slot
	not be required to be filled in during object creation. Add
	inferior-lisp slot so we can know whether a connection belongs to
	a superior Emacs process. Need for that will come in following
	commit.
	(make-connection): Our constructor.
	(create-connection): Removed; not needed anymore.
	(finish-connection-setup): Function to fill socket-io slot.
	(start-server): Results in inferior-lisp slot being T.
	(create-server): Results in inferior-lisp slot being NIL.
	(setup-server): Adapted accordingly. Construct connection early so
	we do not have to pass down all the meta information explicitly.
	(serve-connection): Adapted accordingly.
	(accept-authenticated-client): Renamed from
	accept-authenticated-connection.
	(dispatch-event): Get rid of unused :%apply and :end-of-stream
	events.

2010-03-16  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-ecl.lisp (source-location): Also return EXT::FOO as
	candidate to search through the TAGS file because SI and EXT both
	name the same package, and in ECL's code base, sometimes the
	former, sometimes the latter is used.

2010-03-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (signal-interrupt): Removed.
	(interrupt-worker-thread): Slurp in definition of
	signal-interrupt. No need for invoke-or-queue-interrupt twice in
	case we do not use threads. Thus micro-prettification of
	backtraces.

2010-03-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-ecl.lisp (source-location): Move call to
	TRANSLATE-LOGICAL-PATHNAME from here into MAKE-FILE-LOCATION
	because locations-via-annotations may now also involve logical
	pathnames.

2010-03-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-ecl.lisp (*original-sigint-handler*)
	(install-sigint-handler): Deleted; we directly implement
	call-with-user-break-handler instead.
	(call-with-user-break-handler): New. Correctly interrupt main
	thread instead of newly spawned handle-signal thread on SIGINT.
	(make-interrupt-handler): New helper.

2010-03-09  Stas Boukarev  <stassats@gmail.com>

	* swank-ccl.lisp (emacs-inspect function): Print closed over variables
	in case of closure.

2010-03-09  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-parse-context): Add defclass.

2010-03-09  Helmut Eller  <heller@common-lisp.net>

	Some more fixes for Allegro

	* swank-allegro.lisp (function-source-location): Use
	xref::object-to-function-name which seems to work better for some
	cases.
	(fspec-definition-locations): For :top-level-forms return a list
	of ((fspec loc)) not just (fspec loc).  Also deal with the file
	vs. buffer issue.
	(ldb-code-to-src-loc): Don't use *temp-file-map* before it is
	declared.
	(pc-source-location): Be a bit more fuzzy when searching the
	code-location for a pc.

2010-03-08  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-extract-context): Add defvar and defparameter.

2010-03-08  Helmut Eller  <heller@common-lisp.net>

	Fix some of the brokeness in the last change.

	* swank-allegro.lisp (frame-source-location): Deal with frames for
	undefined functions better.
	(ldb-code-to-src-loc): Handle temp-files properly.

2010-03-08  Helmut Eller  <heller@common-lisp.net>

	Try to use source-level debugging features in Allegro 8.2

	* swank-allegro.lisp (disassemble-frame): Use undocumented
	debugger::dyn-fd-analyze to figure out the PC and display it.
	(pc-source-location, ldb-code-to-src-loc, longest-common-prefix)
	(source-paths-of): New functions.
	(frame-source-location): Use pc-source-location.  Still far from
	optimal since Allegro rarely records source regions and anonymous
	functions don't seem to carry source level debug-info at all.
	(*temp-file-map*, buffer-or-file-location, find-fspec-location):
	Use a table to map temp-file names back to Emacs buffers instead
	of putting an eval-when-compile form in the source.  The
	eval-when-compile form messed up source positions.
	(*temp-file-header-end-position*, find-definition-in-buffer):
	Deleted.
	(compile-from-temp-file): Bind excl:*load-source-debug-info* and
	compiler:save-source-level-debug-info-switch so that Allegro
	doesn't try to load debug-info from deleted files.  Also put
	the filename in *temp-file-map*.

2010-03-08  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (dispatch-interrupt-event): Take a connection because
	it boils down to SIGNAL-INTERRUPT which uses USE-THREADS-P which
	needs a connection.
	(install-fd-handler): Adapted accordingly.
	(simple-serve-requests): Adapted accordingly. Additionally, remove
	superfluous WITH-SWANK-PROTOCOL-HANDLER as that's established by
	WITH-CONNECTION already.
	(simple-repl): Show "abort inferior lisp" restart only if not a
	more appropriate "abort some REX" restart is available. Also make
	sure to return in case of END-OF-FILE, otherwise there's an
	infinite loop where we end up in the debugger again and again
	until the user eventually selects close-connection restart himself.
	(make-repl-input-stream): Use WITH-TOP-LEVEL-RESTART so
	`sldb-quit' can be used in SLDB.

2010-03-08  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (close-connection): Include initially passed
	coding-system in debugging output.

2010-03-08  Tobias C. Rittweiler <tcr@freebits.de>

	Make swank:connection-info include information about initially
	passed coding-system, and the resulting external-format of the
	socket. Debugging aid.

	* swank.lisp (connection.external-format): New function.
	(start-server, create-server): Pass down coding-system, not
	external-format.
	(setup-server): Pass down both, coding-system and external-format.
	(serve-connection): Ditto.
	(create-connection): Set coding-system slot of CONNECTION.
	(connection-info): Include coding-system and external-format.

2010-03-07  Helmut Eller  <heller@common-lisp.net>

	* swank-allegro.lisp (count-cr): Deleted.  No longer used.

2010-03-07  Helmut Eller  <heller@common-lisp.net>

	Handle src-locs of compiler warnings in Allegro 8.2.
	Didn't somebody already fix that?

	* swank-allegro.lisp (location-for-warning)
	(handle-undefined-functions-warning): In 8.2 src-locs include not
	only start but also and end positions.

2010-03-07  Stas Boukarev  <stassats@gmail.com>

	* swank-ecl.lisp (source-location): Don't do
	(setq file (tmpfile-to-buffer file)) in a COND condition,
	otherwise next cond clause will get null file.
	Apply translate-logical-pathname to pathnames.

2010-03-05  Helmut Eller  <heller@common-lisp.net>

	Remove some unused stuff.

	* swank-ccl.lisp (openmcl-set-debug-switches)
	(*interesting-internal-frames*)
	(interesting-frame-p): Unused. Deleted.

2010-03-05  Helmut Eller  <heller@common-lisp.net>

	* swank-ccl.lisp: Indentation fixes.

2010-03-05  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-ecl.lisp: Make backend depend on ECL version 10.3.1 which
	just got released. We do not support older versions. Previous
	version pretty much didn't work in combination with Slime anyway.

2010-03-05  Tobias C. Rittweiler <tcr@freebits.de>

	Ecl: Make M-. work on function interactively compiled via C-c C-c.

	* swank-ecl.lisp (*tmpfile-map*, note-buffer-tmpfile)
	(tmpfile-to-buffer): New helpers.
	(swank-compile-string): Use them. Also use new COMPILE-FILE
	keywords :SOURCE-TRUENAME and :SOURCE-OFFSET available in ECL
	HEAD.
	(find-definitions): Slurp in definition of
	FIND-DEFINITIONS-BY-NAME.
	(find-definitions-by-name): Hence not needed anymore.
	(source-location): Use TMPFILE-TO-BUFFER to get buffer source
	location of interactively compiled functions.

2010-03-04  Mark Evenson  <evenson@panix.com>

	* swank-abcl.lisp (emacs-inspect): Define default method to use
	the result of SYS:INSPECTED-PARTS if non-nil.

2010-03-03  Stas Boukarev  <stassats@gmail.com>

	* doc/slime.texi (Inspector): document slime-inspector-eval.
	Patch by Mark Harig.

2010-03-03  Helmut Eller  <heller@common-lisp.net>

	Don't special case special operators with M-. for CMUCL.

	* swank-cmucl.lisp (function-definitions): Special operators will
	have IR1-translators anyway, so no need to mark them "special".
	(gf-definitions): Renamed from generic-function-definitions.

2010-03-03  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-inspector-history): New command.

2010-03-03  Helmut Eller  <heller@common-lisp.net>

	Don't try to bind keywords in inspector-eval.

	* swank.lisp (inspector-eval): For now, don't bind symbols which
	are constantp.  Maybe something better can be found later.

2010-03-03  Helmut Eller  <heller@common-lisp.net>

	Use @ instead of # to mark object in the inspect history.

	* swank.lisp (print-part-to-string): Use @.

2010-03-03  Helmut Eller  <heller@common-lisp.net>

	Make eval-in-frame display multiple values; not only the first.

	* swank.lisp (values-to-string): New macro.
	(eval-string-in-frame): Use it.

2010-03-02  Stas Boukarev  <stassats@gmail.com>

	* swank-sbcl.lisp (definition-source-for-emacs): Don't error when
	source location doesn't contain form position, point emacs to the
	beginning of a source file and if it's a function provide a
	snippet "(defun <name> ".

2010-03-02  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-compile-and-load-file): Accept C-u arguments for
	compilation policy the same way as slime-compile-defun.

	* swank.lisp (compile-file-for-emacs): Take an additional policy
	argument.
	* swank-backend.lisp (swank-compile-file): Ditto.

	* swank-sbcl.lisp (compiler-policy, (setf compiler-policy)):
	rename from get/set-compiler-policy.
	(with-compiler-policy): New macro.
	(swank-compile-file): Use with-compiler-policy.
	(swank-compile-string): Ditto.

	* doc/slime.texi (Compilation): Update.

2010-03-01  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (documentation-symbol): Show arglists for functions too.

2010-03-01  Tobias C. Rittweiler <tcr@freebits.de>

	Fix that annoying bug that caused being constantly asked to switch
	connection in case one had multiple connections running and quit
	from one.

	* slime.el (slime-modeline-string): Bail out early because
	`slime-current-package' involves `slime-connection' in case the
	slime-repl contrib is used, and querying the user in a
	periodically called function is rather annoying..

2010-02-26  Stas Boukarev  <stassats@gmail.com>

	* swank-loader.lisp (ecl-version-string): Check length of
	the result of ext:lisp-implementation-vcs-id before doing subseq.
	On CVS it returns "unknown".

2010-02-25  Stas Boukarev  <stassats@gmail.com>

	* swank-loader.lisp (ecl-version-string): In
	#+(or) (progn #+#.(cl:print cl:nil) 1) PRINT does run on SBCL, which
	breaks #+#.(cl:if (cl:find-symbol "SYMBOL" :ext) ...) here,
	guard it with
	(find-package :ext) until further investigations.

2010-02-25  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-loader.lisp (lisp-version-string): Add git-commit ids for
	ECL because individual commits do not guarantee fasl
	compatibility.

2010-02-23  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (when-let): New macro. For backends and
	swank.lisp.

	* swank-ecl.lisp: Use it. Also use new location support of ECL git
	HEAD.

2010-02-23  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-postprocess-xref): Show a TAGS entry's hints as
	part of an Xref's dspec for the case of multiple matches.

2010-02-23  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-ecl.lisp (preferred-communication-style): Go back to
	NIL. Some parts (like the compiler and CLOS) of ECL do not seem to
	be thread-safe yet. Also get rid of non-working implementation of
	:FD-HANDLER.
	(poll-streams, wait-for-input): Implement on top of select() for
	communication-style=NIL.
	(*descriptor-handlers*, add-fd-handler, remove-fd-handlers): Get
	rid of.
	(grovel-docstring-for-arglist): Get rid of it, too.
	(arglist): ECL now provides an extra accessor to a function's
	arglist. Use that instead.
	(emacs-inspect): Get rid of the default method. Don't see its
	point.

2010-02-22  Tobias C. Rittweiler <tcr@freebits.de>

	Make swank-ecl.lisp work with latest ECL Git HEAD.

	* swank-ecl.lisp (assert-TAGS-file): Simplified.
	(assert-source-directory): New helper.
	(c-function-p): New helper.
	(c-function): Type based on above.
	(source-location): Move bits from FIND-DEFINITIONS-FOR-TYPE to
	this function. Use CONVERTING-ERRORS-TO-ERROR-LOCATION.
	(find-definitions-for-type): Simplified by using it.

2010-02-22  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (converting-errors-to-error-location): Moved
	here from swank-sbcl.lisp so other backends can make use of it, too.

	* swank-sbcl.lisp: The above macro was called slightly
	differently, so update uses accordingly.

2010-02-22  Tobias C. Rittweiler <tcr@freebits.de>

	Make M-. be able to jump right into the C source for ECL.

	Because it's based on TAGS files, M-. and M-* will DTRT once in a
	.c file.

	* swank-ecl.lisp (assert-TAGS-file): New helper.
	(classify-definition-name): Ditto.
	(find-definitions-for-type): Ditto. Understands Lisp and C
	functions.
	(find-definitions): Use them.
	(source-location): New helper. Extracted from FIND-SOURCE-LOCATION.
	(find-source-location): Use it.
	(swank-compile-string): Only try to delete temporary files if they
	exist.

2010-02-22  Tobias C. Rittweiler <tcr@freebits.de>

	Make it possible for SWANK backends to specify locations based on
	a TAGS file.

	* slime.el (slime-postprocess-xref, slime-postprocess-xrefs): New
	functions. They convert TAGS based locations from SWANK into
	file+position based locations because the rest of Slime expects
	and works with those.
	(slime-find-definitions): Call slime-postprocess-xrefs.
	(slime-xref): Ditto.
	(slime-etags-to-locations): The function which does the actual
	conversion. Extracted from `slime-etags-definitions'.
	(slime-etags-definitions): Use it.

	* swank-backend (defimplementation): Add implicit BLOCK.
	(:etags-file, :tag): Mentioned for possible values in :LOCATION.

2010-02-20  Tobias C. Rittweiler <tcr@freebits.de>

	More work on ECL's swank-backend.

	* swank-ecl.lisp (accept-connection): Handle :buffering, and
	:external-format.
	(external-format): New helper.
	(find-external-format): Make sure to only return :default in case
	ECL was built with --disable-unicode; it'll barf on anything else.
	(socket-fd): Add two-way-stream case due to recent changes in ECL.
	(make-file-location, make-buffer-location): New helpers.
	(condition-location): Use them.
	(swank-compile-file): Handle :external-format.
	(compile-from-stream): Deleted. Slurped into swank-compile-string.
	(swank-compile-string): Call SI:MKSTEMP correctly. Make sure to
	also remove fasl file, not just source file.
	(grovel-docstring-for-arglist): Do not look at "Syntax:" entry in
	docstring because that was a kludge. Upstream ECL should be
	modified instead.
	(in-swank-package-p, is-swank-source-p, is-ignorable-fun-p):
	Commented out. They make debugging ECL's swank-backend harder.

2010-02-20  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-loader.lisp (*architecture-features*): Add :PENTIUM3 and
	:PENTIUM4; they're used by ECL.
	(handle-swank-load-error): Renamed from HANDLE-LOADTIME-ERROR. Use
	*FASL-DIRECTORY* rather than (DEFAULT-FASL-DIR). Parametrize
	context to differentiate b/w compilation/loading.
	(compile-files): Adapted accordingly. Also make sure that an error
	is signaled in case COMPILE-FILE returns NIL as primary result.

2010-02-20  Stas Boukarev  <stassats@gmail.com>

	* swank-ccl.lisp: Remove outdated comment at the beginning
	since it may be misleading.

	* slime.el: In minor-mode-alist for slime-popup-buffer-mode,
	run slime-modeline-string only if slime-mode isn't active, because
	slime-mode runs slime-modeline-string from minor-mode-alist too
	resulting in duplicate modeline strings.
	Reported by Leo Liu.

2010-02-18  Mark Harig <idirectscm@aim.com>

	The compiler warns about various stuff. Fix some of it.

	* slime.el (slime-add-local-hook): Remove support for Emacs 20.
	(sldb-recenter-region): Use forward-line; not next-line.

2010-02-17  Helmut Eller  <heller@common-lisp.net>

	Add a command to eval stuff in the inspector.

	* slime.el (slime-inspector-eval): New command.
	(slime-inspector-mode-map): Bind it to 'e'.
	* swank.lisp (inspector-eval): New function.
	* swank-backend.lisp (eval-context): New function.
	* swank-cmucl.lisp (eval-context): Implement it.

2010-02-17  Helmut Eller  <heller@common-lisp.net>

	Point-entered hooks in the xref buffer don't work so well.
	Use forward/backward commands instead.

	* slime.el (slime-xref-next-line, slime-xref-prev-line): New
	commands.
	(slime-xref-show-location): New aux function.
	(slime-xref-mode-map): Remap up/down to next/prev location
	commands.  Make SPC and RET do the same.

2010-02-17  Helmut Eller  <heller@common-lisp.net>

	Select the xref buffer.
	I never could get used to the next/prev cycling.

	* slime.el (slime-with-xref-buffer): Select the buffer.
	(slime-insert-xrefs): Add point-entered hook to automatically
	display the current location.
	(slime-xref-entered): New function.
	(slime-show-buffer-position): Don't use reposition-window which
	seems very slow and doesn't even do a particularly good job.  The
	new heuristic is much cruder but faster.
	(slime-xref-mode-map): Remove apparently redundant bindings for
	RET.

2010-02-17  Helmut Eller  <heller@common-lisp.net>

	Get rid or snapshots.

	* slime.el (slime-narrowing-configuration, slime-emacs-snapshot)
	(slime-current-narrowing-configuration)
	(slime-set-narrowing-configuration, slime-current-emacs-snapshot)
	(slime-set-emacs-snapshot)
	(slime-current-emacs-snapshot-fingerprint, slime-frame-windows):
	Deleted.  Update call-sites accordingly.

2010-02-17  Helmut Eller  <heller@common-lisp.net>

	Test suite hangs for CCL and CMUCL.

	* slime.el ([test] compile-defun): Remove those compile-time read
	errors for which some implementations invoke the debugger.
	(sexp-at-point.1): Remove failing tests

2010-02-16  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-loader.lisp: Compile files on ECL, too.

2010-02-16  Tobias C. Rittweiler <tcr@freebits.de>

	Pimp my swank.

	* swank-ecl.lisp: We depend on ECL 10.2.1 which is not released
	yet -- you need git/cvs HEAD. Added :spawn, and :fd-handler as
	communication-style (Thanks to Ram Krishnan), improve compilation
	hooks so highligting of warnings works, + various cleanup.

2010-02-15  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-load-contribs): Do not call SWANK-REQUIRE
	asynchronously, if host Lisp uses :SPAWN that may result in the
	attempt to load in code concurrently -- the host Lisp may not
	support that.

2010-02-14  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-attempt-connection): Fix typo. Thanks to Mark
	Harig for spotting it.

2010-02-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-attempt-connection): Do not keep on trying to
	connect if inferior process died.

2010-02-07  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-ecl.lisp: Update threading code. ECL doesn't still work
	with :spawn, though. Work in progress.

2010-02-07  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (xref-doit): Declare eql-specializing parameter
	ignorable, as some implementations complain about them not being
	used.

2010-02-01  Mark Harig <idirectscm@aim.com>

	* slime.el: Added missing pieces to make `slime-cycle-connections'
	available from keystrokes.
	(slime-prefix-bindings): Added "\C-xn" entry.
	(slime-cycle-connections): Corrected grammar in doc string.
	(def-slime-selector-method): Added menu item `n' to SLIME selector
	menu.

	* doc/slime.texi: Added a description for the new key sequence for
	`slime-cycle-connections' and for the new menu item in the SLIME
	selector menu.
	Node slime-selector: Added menu item `n' and cross-references to
	"Multiple Connections" node.
	Node Multiple connections: Added C-c C-x n description.  Added
	cross-references to `slime-selector' node.

2010-01-31  Tobias C. Rittweiler <tcr@freebits.de>

	* hyperspec.el: When using C-c C-d ~ TAB, previously there were
	entries for "C" and "C: Character", which unpleasingly crowded the
	completion buffer, so I made it show one entry ("C - Character")
	only. RIP, erik.

2010-01-30  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-cycle-connections): Change docstring, it
	doesn't make connection buffer-local.
	* doc/slime.texi (Multiple connections): document
	slime-cycle-connections.

	* swank.lisp (pathname-as-directory): Treat "/foo/bar" and "/foo/bar/"
	the same.
	(compile-file-output): Use the above function.

2010-01-28  Mark Evenson  <evenson@dada.local>

	* swank-abcl.lisp (emacs-inspect): Make inspection of Java objects
	toString() results dependent on explicit user request to avoid
	potentially computationally expensive operations.

2010-01-27  Stas Boukarev  <stassats@gmail.com>

	* swank-rpc.lisp: NIL -> nil (for unusual readtable settings).
	Spotted by Harald Hanche-Olsen.

2010-01-26  Mark Evenson  <evenson@dada.local>

	* swank-abcl.lisp: Import
	MOP::COMPUTE-APPLICABLE-METHODS-USING-CLASSES if it exists in the
	ABCL implementation.

2010-01-25  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-allegro.lisp (redefinition-p, redefinition): New.
	(handle-compiler-warning): Add :severity for redefinitions,
	style-warnings, errors.

2010-01-21  Stas Boukarev  <stassats@gmail.com>

	* swank-ccl.lisp (with-frame): Put this macro before it's used.

2010-01-20  Terje Norderhaug <terje@in-progress.com>

	* swank.lisp (with-swank-protocol-error-handler): Refactor using
	safe-backtrace.
	* swank-rpc.lisp (make-swank-protocol-error): Delete call to
	swank:safe-backtrace to eliminate dependency on swank.lisp module.
	* swank-rpc.lisp (swank-protocol-error): Remove
	swank-protocol-error.backtrace as the capture of a safe-backtrace
	is covered by with-swank-protocol-error-handler.

2010-01-20  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-thread-kill): If the region is active, then
	kill all threads in the region.

2010-01-19  Stas Boukarev  <stassats@gmail.com>

	* swank-rpc.lisp (:swank-rpc): (:use :cl), SBCL
	doesn't use it by default.

2010-01-19  Terje Norderhaug  <terje@in-progress.com>

	* Refactorized parts of swank.lisp into a new swank-rpc module.

2010-01-14  Stas Boukarev  <stassats@gmail.com>

	* doc/slime.texi (Setting up the lisp image):
	(swank-loader:init) is also needed for loading swank.
	Reported by Evgeny Bahvalov.

2010-01-13  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (*swank-state-stack*): Delete. Not needed anymore.
	(defslimefun state-stack): Delete.
	(decode-message): Adapted.
	(debug-in-emacs): Adapted.

2010-01-11  Mark Evenson  <evenson@dada.local>

	* swank-abcl.lisp (emacs-inspect): Implementation for Java
	objects.

	Fix compiler warning about *ABCL-SIGNALED-CONDITIONS*.

2010-01-06  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend (declaration-arglist): Normalize declaration
	specifiers to contain `variables' rather than `vars'.

2010-01-05  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-sbcl.lisp (compiler-note-location): Add missing return-from.

2010-01-05  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (compile-defun [test]): Add two cases.

2010-01-05  Cecil Westerhof  <Cecil@decebal.nl>

	* slime.texi (inferior-slime-mode): Fix thinko.

2010-01-05  Terje Norderhaug  <terje@in-progress.com>

	Provide default implementation for all-threads.

	* swank-backend.lisp (all-threads): Just return ().

2010-01-05  Helmut Eller  <heller@common-lisp.net>

	Fix M-. bug related to CMUCL's multi-file compilation units.

	* swank-cmucl.lisp (code-location-stream-position): Require the
	"root-number" as argument and subtract it from the TLF number.
	(location-in-file): Pass the root number along.
	(code-location-string-offset): Use 0 as root number.

2010-01-05  Helmut Eller  <heller@common-lisp.net>

	Slightly better error message when CMUCL fails to find defstructs.

	* swank-cmucl.lisp (struct-constructor, setf-definitions): Don't
	use COERCE which gives confusing error message.

2010-01-05  Helmut Eller  <heller@common-lisp.net>

	Add "quit" and "other window prefix" buffer selectors.

	* slime.el (slime-selector-other-window): New variable.
	(slime-selector): Bind it as need.
	(def-slime-selector-method): Use the other window if so indicated.
	([selector] 4): New key binding.
	([selector] q): New key binding. just abort.

2010-01-05  Helmut Eller  <heller@common-lisp.net>

	Stop the beeping on restart.

	* slime.el (slime-quit-lisp-internal): Don't kill already dead
	processes.

2010-01-03  Stas Boukarev  <stassats@gmail.com>

	* swank-backend.lisp (frame-call): New function.
	Returns a string representing a call to the entry point of a frame.
	* swank-ccl.lisp (frame-call): Implementation of the above.
	* swank-sbcl.lisp (frame-call): Ditto.

2010-01-03  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (with-swank-protocol-error-handler): Remove debugging
	bits.

2010-01-03  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-next-read-or-lose): Call `debug' with the error
	condition, so we can see what actually caused the losage.

2010-01-03  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (compile-defun [test]): Also test proper notification
	after reader-error. Additionally: bind font-lock-verbose to nil to
	prevent annoying font-lock messages during the test.

	* swank-sbcl.lisp (signal-compiler-condition): Make sure
	READER-ERROR comes before ERROR in typecase.
	(swank-compile-file): Remove handling FATAL-COMPILER-HANDLER
	because a) this handling prevents sbcl from printing the
	diagnostics to the repl, and b) sbcl itself should handle this and
	translate it into proper return value for compile-file.

2009-12-23  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (complete-symbol [test]): Fix test case.

2009-12-22  Helmut Eller  <heller@common-lisp.net>

	Some new backend functions used for loading image files.

	* swank-backend.lisp (socket-fd, make-fd-stream, dup, exec-image)
	(command-line-args): New functions.
	* swank-cmucl.lisp: Impemented.
	* swank-cmucl.lisp (reset-sigio-handlers): New function.
	(save-image): Fix quoting bug.

	* swank.lisp (clear-event-history): New functoin.
	(interactive-eval, eval-region): Don't use FRESH-LINE.

2009-12-21  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-at-list-p): Deleted.
	(slime-at-expression-p): Moved to slime-package-fu.
	(slime-forward-blanks): Deleted. Use `(skip-chars-forward
	"[:space:]")' instead.
	(slime-forward-any-comment): Deleted.
	(slime-reader-conditionals-regexp): Make a constant so it's
	inlined.
	(slime-unknown-feature-expression): Make it an error.

2009-12-19  Stas Boukarev  <stassats@gmail.com>

	* swank-backend.lisp (defpackage): export with-symbol and
	replace its fully qualified usage everywhere.

2009-12-17  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-edit-uses-xrefs): New variable. For contribs to
	extend.
	(slime-edit-uses): Use it.

	* swank.lisp (xref-doit): Now a generic functions. For contribs to
	extend.

2009-12-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (with-top-level-restart): Bind local special.
	(top-level-restart-p): Check for it; this tells us if we're in
	the dynamic extent of with-top-level-restart.
	(handle-requests): Use it.

2009-12-17  Stas Boukarev  <stassats@gmail.com>

	* swank-match.lisp: Fix formatting and style warnings.

2009-12-17  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (handle-requests): Comment out
	(assert (boundp '*sldb-quit-restart*)) because it's not bound
	on NIL communication style. It's not a real fix, but at least it
	lets null communication-style work.

2009-12-16  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-sbcl.lisp (categorize-definition-source): New.
	(definition-source-for-emacs): Use it. Slightly
	refactored. Renamed from `make-definition-source-location'.
	(find-definitions, find-source-location)
	(source-location-for-xref-data, function-dspec): Updated
	accordingly.
	(source-file-position): Scratch last argument, not needed anymore.

2009-12-16  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (compile-file-output): Use
	(make-pathname :directory dir :defaults (compile-file-pathname file))
	instead of (compile-file-pathname file :output-file dir),
	because the latter works differently on different implementations.
	(fasl-pathname): Use the above function.

2009-12-16  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (*sldb-quit-restart*): Export. For users to customize
	what `q' does in SLDB.
	(handle-requests): Test differently for recursive invocations
	as *sldb-quit-restart* may now be globally bound due to user
	customization.
	(coerce-restart): Coerces a restart-designator to a restart.
	(throw-to-toplevel): Use it.

	* slime.texi (swank:*sldb-quit-restart*): Document it.

2009-12-15  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (collect-notes): Establish new abort restart ("Abort
	Compilation"); if an error is signaled in EVAL-WHEN, or during
	macroexpansion -- assuming the backend DTRT --, invoking this
	restart will result in the normal compilation failure behaviour,
	including correct reporting of the offending toplevel form.

	* swank-sbcl.lisp (handle-notification-condition): Use
	`real-condition' here.
	(handle-file-compiler-termination): As a result, not needed anymore.
	(call-with-compilation-hooks): Also signal information about
	normal errors.

2009-12-14  Stas Boukarev  <stassats@gmail.com>

	* doc/slime.texi (ASDF): Document new commands.

2009-12-12  Matthias Koeppe  <mkoeppe@math.ucdavis.edu>

	* doc/slime.texi (Presentations): Add an example that illustrates
	quoting necessary with presentations that are lists.

2009-12-11  Stas Boukarev  <stassats@gmail.com>

	* swank-allegro.lisp: Use new function `make-error-location'.
	(find-fspec-location): Handle errors.
	Patch by Tobias C. Rittweiler.

2009-12-11  Tobias C. Rittweiler <tcr@freebits.de>

	Add `M-x slime-toggle-debug-on-swank-error'.

	In "Debug on SWANK error" mode, errors which are normally caught
	to not annoy the user, will now drop into the debugger.

	Additionally, the backend won't do any backtrace magic so you'll
	see the full backtrace with all its glory details. (SBCL only so
	far.)

	* slime.el (slime-toggle-debug-on-swank-error): New.

	* swank.lisp (toggle-debug-on-swank-error): New slimefun.
	(debug-on-swank-error): New function. SETFable.
	(invoke-default-debugger): Use CALL-WITH-DEBUGGER-HOOK so we're
	trapped into the native debugger on SBCL (previously we weren't
	due to SB-EXT:*INVOKE-DEBUGGER-HOOK*.)

	* swank.lisp: Rename SWANK-ERROR to SWANK-PROTOCOL-ERROR.

2009-12-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-sbcl.lisp (call-with-debugger-hook): Oops, removed the
	binding for *DEBUGGER-HOOK*. Fix that.
	(make-invoke-debugger-hook): Do nothing if hook is NIL.

2009-12-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (*debug-swank-backend*): New variable. If
	true, backends should not catch internal errors (e.g. during
	definition finding), and should not perform backtrace magic.
	(make-error-location): New helper.
	(find-definitions [interface]): Default to error location.

	* swank-sbcl.lisp (converting-errors-to-location): New helper
	macro. Regards new *DEBUG-SWANK-BACKEND*.
	(find-definitions [implementation]): Use it.
	(find-source-location [implementation]): Ditto.
	(functiond-spec): Ditto.
	(frame-source-location [implementation]): Ditto.
	(*debug-definition-finding*): Removed.
	(make-source-location-specification): Removed.
	(safe-function-source-location): Removed.
	(safe-source-location-for-emacs): Removed. Not needed anymore.

	(call-with-debugging-environment): Do not perform stack hinting
	depending on *DEBUG-SWANK-BACKEND*.

2009-12-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-sbcl.lisp (set-break-hook): New.
	(call-with-break-hook): New, too. Both extracted from elsewhere.
	(install-debugger-globally, call-with-debugger-hook): Use them.
	(make-invoke-debugger-hook): Adapted not to call *debugger-hook*
	on its own; it should rather decline because *debugger-hook* is
	tried after *invoke-debugger-hook* anyway. Previously, a
	custom *debugger-hook* (which declines itself) would have been
	executed twice.

2009-12-07  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-parse-toplevel-form): Use
	`slime-region-for-defun-at-point' instead of `beginning-of-defun'.

2009-12-03  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-documentation-lookup-function): New hook,
	defaults to `slime-hyperspec-lookup'.
	(slime-documentation-lookup): Invoke hook.
	(slime-prefix-bindings): Bind `C-c C-d h' to it.

2009-12-02  Stas Boukarev  <stassats@gmail.com>

	* swank-sbcl.lisp (frame-locals): `frame-debug-vars' can return NIL,
	so check before using it as a vector.
	Patch by Nathan Bird.

2009-11-30  Helmut Eller  <heller@common-lisp.net>

	Add a slime-editing-map as suggested by Attila Lendvai.  The main
	purpose is to create a keymap that's shared by the REPL and other
	modes so that adding custom bindings gets a bit easier.

	* slime.el (slime-editing-map, slime-mode-indirect-map): New variables.
	(slime-init-keymaps): Clear out any existing bindings before
	building the new keymaps.
	(slime-init-keymap): New helper.
	(slime-bind-keys): Renamed&extended from
	slime-define-both-key-bindings.

	* slime.el (slime-editing-mode): New minor mode for use
	in the REPL.

2009-11-26  Mark Evenson  <evenson@panix.com>

	* swank-abcl.lisp (arglist):  Fixes for functions with non-nil
	arglist and for generic functions with empty argument lists.

	Diagnosed and cured by Matthias Hlzl.

2009-11-23  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-set-connection-info): Set slime-current-thread to t
	before doing anything. Solves a bug reported by Slawek Zak.

2009-11-21  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-sbcl.lisp (who-specializes): Implement.
	Requires SBCL 1.0.32.

2009-11-19  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-minibuffer-map): Nee `slime-read-expression-map'
	(slime-minibuffer-history): Nee `slime-read-expression-history'
	(slime-minibuffer-setup-hook): Extracted.
	(slime-read-from-minibuffer): Adapted accordingly.

2009-11-13  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (classify-symbol): Check fbound before calling
	fdefinition, ECL doesn't like (fdefinition nil).

	* swank-ecl.lisp
	(swank-mop:compute-applicable-methods-using-classes): Add a dummy
	function. ECL doesn't have it, but some contribs are using it.
	Patch by Andy Hefner.

2009-11-13  Stas Boukarev  <stassats@gmail.com>

	* swank-ecl.lisp (function-name): Use clos:generic-function-name
	for generic functions.
	(arglist): Check fro symbol before calling special-operator-p and
	macro-function.
	Patch by Andy Hefner.

2009-11-06  Stas Boukarev  <stassats@gmail.com>

	* swank-ecl.lisp (grovel-docstring-for-arglist): ECL's arglists
	for macros include macro name at the first place, unlike arglists
	for functions. cdr arglists only for macros and special operators.
	Reported by Andy Hefner.
	(find-source-location): Missing comma before error message formatting.
	Patch by Andy Hefner.

2009-11-05  Tobias C. Rittweiler <tcr@freebits.de>

	Make C-c C-c operate on region if mark is active (and Transient
	Mark mode is enabled.)

	* slime.el (slime-compile-defun): Operate on region if
	transient-mark-mode is active.

2009-11-03  Helmut Eller  <heller@common-lisp.net>

	Ask gdb for source lines of foreign functions.

	* swank-cmucl.lisp (frame-source-location): Handle foreign
	frames with gdb.
	(frame-ip): Handle bogus frames (on x86)
	(disassemble-frame): Use gdb for foreign frames.
	(foreign-frame-p, foreign-frame-source-location): New functions.
	(gdb-command, gdb-exec, parse-gdb-line-info, read-word)
	(whitespacep, with-temporary-file, call/temporary-file): New
	helpers.

2009-11-03  Stas Boukarev  <stassats@gmail.com>

	* slime.el (sldb-setup): Do (set-syntax-table lisp-mode-syntax-table)
	otherwise functions used by autodoc do not work properly.

2009-11-03  Stas Boukarev  <stassats@gmail.com>

	* slime.el (sldb-backward-frame): If the point is at the end of
	the buffer, there is no property, handle this case.

	* swank.lisp (collect-notes): LOAD returns generalized boolean,
	not just boolean, but make-compilation-result accepts only booleans
	for its second argument.

	Both bugs reported by Derrell Piper.

2009-11-02  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-end-of-symbol): Make sure not to move on #'foo.
	([test] sexp-at-point.1): New test case.

2009-11-02  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (without-interrupts): Removed. No longer used.
	* swank-backend.lisp (call-without-interrupts): Removed.
	Update backends accoringly.

2009-11-02  Helmut Eller  <heller@common-lisp.net>

	CCL's lap-functions don't have source-notes but the name often
	has.  E.g. ccl::%fixnum-truncate.  Use names as last resort.

	* swank-ccl.lisp (function-name-source-note): New function.
	(pc-source-location): Use it.

2009-11-02  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (tokenize-symbol-thoroughly): Return NIL
	instead of throwing an error.
	(parse-symbol): Handle null result of tokenize-symbol-thoroughly.

	This fixes a bug reported by Derrell Piper.

2009-10-31  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-bug): Deleted.

2009-10-31  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-inside-string-p, slime-inside-comment-p)
	(slime-inside-string-or-comment-p): New.

	* swank-match.lisp: New file. Contains very simple pattern matcher
	from the CMU AI archive.

	* swank-loader.lisp: Compile swank-match.lisp.

	* swank.lisp: Make SWANK package use new SWANK-MATCH package.

2009-10-31  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (find-symbol-with-status): New.
	(parse-symbol): Use it to correctly parse symbols where only one
	colon is given. Consequences: Autodoc won't display an arglist on
	`(foo:bar |' if BAR is not exported from FOO.

2009-10-31  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (list-threads): Remove thread-description.  Wasn't
	used anymore.
	* swank-backend.lisp (thread-description, set-thread-description):
	Deleted.
	* swank-abcl.lisp: Update accordingly.
	* slime.el (slime-update-threads-buffer, slime-thread-insert):
	Update accordingly.

2009-10-31  Helmut Eller  <heller@common-lisp.net>

	* swank-ccl.lisp (kill-thread): Don't signal conditions.
	* swank-backend.lisp (kill-thread): Update docstring.

2009-10-30  Stas Boukarev  <stassats@gmail.com>

	* swank-loader.lisp (setup): Use EXT:PROBE-DIRECTORY on Clisp,
	because PROBE-FILE doesn't want to work on directories.
	Patch by Dirk Sondermann.

2009-10-30  Helmut Eller  <heller@common-lisp.net>

	* swank-openmcl.lisp: Removed. 1.4 is out so no longer needed.
	* swank-ccl.lisp: Update accordingly.

	* test-all.sh: Removed. Not used in ages.

2009-10-28  Helmut Eller  <heller@common-lisp.net>

	Simpler modeline code.

	* slime.el (slime-modeline-string): Renamed from
	slime-compute-modeline-string.
	(slime-modeline-state-string): Renamed from
	slime-compute-connection-state
	(slime-modeline-package, slime-modeline-connection-name)
	(slime-modeline-connection-state)
	(slime-extended-modeline,slime-compute-modeline-package)
	(slime-update-modeline-string, slime-shall-we-update-modeline-p)
	(slime-update-all-modelines, slime-modeline-update-timer)
	(slime-restart-or-init-modeline-update-timer)
	(slime-connection-state-as-string): Deleted
	(slime-stale-connection-p): Deleted.

2009-10-28  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-disconnect): Don't reference connection.  Left
	over from last change.
	([test] arglist): Update expected results for slightly changed
	printer settings.
	([test] indentation): Install common-lisp-indent-function.
	([undefun] display-warning): Fix it.

	* test.sh: Don't copy contribs. Slime should work without them.
	* swank-loader.lisp (setup): Compile contribs only if directory
	exists.

2009-10-28  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-format-display-message, slime-display-message)
	(slime-create-message-window): Deleted.  The trick with the
	pre-command-hook doesn't work in XEmacs 21.5.  So use the standard
	message function.  One day XEmacs will learn how to resize the
	minibuffer, but until then we have to live with one-line messages.

2009-10-27  Helmut Eller  <heller@common-lisp.net>

	* slime.el: Fix some docstrings and comments.

2009-10-26  Tobias C. Rittweiler <tcr@freebits.de>

	* test.sh: Shebang on bash, not just on sh.

2009-10-25  Tobias C. Rittweiler <tcr@freebits.de>

	Revert the reversed numbering of restarts in sldb.

	New command `sldb-cycle' ([tab]) in sldb will cycle between
	restart list and backtrace.

	Make sldb-invoke-restart-by-name case-insensitive.

	* slime.el (sldb-mode-map): Bind Tab to `sldb-cycle'.
	(sldb-restart-list-start-marker): New variable.
	(sldb-setup): Store marker in it.
	(sldb-cycle): New command to cycle between restart list and
	backtrace.
	(sldb-invoke-restart-by-name): Make completion case-insensitive.
	(sldb-insert-restarts): Revert to old behaviour.

2009-10-24  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-ccl.lisp (who-specializes): Do not signal an error if
	argument does not name a class.

2009-10-24  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (xref): Deal with non-yet-interned names gracefully.

2009-10-24  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-search-property): Add parameter to get value at
	point propery changed.
	(slime-find-next-note): Use it.
	(slime-find-previous-note): Ditto.

2009-10-24  Tobias C. Rittweiler <tcr@freebits.de>

	New command C-M-, to go to previous xref location.

	[Old command C-M-. to go to next xref location.]

	Xref buffers are not automatically selected anymore; it's more
	ergonomic to cycle through them via C-M-. and C-M-, from
	within the source buffer.

	* slime.el (slime-search-property): Simplify slightly.
	(slime-find-next-note): Use it.
	(slime-find-previous-note): Use it, too.
	(slime-find-note): Deleted.
	(slime-editing-keys): Add C-M-,.
	(slime-previous-location-function): New variable.
	(slime-previous-location): New command.
	(slime-with-xref-buffer): Do not select Xref buffer.
	(slime-show-xref-buffer): Adapted accordingly.
	(slime-goto-next-xref): Highlight current item on C-M-. and C-M-,.
	(slime-goto-previous-xref): New.
	(slime-highlight-sexp): Renamed from `sldb-highlight-sexp'.
	(slime-highlight-line): New.

2009-10-24  Helmut Eller  <heller@common-lisp.net>

	* slime.el (sldb-insert-restarts): Insert the proper numbers for
	the --more-- button.
	(sldb-restart-number-at-point): Rename back to
	sldb-restart-at-point.  Don't use
	confisingly-verbose-names-for-no-good-reason.
	(sldb-restart-number-for-swank): Deleted.

2009-10-23  Tobias C. Rittweiler <tcr@freebits.de>

	Restarts in SLDB are now numbered reversely. The rationale is that
	always-existing restarts are likely to be associated with the same
	number now.

	* slime.el (sldb-insert-restarts): Number restart reversely.
	(sldb-restart-number-for-swank): New; recompute the unreversed
	number for the swank side.
	(sldb-restart-number-at-point): Previously `sldb-restart-at-point'.
	(sldb-invoke-restart): Adapted accordingly.

2009-10-23  Tobias C. Rittweiler <tcr@freebits.de>

	When ever Slime seems to get stuck (e.g. after some character
	encoding confusion), `M-x slime-reset' should hopefully bring it
	into a functional state again.

	* slime.el (slime-reset): Erase connection buffer.

2009-10-21  Tobias C. Rittweiler <tcr@freebits.de>

	Make M-x slime-changelog-date work.

	* slime.el (slime-changelog-date): Make the function be callable
	interactively.

2009-10-21  Stas Boukarev  <stassats@gmail.com>

	* doc/slime.texi (ASDF): Document new commands.

2009-10-20  Martin Simmons  <martin@lispworks.com>

	* swank-lispworks.lisp (call-without-interrupts): Discourage use.
	(interesting-frame-p): Never show open frame bogons.

2009-10-19  Stas Boukarev  <stassats@gmail.com>

	* swank-sbcl.lisp (thread-description): Remove it and supporting code,
	because it didn't really work.

	* swank.lisp (with-thread-description): Remove unused macro.

	* slime.el (slime-list-threads): Update information before
	setting the mode, otherwise it messes up current connection.

	* doc/slime.texi: fix typo.

2009-10-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (without-printing-errors): New macro.
	(to-string): Use it.
	(to-line): Use it, too. This fixes printing error occuring during
	inspecting to prevent the inspector from displaying something
	useful.

	Reported by xristos@suspicious.org.

2009-10-15  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-current-package): Move REPL stuff to contrib.

2009-10-15  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-current-package): Return REPL's package,
	if other are unavailable and if slime-repl is loaded.

2009-10-12  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Update copyright.

2009-10-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-length=): Fix (slime-length= '() 0).
	(slime-eval-feature-expression): Fix. Couldn't handle (NOT)
	and (NOT FOO BAR).

2009-10-09  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (stop-server): (list-threads) returns threads offset by 1,
	don't kill the wrong thread.

2009-10-06  Stas Boukarev  <stassats@gmail.com>

	* swank-ccl.lisp (map-backtrace): Handle null end-frame-number
	argument.

2009-09-28  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (set-package): Provide a more meaningful error
	message when package doesn't exist.

	* swank-lispworks.lisp (replace-strings-with-symbols): Didn't work on
	non-proper lists. Reported by Madhu.

2009-09-27  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-sbcl.lisp (call-with-debugger-hook): Correctly deal with
	case of HOOK being NIL.
	(make-definition-source-location): Somewhat simplified.
	(string-path-snippet): Removed, not needed anymore.

2009-09-24  Stas Boukarev  <stassats@gmail.com>

	* swank-sbcl.lisp (swank-compile-string): Ignore unused variable
	warningsp.

2009-09-23  Helmut Eller  <heller@common-lisp.net>

	* swank-sbcl.lisp (receive-if): Bind *break-on-signals* to
	nil before using with-timeout.

2009-09-22  Helmut Eller  <heller@common-lisp.net>

	* swank-ccl.lisp (find-definitions): For fbound symbols also
	consider source-notes in the function object.  Useful if
	the function slot was set with (setf (symbol-function ..))
	and not by defun.

2009-09-21  Stas Boukarev  <stassats@gmail.com>

	* doc/slime.texi (slime-sprof): document slime-sprof contrib.

2009-09-20  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-abcl.lisp (thread-description): Fix typo.
	(set-thread-description): Ditto.

2009-09-20  Tobias C. Rittweiler <tcr@freebits.de>

	Generalize M-? (or M-_ respectively.)

	It will now list:

	  - call sites for functions,

	  - macroexpand sites for macros,

	  - binding, setting, referencing sites for variables,

	  - specializing methods for classes.

	* slime.el (slime-xref): Deal with :not-implemented.
	(slime-xrefs): New. Makes RPC request to XREFS.
	(slime-edit-callers): Renamed to `slime-edit-uses'.
	(slime-edit-uses): Use slime-xrefs.

	* swank-backend.lisp (who-*): Add default implementation which
	returns :not-implemented.

	* swank.lisp (xref-doit): Extracted from XREF.
	(xref): Pass over :not-implemented to Emacs side.
	(xrefs): New slime fun. To return results of multiple XREF
	requests at once.

2009-09-20  Mark Evenson  <evenson@panix.com>

	Use *INVOKE-DEBUGGER-HOOK* introduced in ABCL by analogy to SBCL
	 (Tobias Rittweiler).

	* swank-abcl.lisp (sys::break): Conditionally redefine SYS::BREAK
	only if SYS::INVOKE-DEUBBGER-HOOK is not present.

2009-09-18  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-parent-bindings): Define M-? as
	`slime-edit-callers', too. My previous choice of M-_ was warped
	due to my German layout.

2009-09-18  Tobias C. Rittweiler <tcr@freebits.de>

	New binding: M-_ (`slime-edit-callers').

	Similiar to `slime-who-calls' but only creates an Xref buffer if
	needed for disambiguation, and also pushes to the definition
	stack.

	Spiritually like M-. but works "in the other direction".

	* slime.el (sllime-edit-callers): New function. Cross between
	`slime-who-calls' and `slime-edit-definition'.
	(slime-parent-bindings): Define M-_ as `slime-edit-callers'.
	(slime-pop-xref-buffer): New helper. Extracted from
	`slime-show-xrefs'.
	(slime-show-xrefs): Use it.
	(slime-xref): Let callers specify a continuation.

2009-09-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-abcl.lisp (sys::break): Fix typo.
	(slot-definition-documentation, slot-definition-type)
	(class-prototype, generic-function-declarations)
	(specializers-direct-methods, slot-boundp-using-class)
	(slot-value-using-class): Add IGNORE declarations. Compiling
	swank-abcl.lisp is now free of warnings.
	(swank-compile-file): Load the compiled file even though warnings
	were signalled during compilation.

2009-09-17  Mark Evenson  <evenson@panix.com>

	* swank-abcl.lisp (source-location): Emacs buffers start at 1,
	whereas CL files start at 0 (Tobias Rittweiler).

2009-09-16  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (documentation-symbol): Return more readable information.

2009-09-14  Mark Evenson  <evenson@panix.com>

	* swank-abcl.lisp (source-location): Fix typo.

2009-09-12  Mark Evenson  <evenson@panix.com>

	Provided by Alan Ruttenberg.

	* swank-abcl.lisp (source-location): Make edit definition work.

	* swank-abcl.lisp (arglist): Now works with generic functions.


2009-09-08  Helmut Eller  <heller@common-lisp.net>

	* swank-loader.lisp (lisp-version-string): Include "-ics" for
	version with extended charsets.  Suggested by Scott L. Burson.

2009-09-03  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-net-close): set-process-query-on-exit-flag
	doesn't exist in XEmacs.
	(slime-make-net-buffer): For now, disable querying here.
	Could also close the socket before killing the buffer.
	(slime-buffer-processes): Deleted.

2009-09-02  Stas Boukarev  <stassats@gmail.com>

	* swank-lispworks.lisp (replace-strings-with-symbols): New function for
	recursively interning and replacing strings in a list.
	(arglist): Replace all strings in arglists with symbols.

	* slime.el (slime-net-close): Do not query for process killing
	confirmation before killing a connection buffer.
	(slime-buffer-processes): New function for listing processes
	associated with a buffer.

2009-08-31  Helmut Eller  <heller@common-lisp.net>

	Don't advice ccl::break-loop.
	Should not be necessary as we can now use ccl:*break-hook*.

	* swank-ccl.lisp ([advice] ccl::break-loop): Deleted.

2009-08-31  Helmut Eller  <heller@common-lisp.net>

	Keep note overlays in a global variable.
	That's simpler and cheaper than scanning all buffers.

	* slime.el (slime-note-overlays): New variable.
	(slime-make-note-overlay, slime-remove-old-overlays): Use it.

2009-08-27  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-remove-old-overlays): delete notes at the very
	beginning of the buffer too. Thanks to Nick Levine.

2009-08-22  Helmut Eller  <heller@common-lisp.net>

	Speed up symbol completion.

	* swank.lisp (all-completions): Don't call unparse-symbol
	while matching.  That gets very slow in CCL's CCL package.
	Just use symbol-name and compare with char-equal.
	(prefix-match-p): Use char-equal.

2009-08-21  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-transcript-start-hook)
	(slime-transcript-stop-hook): New hooks.
	(slime-eval-with-transcript): Use them.
	(slime-eval-with-transcript-cont): Deleted.

2009-08-19  Mark Evenson  <evenson@panix.com>

	* swank-abcl.lisp: Accommodate the new Java/Lisp stack frame
	abstraction in the upcoming abcl-0.16. (based on code from Tobias
	Rittweiler).

2009-08-18  Mark Evenson  <evenson@panix.com>

	Add multithreading code for abcl-0.16. (Tobias Rittweiler)

	* swank-abcl.lisp: A multithread implementation taking advantage
	of the new synchronization primitives in abcl-0.16.

	Restore working with abcl-0.15.

	* swank-abcl.lisp: Remove the warm initialization code for
	SWANK:COMPILER-CONDITION, as it is no longer needed for the
	current release of ABCL.

2009-08-16  StanisBaw Halik <sthalik@test123.ltd.pl>

	* swank.lisp (init-global-stream-redirection): Continue even if
	streams are already redirected.  Useful for restarting Swank with
	M-x slime when a REPL is already present.  Will most likeley
	mess up the input stream in multi threaded setups, tho.

2009-08-15  Helmut Eller  <heller@common-lisp.net>

	XEmacs fixes.

	* slime.el (slime-editing-keys): Use (kbd "C-M-.") because XEmacs
	translates [?\C-\M-.] to C-M-n.
	(next-single-char-property-change)
	(previous-single-char-property-change): Use
	next-single-property-change because next-char-property-change gets
	embarrisingly slow in XEmacs in font-locked buffers.
	It never felt that slow in Emacs 20 though.

2009-08-15  Helmut Eller  <heller@common-lisp.net>

	* swank-ccl.lisp (definition-name): Special case methods.

	* slime.el (slime-choose-overlay-region): Don't return zero length
	regions for :eof.
	(slime-show-buffer-position): The second argument to
	display-buffer means something completely different in
	XEmacs. Don't use it.
	(slime-severity-face): Handle :redefinition.
	(slime-temporarily-highlight-note): Use a timer instead of the
	post-command-hook.

2009-08-13  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-auto-select-connection, slime-auto-connect):
	Turn them into customizable variables.

2009-08-11  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-sbcl.lisp (swank-compile-string): Make sure that it
	returns NIL on compilation failure.

2009-08-10  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-insert-note-group): Factored out from
	slime-insert-compilation-log.
	(slime-goto-location-position): Can't use goto-line.

2009-08-10  Helmut Eller  <heller@common-lisp.net>
	Separate context info from compiler message text.

	* swank-backend.lisp (compiler-condition): Add a new slot
	:source-context.  Remove :short-message.
	* swank-cmucl.lisp, swank-sbcl.lisp, swank-scl.lisp,
	swank-openmcl.lisp, swank-ccl.lisp: Update callers.
	* swank.lisp (make-compiler-note): Use source-context slot.
	* slime.el (slime-note.source-context): New.
	(slime-insert-compilation-log): Use it.
	(slime-note.short-message): Deleted.

2009-08-10  Helmut Eller  <heller@common-lisp.net>

	Don't add linebreaks for one-line messages.

	(slime-insert-block): New function.
	(slime-insert-compilation-log): Use it.
	(slime-indent-rigidly): Use insert-before-markers, otherwise point
	ends up at before a bunch of inserted spaces.

2009-08-10  Helmut Eller  <heller@common-lisp.net>

	Various compilation related changes.

	* slime.el (slime-show-note-counts): Don't show 0 values.
	(slime-severity<): New function.
	(slime-maybe-show-compilation-log): Always create the log buffer
	but display it only if the compilation failed.
	(slime-insert-compilation-log): Disable the stupidly inefficient
	font-lock-after-change-function.
	(slime-canonicalized-location-to-string): Use relative filenames.
	(slime-goto-location-buffer): Disable warnings about symlinks.

2009-08-09  Tobias C. Rittweiler  <tcr@freebits.de>

	Make C-x ` work again.

	M-n and C-x ` are now very similiar; but the former operates
	relative to point in the source buffer, while the latter works
	relative to the compilation log.

	* slime.el (slime-insert-compilation-log): No do set
	`compilation-skip-to-next-location'.

2009-08-09  Tobias C. Rittweiler  <tcr@freebits.de>

	M-n/M-p in .lisp buffers do not show the note in the minibuffer
	anymore if a compilation log is displayed to the user.

	In the compilation log, sort and group the notes by line/column
	number.

	* slime.el (slime-insert-compilation-log): Sort the notes by their
	line/column numbers; group notes of same location and display them
	as one entry.
	(slime-compilation-loc): Removed.
	(slime-canonicalized-location),
	(slime-canonicalized-location-to-string): Extracted from
	`slime-compilation-loc'.
	(slime-group-and-sort-notes): Does the sorting/grouping.
	(slime-show-note): Do not show note in minibuffer if compilation
	log is displayed to the user.

2009-08-09  Stas Boukarev  <stassats@gmail.com>

	* swank.asd (asdf:perform): don't call `swank-loader:init' with
	:setup nil, because it doesn't get contribs compiled, and some other
	configuration steps are omitted.

	* slime.el (slime-profile-by-substring): new function for profiling
	functions by matching a substring.

	* swank.lisp (profile-by-substring): ditto.

2009-08-08  Tobias C. Rittweiler  <tcr@freebits.de>

	M-n / M-p in a .lisp buffer now also jump to the respective note
	in the compilation-log buffer if one is currently displayed to the
	user.

	* slime.el (slime-remove-old-overlays): Simplified.
	(slime-insert-compilation-log): Add a note-overlay for each note
	so we can find the right one when user uses M-n/M-p in .lisp
	buffer.
	(slime-goto-note-in-compilation-log): New.
	(slime-make-note-overlay): Extracted from
	`slime-create-note-overlay'.
	(slime-next-note, slime-previous-note): Simplified.
	(slime-show-note): Goto note in compilation-log if available.
	(slime-note-overlay-p): Call overlay property `slime-note', not
	just `slime'.
	(slime-find-note): Likewise; also returns the overlay if found.
	(slime-show-buffer-position): Optionally recenter position to the
	top of the window.

2009-08-04  Stas Boukarev  <stassats@gmail.com>

	* swank-sbcl.lisp (signal-compiler-condition): read
	sb-kernel:redefinition-warning only if it exists.
	Some older SBCLs don't have it (particularly included in the
	stable Debian).

2009-08-02  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-backend.lisp (severity [type]): Allow :redefinition.

	* swank-sbcl.lisp (signal-compiler-condition): Tag redefinitions.

	* slime.el (slime-maybe-show-compilation-log): Do not show
	compilation log if each note describes just a redefinition.
	(slime-insert-compilation-log): Insert notes indented by 2
	spaces. Insert some more newlines so the buffer appears more
	structured.
	(slime-show-note-counts): Add :redefinition to ecase.
	(slime-redefinition-note-p): New.
	(slime-severity-label): Was unused. Adapted to be usable.

2009-07-30  Stas Boukarev  <stassats@gmail.com>

	* doc/slime.texi (Setting up pathname translations): add that it is
	in the `slime-tramp' contrib.

2009-07-30  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-clisp.lisp: Clisp 2.48 experimentally supports threads. So
	add infrastructure to use threads in Clisp's swank backend. We do
	not make it the default, because it's not prime time yet. There
	are still problems with GC, weak-pointers, and thread objects.

2009-07-28  Stas Boukarev  <stassats@gmail.com>

	* doc/slime.texi (slime-selector): mention t and c keys.

2009-07-27  Stas Boukarev  <stassats@gmail.com>

	* swank-ccl.lisp (source-note-to-source-location): keys of
	*temp-file-map* are pathnames, not namestrings; convert
	namestrings to pathnames before looking up.

2009-07-27  Geo Carncross  <geocar@gmail.com>

	* swank-ecl.lisp: Support for older ECL installs
	from patch by Mark Evenson

2009-07-26  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-maybe-show-compilation-log): New function.
	(slime-compilation-finished-hook): Use it.  Now that the
	compilation buffer gets not selected it's more acceptable to
	display it more often.
	(slime-insert-compilation-log): Set compilation-skip-threshold to
	0 and compilation-skip-to-next-location to nil.  Seems to work
	better for us.
	(slime-with-popup-buffer): Synch window-point, otherwise it be at
	the end of the buffer for reused buffers.
	(slime-display-popup-buffer): Return the window.

2009-07-26  Helmut Eller  <heller@common-lisp.net>

	* swank-sbcl.lisp (tempnam): Muffle efficiency notes.

2009-07-26  Gail Zacharias <gz@clozure.com>

	* swank-ccl.lisp: New file.  An updated version of
	swank-openmcl.lisp in preparation for a slew of changes to CCL and
	to honor the new name.

	* swank-loader.lisp (*sysdep-files*): Use it.

2009-07-21  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-sexp-at-point-for-macroexpansion): use markers
	for bounds, because in some situations text layout could be modified
	before bounds would be used, for example, using keyboard macros.

2009-07-15  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-inspector-fetch-all): new command, bound to >
	in the inspector buffer.

	* doc/slime.texi (Frame Navigation): add description
	of `sldb-end-of-backtrace' and `sldb-beginning-of-backtrace'.
	(Inspector): add `slime-inspector-fetch-all'.


2009-07-12  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-editing-keys): Don't override M-*. The default
	binding should do what Matthias wants.

2009-07-11  Matthias Koeppe  <mkoeppe@math.ucdavis.edu>

	* swank-backend.lisp (definterface): Fix typo in error message.

2009-07-11  Stas Boukarev  <stassats@gmail.com>

	* doc/Makefile (clean): Remove bash extensions. Patch by
	Teemu Likonen.

2009-07-06  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-ecl.lisp (find-external-format): Copied from
	swank-sbcl.lisp. A lot of backends seem to share the same
	implementation, perhaps some refactoring is needed.

2009-07-06  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank.lisp (make-repl-input-stream): Make sure to redirect
	output from slime requests to the REPL buffer for
	communication-style=NIL.

2009-07-02  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-beginning-of-symbol): Limit searching to 2000
	characters.

2009-07-02  Terje Norderhaug <terje@in-progress.com>

	* swank-lispworks.lisp (thread-attributes): Implemented.

2009-07-02  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (ed-in-emacs): Handle symbols/function-names better.
	* slime.el (slime-ed): Updated accordingly.

2009-07-02  Terje Norderhaug <terje@in-progress.com>

	* swank.lisp (operator-arglist): Don't use pprint-fill
	for people with wide screens.

2009-07-02  Stas Boukarev  <stassats@gmail.com>

	* slime.el (slime-net-coding-system): make it customizable.
	(slime-inspector-operate-on-click): Make --more-- button in
	the inspector clickable.

2009-06-30  Geo Carncross  <geocar@gmail.com>

	* swank-ecl.lisp: Package profiling support

2009-06-30  Stas Boukarev  <stassats@gmail.com>

	* swank-openmcl.lisp (arglist): Return :not-available if the arglist
	cannot be obtained. Patch by Terje Norderhaug.

2009-06-29  Stas Boukarev  <stassats@gmail.com>

	* swank.lisp (open-streams): do not create unnecessary output stream
	when using dedicated output stream. Thanks to Terje Norderhaug.

2009-06-28  Terje Norderhaug <terje@in-progress.com>

	Generalize list-threads for implementation-dependent attributes.

	* swank-backend.lisp (thread-attributes): New function.
	* swank-openmcl (thread-attributes): Implement it.
	* swank.lisp (list-threads): Return a table with the attribute
	names as the first row and the new attributes in the last columns.
	* slime.el (slime-update-threads-buffer): For now, ignore the
	extra attributes.

2009-06-28  Stelian Ionescu <stelian.ionescu-zeus@poste.it>

	* slime.el (slime-compiler-macroexpand-inplace)
	(slime-compiler-macroexpand-1-inplace): New commands.
	(slime-macroexpansion-minor-mode-map): Bind them.

2009-06-28  Helmut Eller  <heller@common-lisp.net>

	* swank-sbcl.lisp (add-fd-handler): Avoid recursive invocation
	of the handler, e.g. when read-sequence blocks.

2009-06-28  Stas Boukarev  <stassats@gmail.com>

	* swank-openmcl.lisp (compiler-warning-short-message): In new
	versions of CCL `compiler-warning-nrefs' slot
	of the `compiler-warning' class is now a list, not an integer.

2009-06-25  Geo Carncross  <geocar@gmail.com>

	* swank-ecl.lisp: Profiling support by Marko Koci?

2009-06-27  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-beginning-of-symbol): Skip over #., #-, and #+.
	([test] symbol-at-point.15 .. 17): Test it.

2009-06-24  Nikodemus Siivola <nikodemus@random-state.net>

	Add :WAIT keyword argument to support blocking in
	SWANK:INSPECT-IN-EMACS.

	* swank.lisp (inspect-in-emacs): added keyword argument :wait.

	* slime.el (slime-dispatch-event): if swank requests response to
	:inspect, add a hook to the inspector to signal swank once done.
	(slime-open-inspector): add optional hook argument to be added as
	local kill-buffer-hook.

2009-06-21  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-initialize-lisp-buffer-for-test-suite): Moved to
	contrib/slime-fontifying-fu.el

2009-06-21  Helmut Eller  <heller@common-lisp.net>

	Don't try so hard to get symbol-at-point right.
	The old implementation was complicated and didn't even pass it's
	own test suite.  The new version is less ambitious but simpler.

	* slime.el (slime-symbol-at-point, slime-beginning-of-symbol)
	(slime-end-of-symbol): Simplify.
	(slime-exit-vertical-bars, slime-symbol-constituent-at): Deleted.
	([test] symbol-at-point.1 .. symbol-at-point.14): Renamed form
	fancy-symbol-names and split up into smaller peices.
	(slime-test-symbols): New.
	(slime-check-symbol-at-point): Renamed from
	slime-check-fancy-symbol-name.

2009-06-21  Helmut Eller  <heller@common-lisp.net>

	* swank-backend.lisp (frame-source-location): Renamed from
	frame-source-location-for-emacs.

2009-06-20  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-check-fancy-symbol-name): Don't update the loop
	index inside the loop body.

2009-06-20  Helmut Eller  <heller@common-lisp.net>

	* swank-openmcl.lisp (emacs-connected): Deleted. Setting
	ccl::*interactive-abort-process* doesn't seem right.

2009-06-15  Helmut Eller  <heller@common-lisp.net>

	* swank-openmcl.lisp: Explicitly require CCL version 1.3.

2009-06-15  Helmut Eller  <heller@common-lisp.net>

	* swank-openmcl.lisp (emacs-inspect [t]): Honor the type returned
	by inspector::line-n.
	(emacs-inspect [compiled-lexical-closure]): Deleted. Let CCL's
	inpector handle this case. Which does it better and it's less work
	for us.

2009-06-14  Helmut Eller  <heller@common-lisp.net>

	Some workarounds for SBCL on Windows.

	* swank-sbcl.lisp (input-available-p): New function.
	(wait-for-input): Use it.
	([win32] handle-listen, has-buffered-input-p): New.
	(temp-file-name, tempnam): Plain tmpnam(3) is next to useless on
	Windows use tempnam(3) instead.

2009-06-12  Geo Carncross  <geocar@gmail.com>

	* swank-ecl.lisp: Support new environment changes in recent ECL/CVS
	patch largely from ECL maintainer.

2009-06-11  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el ([test] font-lock-magic): Moved to fontifying-fu contrib.

2009-06-05  Helmut Eller  <heller@common-lisp.net>

	Don't clutter compiler messages with source positions.  Especially
	stuff like "In an anonymous lambda form inside an anonymous lambda
	form inside an anonymous lambda form inside FOO: Undeclared free
	variable X" is not helpful.

	* swank-openmcl.lisp (compiler-warning-short-message): New GF.
	(handle-compiler-warning): Use it.

	(disassemble-frame): Print current PC.

2009-06-04  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-dispatch-event [:emacs-rex]): Don't clutter
	the main code-path with confusing error handling.

2009-06-04  Helmut Eller  <heller@common-lisp.net>

	* swank-openmcl.lisp (*known-processes*, mailbox): Use a weak
	hashtable to plug the memory leak.

2009-05-28  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (def-slime-test): Forgot to remove debugging code.

2009-05-28  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-dispatch-event :emacs-rex): Make sure that we
	pop the continuation on erroneous send.

	Patch by Mark Cox <markcox80@gmail.com>.

2009-05-28  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank.lisp (tokenize-symbol-thoroughly): Make it work correctly
	on escaped symbols.

2009-05-28  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-disconnect): Now only disconnects one
	connection, current one by default, or given by argument.
	(slime-disconnect-all): New. What `slime-disconnect' was before.
	(def-slime-test): Changed: expected failures are now given
	by (:fails-for ...) clauses. Extended: new clause (:style ...) to
	have a test run only on a certain communication style. Updated
	existing test cases accordingly.
	([struct] slime-test): New slot `skipped'.
	(slime-skipped-tests): New var.
	(slime-execute-tests): Adapted accordingly.
	([test] disconnect): Renamed to `disconnect-and-reconnect'
	([test] disconnect-one-connection): New.

	Adapted from patch by Stas Boukarev.

2009-05-24  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el ([test] fancy-symbol-names): Add cases involving #|
	... |# style comments. Currently failing.

	Reported by Madhu.

2009-05-24  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-goto-location-position): Only go to
	match-beginning if search succeeded.

	Patch by Madhu.

2009-05-23  Helmut Eller  <heller@common-lisp.net>

	* swank-openmcl.lisp (break-in-sldb): Honor *break-on-signals*.
	That means that we can't use SIGNAL here and we have to invoke
	SLDB directly.
	(condition-for-break): New helper.
	Reported by Bill St. Clair.

2009-05-19  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-symbol-at-point): Sometimes we can be too good,
	e.g. in "|# (defun foo () (getf" the above would return nil
	because the vertical bar is not terminated. The user probably
	wants "getf" nontheless.

	Reported by Madhu.

2009-05-19  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (sldb-restartable-frame-line-face): Set a default value.
	(sldb-frame-restartable-p): New.
	(sldb-compute-frame-face): Use it.
	(sldb-show-frame-details): Use it, too.

2009-05-19  Nikodemus Siivola  <nikodemus@random-state.net>

	* swank-source-path-parser.lisp (read-and-record-source-map):
	ignore errors during the call to READ, so that we don't the
	current version of the form we are looking at contains eg.
	uninternable symbols.

2009-05-19  Helmut Eller  <heller@common-lisp.net>

	* swank-openmcl.lisp (source-note-to-source-location): Always
	test *temp-file-map* first, because the temp-file might actually
	exist during compilation but no longer when Emacs tries to open
	it.
	(slime-goto-location-buffer): Don't create buffers for
	non-existent files.

2009-05-18  Nikodemus Siivola  <nikodemus@random-state.net>

	* slime.el (slime-description-autofocus): New variable.
	(slime-show-description): Use it to decide if description
	buffers should receive focus automatically.
	* doc/slime.texi: Document it.

2009-05-17  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-dispatch-event): New event
	`:read-from-minibuffer'.
	(slime-read-from-minibuffer-for-swank): New.

	* swank.lisp (dispatch-event): Pass through :read-from-minibuffer
	event.
	(read-from-minibuffer-in-emacs): Now uses new event rather than
	eval-in-emacs.

2009-05-17  Helmut Eller  <heller@common-lisp.net>

	* swank-openmcl.lisp (compile-temp-file): Remove backward
	compatibility code.
	(eval-in-frame, frame-source-location-for-emacs)
	(return-from-frame, restart-frame)
	(disassemble-frame, xref-locations): Simplify.
	(list-callers): Use ccl::caller-functions which gives us more precise
	src-locs than ccl::callers.
	(canonicalize-location, remove-filename-quoting)
	(maybe-method-location): Deleted.  No longer used.
	(who-specializes): Simplify.

2009-05-17  Helmut Eller  <heller@common-lisp.net>

	More precise compiler-message location.

	* swank-openmcl.lisp (handle-compiler-warning): Use the
	source-note slot of the condition as source location, which is
	more precise than the stream-position slot.
	(compiler-warning-severity): New function. The distinction between
	warning and style-warning is rather arbitrary but let's try it.
	(swank-compile-file): Pass the external-format arg down to
	compile file.
	(*buffer-name*, *buffer-offset*, condition-source-position):
	Deleted. No longer used.

2009-05-16  Helmut Eller  <heller@common-lisp.net>

	Minor refactoring.

	* swank-openmcl.lisp (call/frame, with-frame): New macro.
	(frame-visible-variables): New helper.
	(frame-var-value, frame-locals, disassemble-frame): Use it.
	(frame-catch-tags): Removed.  Way to much code for such a rarely
	used function.

2009-05-16  Helmut Eller  <heller@common-lisp.net>

	* swank-openmcl.lisp (swank-compile-string): Store the source
	code, by setting CCL:*SAVE-SOURCE-LOCATIONS* to T, for better
	disassembler output.
	(function-source-location): Remove the old pre-1.3 version.

	* swank.lisp (sldb-bitvector-pprint): Oops, all bits are true.

2009-05-16  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-current-parser-state): Do not save
	match-data. This function is called so often that it makes a
	difference.

2009-05-16  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (*sldb-pprint-dispatch-table*): Be careful when
	calling WRITE recursively: set :circle to nil which avoids
	interference with cycle-detection.
	(escape-string): New helper function.
	(*backtrace-pprint-dispatch-table*): Use it.

2009-05-15  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-allegro.lisp (swank-compile-string): Forgot to remove old
	definition in changeset 2009-05-12.

	Patch by Stelian Ionescu.

2009-05-15  Tobias C. Rittweiler  <tcr@freebits.de>

	Move font-lock-magic into contrib/slime-fontifying-fu.el.

	* slime.el (slime-highlight-suppressed-forms),
	(slime-reader-conditional-face),
	(slime-search-suppressed-forms-internal),
	(slime-search-suppressed-forms),
	(slime-search-directly-preceding-reader-conditional),
	(slime-extend-region-for-font-lock),
	(slime-compute-region-for-font-lock),
	(slime-activate-font-lock-magic): Moved.

2009-05-15  Tobias C. Rittweiler  <tcr@freebits.de>

	Rewrote some parts of the font-lock-magic in face of its fragility
	over the last days. Hopefully it'll be better now.

	* slime.el (slime-region-for-tlf-at-point): Removed. Not needed
	anymore.
	(slime-region-for-extended-tlf-at-point): Removed.
	(slime-search-backward-reader-conditional): Removed.
	(slime-search-directly-preceding-reader-conditional):
	New. Similiar to the above.
	(slime-extend-region-for-font-lock): Display bug message when
	error is caught.
	(slime-compute-region-for-font-lock): Rewritten.
	([test] font-lock-magic): Another test case.

2009-05-14  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-region-for-tlf-at-point): Use
	`(end-of-defun) (backward-sexp)' rather than
	`(end-of-defun) (beginning-of-defun' to go to the start of the
	current defun. The latter would fail on "() (a\nb\nc)".

2009-05-14  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-compute-region-for-font-lock): Fix typo.

2009-05-13  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-search-suppressed-forms): On errors, we have to
	continue the search, otherwise there's a chance that we miss
	reader conditionals in the current font-lock region.
	(slime-search-backward-reader-conditional): New. Extracted from
	`slime-region-for-extended-tlf-at-point'.
	(slime-region-for-extended-tlf-at-point): Use it.
	(slime-font-lock-region): Removed.
	(slime-font-lock-region-changed-p): Removed.
	(slime-extend-region-for-font-lock): Simplified.
	(slime-compute-region-for-font-lock): Make sure that we never
	return a flag indicating change when there was in fact no
	change. This should make the explicit guard against infinite loop
	superfluous.
	(slime-extend-region-warn-infinite-loop): Removed.
	([test] font-lock-magic): More cases.

2009-05-12  Tobias C. Rittweiler  <tcr@freebits.de>

	Make font-lock-magic test case pass.

	* slime.el (slime-bug): New function.
	(slime-search-suppressed-forms): Use it.
	(slime-extend-region-warn-infinite-loop): Ditto.
	(slime-search-suppressed-forms-internal): Check whether we're
	inside a comment, or a string.
	([test] font-lock-magic): Add another case.

2009-05-12  Tobias C. Rittweiler  <tcr@freebits.de>

	Highlight reader-errors in the source buffers on Allegro.

	* swank-allegro.lisp (*temp-file-header-end-position*): New
	variable.
	(call-with-compilation-hooks): Handle reader errors.
	(handle-compiler-warning): Adapt it accordingly.
	(location-for-reader-error): New.
	(compile-from-temp-file): Now takes a header argument explicitly
	so we can hold of the actual offset of the string we want to
	compile. This is needed to translate back file-positions reported
	in reader-errors.
	(swank-compile-string, swank-compile-file): Adapted accordingly.

2009-05-12  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-allegro.lisp (find-topframe): Hide SWANK related cruft
	from showing up in backtraces in SLDB.

2009-05-12  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-display-warning): Add `warning' as warning type.
	(slime-show-note-counts): If compilation failed, fontify the
	message in red to be more visibly apparant.

2009-05-11  Tobias C. Rittweiler  <tcr@freebits.de>

	(slime-eval-feature-expression): Guard for more erroneous
	input (due to refontification while user's typing.)

2009-05-10  Helmut Eller  <heller@common-lisp.net>

	* slime.el ([test] font-lock-magic): Add some hard cases.

2009-05-10  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-compute-region-for-font-lock): Fix typo.

2009-05-10  Tobias C. Rittweiler  <tcr@freebits.de>

	Font-lock magic barfed on #+(test).

	* slime.el (slime-eval-feature-conditional): Renamed to
	`slime-eval-feature-expression'.
	(slime-unknown-feature-expression): New error symbol.
	(slime-eval-feature-expression): Signal it.
	(slime-search-suppressed-forms): Catch it.
	(slime-compute-region-for-font-lock): Guard against unbalanced
	parentheses.
	(slime-initialize-lisp-buffer-for-test-suite): New helper.
	([test] font-lock-magic): New test case.

	Reported by Kalyanov Dmitry.

2009-05-09  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-source-file-cache.lisp (read-snippet-from-string): New.

	* swank-sbcl.lisp (source-hint-snippet): Use it.
	(emacs-buffer-source-location): Use it, too.
	(string-path-snippet): Ditto. Additionally: Make sure the returned
	string is truncated by *SOURCE-SNIPPET-SIZE*.

2009-05-08  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-search-suppressed-forms-internal): Not properly
	factored out by earlier changeset.

2009-05-08  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank.lisp (read-from-minibuffer-in-emacs): New.
	([struct] istate): Add METADATA-PLIST slot.
	(ensure-istate-metadata): New. To attach arbitrary metadata to an
	inspector page.
	(inspect-object): Adapted so methods on EMACS-INSPECT can look at
	*ISTATE*.

2009-05-08  Tobias C. Rittweiler  <tcr@freebits.de>

	#+#.foo confused the recent fontification changes. Fix that.

	* slime.el (slime-search-suppressed-forms-internal): New. Split
	from `slime-search-suppressed-forms'.
	(slime-search-suppressed-forms): Catch `invalid-read-syntax'
	errors.

2009-05-01  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-line-number-at-pos): Replaced with
	`line-number-at-pos', and add that to the portability layer.
	(display-warning): Add to the portability layer.
	(slime-display-warning): New.

	* slime.el: Implement a guard against infinite loops during
	fontification. We detect and prevent those. If we detect one, we
	emit a big warning to the user.

	(slime-font-lock-region): New variable.
	(slime-font-lock-region-changed-p): New helper.
	(slime-extend-region-warn-infinite-loop): New helper.
	(slime-compute-region-for-font-lock): Extracted from
	`slime-extend-region-for-font-lock'.
	(slime-extend-region-for-font-lock): Use it; add the guard.

2009-04-30  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-abcl.lisp: Really commit Vodonosov's patch from
	2009-03-09.

2009-04-30  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-backend.lisp ([default] declaration-arglist): Add
	arglist of DECLARATION declaration.

	* swank-openmcl.lisp ([eql 'optimize] declaration-arglist):
	Implement it for CCL.
	(describe-symbol-for-emacs): Add :TYPE.
	(describe-definition): Add :TYPE.

	Adapted from patch by Stas Boukarev.

2009-04-29  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-extend-region-for-font-lock): (nth 0
	<parser-state>) may return negative numbers.

2009-04-29  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el: Fix infinite loop during fontification introduced
	by yesterday's changeset.

	(slime-region-for-tlf-at-point): New. Like
	`slime-region-for-defun-at-point' but tries harder to get the
	toplevel form right.
	(slime-region-for-extended-tlf-at-point): Previously
	`slime-region-for-extended-defun-at-point'.
	(slime-extend-region-for-font-lock): Use it.
	(slime-mark-defun-for-font-lock): Ditto.

2009-04-28  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el: Fix fontification of suppressed (by reader
	conditionals) forms. That is make it reliably and totally work.

	(slime-region-for-extended-defun-at-point): New. Like
	`slime-region-for-defun-at-point' but takes preceding reader
	conditionals into account.
	(slime-extend-region-for-font-lock): New. Make sure that
	fontification operates on regions spanning a whole toplevel form
	only. So we never operate within the context of a reader
	conditional and we never miss any of those.
	(slime-search-suppressed-forms): Remove ignore-errors; not needed
	anymore now as we extend the region for fontification.
	(slime-mark-defun-for-font-lock): New.
	(slime-activate-font-lock-magic): Push
	`slime-extend-region-for-font-lock' onto
	`font-lock-extend-region-functions'.

2009-04-25  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-show-description): Put the connection name into
	the buffer name for description buffers. So we can have multiple
	description buffers open, one per connection.

	Useful for comparing the output of DISASSEMBLE across
	implementations.

2009-04-21  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-handle-indentation-update): Revert change from
	2009-03-09; that was a thinko.
	([test] indentation): Some basic test case for correct indentation.

2009-04-03  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-sbcl.lisp (swank-compile-file): Return T for the FAILURE-P
	return value in case of a FATAL-COMPILER-ERROR.

	Reported by Philipp M. Schäfer

2009-04-03  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-inspector-mode-map): Remove binding for
	M-RET. (It'll be added by the slime-repl contrib.)
	(slime-inspector-copy-down): Removed.

2009-03-27  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (encode-message): Handle errors during write, e.g.
	closed sockets.

2009-03-27  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-setup-contribs): Moved over from
	slime-autoloads.el

2009-03-27  Helmut Eller  <heller@common-lisp.net>
	* swank-openmcl.lisp (toggle-trace): Replace ccl::%trace with
	ccl:trace-function.
	(kill-thread): Use an implementation that doesn't raise a
	serious-conditions.

2009-03-27  Helmut Eller  <heller@common-lisp.net>

	* slime.el ([test] macroexpand): Fix more case issues.

2009-03-25  Helmut Eller  <heller@common-lisp.net>

	* slime.el ([test] macroexpand): Ignore case.

2009-03-09  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-define-channel-type): Indulge in pretty colors.
	(slime-define-channel-method): You, too!

	(slime-handle-indentation-update): Always put an indentation
	update on 'slime-indent; for slime-indentation-fu.

2009-03-09  Anton Vodonosov <avodonosov@yandex.ru>

	Use correct encoding and eol conventions for socket streams.

	* swank-abcl.lisp (accept-connection): Honor external-format
	argument.
	(*external-format-to-coding-system*, find-external-format): New.

2009-03-09  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-with-xref-buffer): Use buffer-names like
	"*slime xref...*" so that slime-kill-all-buffers can pick
	it up easily.

2009-03-09  Helmut Eller  <heller@common-lisp.net>

	* hyperspec.el (common-lisp-hyperspec-lookup-reader-macro): Use
	case-insensitive completion.
	(hyperspec-lookup-reader-macro): New alias.
	Suggested by Stas Boukarev.

2009-03-09  Helmut Eller  <heller@common-lisp.net>

	Make fasl-pathname fully customizable not only the direcrory part.

	* swank.lisp (*fasl-pathname-function*): New variable.
	(*fasl-directory*): Deleted.

2009-03-08  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-choose-overlay-for-read-error): Extracted and
	extended from `slime-choose-overlay-region'. Differentiate between
	symbol-related reader-errors (package not found &c) and
	character-related reader-errors.
	(slime-choose-overlay-region): Use it.

2009-03-08  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (make-slime-buffer-location, make-slime-file-location):
	Do not default to (:hints), but to nil, as expected in the
	slime-side source-location machinery.

2009-03-08  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-choose-overlay-region): Special case :read-error
	notes regardless of position kind.

	* swank-sbcl.lisp (signal-compiler-condition): Return :READ-ERROR
	as severity for reader-errors.
	(compiler-note-location): Fix off-by-one when compiling from
	buffer.

2009-03-08  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-sbcl.lisp (compiling-from-buffer-p),
	(compiling-from-file-p)
	(compiling-from-generated-code-p): New helpers; extracted from
	LOCATE-COMPILER-NOTE.
	(locate-compiler-note): Use them.
	(compiler-note-location): Use them, too, to handle reader-errors
	when compiling from file. This completes 2009-02-27.

	Reported by Christian Lynbech.

2009-03-07  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el ([portability] getf): Redefine `getf' on Emacs21 to
	work on malformed plists like it does on later Emacsen. This made
	the `find-local-definitions' test case fail on Emacs21.

2009-03-04  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-check-fancy-symbol-name): Use
	`slime-test-expect' instead of `slime-check'.
	([test] fancy-symbol-names): Extend test case; check for
	"Foo" in #<Foo| {...}>.
	(slime-symbol-constituent-at-pos): Check for #<.

2009-03-04  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-wait-condition): Remove `save-excursion'; it
	made the `repl-test' test case fail because this test tries to set
	point to the new prompt in vain.

2009-03-03  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-pretty-package-name): Simplify.

2009-03-03  Helmut Eller  <heller@common-lisp.net>

	Use a separate key, C-c C-d #, to lookup reader-macros.

	* hyperspec.el (common-lisp-hyperspec-lookup-reader-macro): New
	command.
	(common-lisp-hyperspec-reader-macros): New variable.
	(common-lisp-hyperspec-reader-macro-at-point): Moved over from
	slime.el
	* slime.el (slime-doc-bindings): Bind C-c C-d #.
	(slime-hyperspec-lookup): Don't consider reader-macros.

2009-03-02  Tobias C. Rittweiler  <tcr@freebits.de>

	* hyperspec.el (common-lisp-hyperspec-symbols): Add entries for
	reader macros even when `common-lisp-hyperspec-symbol-table' is
	bound to some value.

2009-02-27  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el ([test] macroexpand): New test case.
	(slime-buffer-visible-p): New helper.
	(slime-execute-as-command): New helper.

2009-02-27  Tobias C. Rittweiler  <tcr@freebits.de>

	* hyperspec.el (common-lisp-hyperspec-symbols): Add links to
	reader macros.

	* slime.el (slime-reader-macro-at-point): New function.
	(slime-hyperspec-lookup): Call it.

	Adapted from Stas Boukarev.

2009-02-27  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el: Rename `slime-symbol-name-at-point' to
	`slime-symbol-at-point'.

2009-02-27  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el ([portability] lisp-mode-syntax-table): On Emacs21,
	make @ a prefix character like it's from Emacs22
	onward. `slime-symbol-name-at-point' was written with that
	assumption.

2009-02-27  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-current-parser-state): Wrap `syntax-ppss' in a
	`save-match-data'. This issue has been reported to the Emacs
	maintainers.

2009-02-27  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-defun-if-undefined),
	(slime-defmacro-if-undefined): Renamed to
	`slime-DEFUN-if-undefined' and `slime-DEFMACRO-if-undefined' to
	better differentiate between the two.

	(slime-indulge-pretty-colors): New function. You can now put a
	symbol on the plist of `slime-indulge-pretty-colors' to make the
	symbol be fontified like `defun'. This is done for
	`slime-def-connection-var', and the two symbols above.

2009-02-27  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-defmacro-if-undefined): New. Analogous to
	`slime-defun-if-undefined'.
	([portablity]] with-selected-window) Use it.
	([portability] with-temo-buffer): Likewise.

	Patch by Theam Yong Chew.

2009-02-27  Tobias C. Rittweiler  <tcr@freebits.de>

	C-c C-c on (defun foo () ,bar) did not result in a compiler note
	overlay on SBCL.

	* swank-sbcl.lisp (compiler-note-location): Make it take a
	condition; if the condition is a READER-ERROR, the passed
	compiler-error-context is very likely NIL---we have not proceeded
	beyond reading, so we aren't within the compiler yet. In that
	case, we use the stream position of the stream behind the
	READER-ERROR instead.

2009-02-26  Tobias C. Rittweiler  <tcr@freebits.de>

	* doc/slime.texi: Fix typos, and add keybindings not listed there.

	Patch by Stas Boukarev.

2009-02-26  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (sldb-backward-frame): Only move backward when we're
	below the backtrace marker.

2009-02-26  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank.lisp (debug-in-emacs): Moved (WITH-BINDINGS
	*SLDB-PRINTER-BINDINGS* ...), from here...
	(sldb-loop): ... to here. Otherwise results from a user doing an
	eval-in-frame were truncated.

	Reported by Jeff Workman.

2009-02-26  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank.lisp (hash-table-to-alist): New function.
	([method] emacs-inspect (hash-table)): Sort keys if they're all
	numbers, symbols, or strings.

	Adapted from Willem Broekema.

2009-02-26  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-backend.lisp (warn-unimplemented-interfaces):
	Bind *PRINT-PRETTY* to T. Otherwise no sugar formatting on CCL.

2009-02-26  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-pretty-package-name): Signalled an error on
	simple symbols; fix that!

	Reported by Geoff Wozniak.

2009-02-26  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-current-form-path): Use
	`slime-current-parser-state'.

2009-02-26  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el ([test] fancy-symbol-names): New, hopefully
	comprehensive, test for funky symbol names.
	(slime-check-fancy-symbol-name): Helper.
	(slime-exit-vertical-bars): New function to move out from |foo|.
	(slime-symbol-constituent-at): New predicate to test whether the
	character at point is a valid symbol constituent.
	(slime-beginning-of-symbol, slime-end-of-symbol): Rewritten using
	above two functions and `forward-sexp' that correctly parses
	escapes etc.
	(slime-sexp-at-point): Consider thing at point a symbol first.

2009-02-24  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-forward-cruft): Forward whitespace, reader
	conditonals, comments. Splitted from `slime-forward-sexp'.
	(slime-pretty-package-name): Use it.

2009-02-24  Tobias C. Rittweiler  <tcr@freebits.de>

	Re-checkin my change from 2009-02-14. It seems I didn't actually
	commit it.

2009-02-22  Tobias C. Rittweiler  <tcr@freebits.de>

        `M-x slime-format-string-expand' displays the expansion of a
        format string.

        * slime.el (slime-string-at-point) New.
        (slime-string-at-point-or-error): New.
        (slime-format-string-expand): New; use them.

        * swank-backend.lisp (format-string-expand): New interface.
        * swank.lisp (swank-format-string-expand): New; use it.

2009-02-17  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (dispatch-event [:emacs-rex]): Reply a :invalid-rpc
	message if the specified thread doesn't exist.
	* slime.el (slime-dispatch-event): Handle :invalid-rpc.
	(slime-init-connection-state): Bind slime-current-thread
	to avoid problems with dead threads.

2009-02-14  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-reader-conditionals-regexp): New variable. Taken
	from `slime-forward-reader-conditional'.
	(slime-pretty-package-name): Fix modeline display for buffer
	containing forms like (in-package "#+foo :A #-foo :B"). Also do
	not call `read' on the name; the function does not need to return
	a symbol, and `read' may choke on non-elisp syntax.

2009-02-14  Helmut Eller  <heller@common-lisp.net>

	Don't signal conditions in interrupt handler to
	avoid problems with naive code like
	 (handler-case foo (condition bar))

	* swank-backend.lisp (*interrupt-queued-handler*): Use a dynamic
	variable instead.
	(slime-interrupt-queued): Deleted.
	* swank-cmucl.lisp, swank.lisp: Ditto.

2009-02-14  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-restart-or-init-modeline-update-timer): Don't
	run the timer repeatedly.
	(slime-change-directory): Also change the directory in the
	connection-buffer.

2009-02-11  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-current-tlf, slime-current-form-path): New
	functions; can be handy when inspecting source-locations while
	debugging M-.

2009-02-11  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el: Barf if emacs-major-version <= 20. We support 21 and up.
	(slime-emacs-20-p): Removed.

	* slime.el (slime-forward-reader-comment): Removed.
	(slime-forward-any-comment): New; superset of above.
	(slime-forward-reader-conditional): Make it understand SBCL's
	#!+,#!- so it works in source files of SBCL itself, too.
	(slime-current-parser-state): New.

2009-02-07  Tobias C. Rittweiler  <tcr@freebits.de>

	In Xref, list IR1-conversion functions with :DEF-IR1-TRANSLATOR as
	prefix rather than DEFUN. (Test case: M-. on FUNCTION.)

	* swank-sbcl.lisp (definition-specifier): New function.
	(make-dspec): New function. Splitted from
	MAKE-SOURCE-LOCATION-SPECIFICATION.

2009-02-07  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-initialize-macroexpansion-buffer): Clear the
	buffer-undo-list, so the user can't get expansions from earlier
	macroexpansions into the buffer, screwing up badly.

2009-01-30  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-clisp.lisp (fspec-location): Fix creation of source-location.

	Patch by Carsten Blaauw.

2009-01-30  Geo Carncross  <geocar@gmail.com>

	* swank-ecl.lisp (grovel-docstring-for-arglist): Fix for arglist
	that reads, but isn't a list

2009-01-27  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-backend.lisp (with-symbol): New function, to be used with #+.

	* swank-sbcl.lisp: Use WITH-SYMBOL and get rid of SBCL-WITH-SYMBOL.

	* swank-openmcl.lisp (macroexpand-all): Implement it.

	Patch by Stas Boukarev.

2009-01-23  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-editing-keys): New variable; splitted from
	`slime-keys'. Contains key bindings that are useful for buffers
	where users can edit s-exprs, such as source buffers and the REPL.
	(slime-keys): Use it.

2009-01-17  Tobias C. Rittweiler  <tcr@freebits.de>

	Fix C-u C-c C-c in SLDB.

	* slime.el (sldb-recompile-frame-source): sind
	`slime-compilation-policy' at the right place.

2009-01-15  Martin Simmons  <martin@lispworks.com>

	* swank-lispworks.lisp: wrapper functions for swank-mop
	slot-boundp-using-class, slot-value-using-class and
	slot-makunbound-using-class to account for MOP differences.

2009-01-16  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-keys): Put C-c C-i and M-* back.

2009-01-16  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (pprint-eval): Also return the output produced during
	evaluation.

2009-01-16  Helmut Eller  <heller@common-lisp.net>

	* swank-openmcl.lisp (break-in-sldb): Display the argument.

2009-01-16  Helmut Eller  <heller@common-lisp.net>

	* swank-backend.lisp (warn-unimplemented-interfaces): Print the
	names with pprint-fill.

2009-01-10  Helmut Eller  <heller@common-lisp.net>

	* swank-openmcl.lisp (install-debugger-globally): Set *break-in-sldb*.

2009-01-10  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank.lisp (do-symbols*): Wrap body in TAGBODY.

2009-01-10  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-compile-file-options): New variable.
	(slime-compile-file): Use it.

2009-01-10  David Reitter <david.reitter@gmail.com>

	* slime.el (slime-space): Declare `slime-space' to
	`delete-selection-mode' and friends (CUA) so that their behavior
	is the same as with normal insertion of a space.

2009-01-10  Helmut Eller  <heller@common-lisp.net>

	* swank-backend.lisp (swank-compile-file): Take output-file as
	additional argument.  Update backends accordingly.

	* swank.lisp (*fasl-directory*): New variable.
	(fasl-pathname): New function.
	(compile-file-for-emacs): Use it.

2009-01-10  Helmut Eller  <heller@common-lisp.net>

	* swank-backend.lisp (set-default-initial-binding): New function.

	* swank.lisp (setup-stream-indirection):  Use it

2009-01-09  Helmut Eller  <heller@common-lisp.net>

	* swank-allegro.lisp (swank-compile-string): Don't use the
	no-longer-existing directory argument.

2009-01-08  Helmut Eller  <heller@common-lisp.net>

	* slime.el: Move the tree widget for compiler notes to contrib/.

2009-01-08  Helmut Eller  <heller@common-lisp.net>

	* swank-backend.lisp (swank-compile-string): Pass the
	buffer-file-name to Lisp, not only the directory.
	Update callers accordingly.
	* slime.el ([test] arglist): Update arglist.

2009-01-08  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-popup-restore-data): Renamed from
	slime-popup-buffer-restore-info.
	(slime-popup-buffer-saved-fingerprint)
	(slime-popup-buffer-saved-emacs-snapshot)
	(slime-popup-buffer-snapshot-unchanged-p)
	(slime-popup-buffer-restore-snapshot)
	(slime-xref-quit, slime-xref-retract): Deleted.

2009-01-08  Helmut Eller  <heller@common-lisp.net>

	Remove some customization variables of questionale use.

	* slime.el (slime-when-complete-filename-expand)
	(slime-space-information-p, slime-display-compilation-output)
	(sldb-show-location-recenter-arg, slime-recenter-window)
	(slime-display-buffer-region): Deleted.

2009-01-07  Helmut Eller  <heller@common-lisp.net>

	Just use find-tag-marker-ring as stack for M-.

	* slime.el (slime-push-definition-stack)
	(slime-pop-find-definition-stack): Do whatever Emacs's standard
	find-tag commands do.

2009-01-07  Helmut Eller  <heller@common-lisp.net>

	Fix the slime-next-location command.

	* slime.el (slime-xref-last-buffer): New variable.
	(slime-show-xrefs): Initialize it.
	(slime-goto-next-xref): Use it.
	(slime-search-property): New function.
	(slime-xref-buffer): Delted

2009-01-07  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (*sldb-pprint-dispatch-table*): Honor *print-escape*

2009-01-07  Helmut Eller  <heller@common-lisp.net>

	* swank-cmucl.lisp (frame-locals, frame-debug-vars): Remove
	non-valid variables.
	(debug-var-value): Compute the location from the frame arg.

2009-01-07  Helmut Eller  <heller@common-lisp.net>

	* swank-source-path-parser.lisp (make-source-recorder)
	(source-path-source-position): Adjust the file-position before
	entering it in the table.

2009-01-07  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-with-xref-buffer): Don't set
	slime-popup-buffer-quit-function. Use the default.  Don't shrink
	the window because it may have existed before creating the buffer
	and we need to restore it.
	(slime-goto-xref): Just use slime-popup-buffer-quit.
	(slime-edit-definition-cont): Push definition stack here so that
	we don't need to do anything special in slime-goto-xref.
	(slime-display-popup-buffer): Also save the buffer that the popup
	window was displaying before (if the window is not new).
	(slime-close-popup-window): Restore the old buffer (if any) of the
	popup window.

2009-01-07  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-show-buffer-position): Use reposition-window.

2009-01-07  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-keys): Remove the binding for C-c C-i. M-TAB
	can also be pressed with M-C-i which is probably not taken
	by the window manager.  ESC TAB would also work.  Maybe we
	should reuse C-c C-i for slime-inspect.
	Move C-c C-y to slime-repl.e.
	Remove C-c C-f: it's already on C-c C-d f.
	Remove C-c M-0: slime-restore-window-configuration doesn't exist.
	Remove M-g: slime-quit doesn't work since ages.

2009-01-05  Helmut Eller  <heller@common-lisp.net>

	Create a compilation-log buffer so that next-error works but
	don't display the buffer.

	* slime.el (slime-create-compilation-log): New function.
	(slime-compilation-finished-hook): Use it.

2009-01-05  Helmut Eller  <heller@common-lisp.net>

	Use keymap inheritance to share bindings in various modes.

	* slime.el (slime-parent-map): New keymap.
	(slime-mode-map, slime-popup-buffer-mode-map, sldb-mode-map)
	(slime-inspector-mode-map): Use it.
	(slime-parent-bindings, slime-prefix-bindings): New variables.
	(slime-prefix-key, slime-define-key): Deleted.

	Update contribs accordinly.

2009-01-05  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-with-popup-buffer): New argment: select.
	If nil (default) buffer will only be displayed but not selected.

2009-01-05  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-show-compilation-log): Insert two lines at
	the beginning.  Emacs 21 seems to skip over those two.

2009-01-05  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-sbcl.lisp (function-arglist):
	SB-INTROSPECT:FUNCTION-ARGLIST is deprecated in bleeding edge sbcl.

2009-01-05  Tobias C. Rittweiler  <tcr@freebits.de>

	Do not truncate error messages in SLDB.

	* swank.lisp (*sldb-bitvector-length*): Like *PRINT-LENGTH* for
	bit-vectors.
	(*sldb-string-length*): Likewise for strings.
	(*sldb-pprint-dispatch-table*): Truncate bit-vectors / strings
	according to the above variables.
	(*sldb-printer-bindings*): Use the new variables. Bind
	*PRINT-LINES* to NIL so error messages are not truncated.

2009-01-04  Helmut Eller  <heller@common-lisp.net>

	Make it possible to limit the number of displayed restarts.

	* slime.el (sldb-initial-restart-limit)
	(sldb-insert-more-restarts): New.
	(sldb-setup, sldb-insert-restarts): Use it.

2009-01-04  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-local-variable-p): New function. XEmacs requires
	two arguments.

2009-01-04  Helmut Eller  <heller@common-lisp.net>

	* swank-cmucl.lisp (note-error-location): If possible, include the
	filename.
	* slime.el (slime-goto-location-position): Add :eof as position
	kind.

2009-01-03  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-goto-location-buffer): Don't goto point-min.
	(slime-check-location-buffer-name-sanity)
	(slime-check-location-filename-sanity): Separated from
	slime-goto-location-buffer.
	(slime-line-number-at-pos): New compatibility function.

2009-01-03  Helmut Eller  <heller@common-lisp.net>

	By default, show compiler notes in a buffer with compilation-mode.

	* slime.el (slime-show-compilation-log)
	(slime-maybe-show-compilation-log): New functions,
	(slime-compilation-finished-hook): Change the default value
	to 'slime-maybe-show-compilation-log.

2009-01-03  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (simple-serve-requests, make-repl-input-stream):
	Move the call to WITH-CONNECTION to the input stream to pick up
	stream redirections.

2009-01-03  Helmut Eller  <heller@common-lisp.net>

	* swank-clisp.lisp (wait-for-input): Disable it for win32.

2009-01-02  Helmut Eller  <heller@common-lisp.net>

	Experimental implementation of "channels".
	The idea is to support arbitrary protocols without
	changes to the low level event dispatcher.

	* slime.el (slime-make-channel, slime-close-channel)
	(slime-channel-send, slime-send-to-remote-channel): New functions.
	(slime-define-channel-type, slime-define-channel-method): New
	macros.
	(slime-dispatch-event): Support channel events.
	* swank.lisp (channel, listener-channel): New classes.
	(channel-send, send-to-remote-channel): New functions.
	(create-listener): New function.  Test case for channel code.
	(process-requests): Process channel events.

2009-01-02  Helmut Eller  <heller@common-lisp.net>

	* slime.el ([test] arglist): Guard against nil.  ECL
	returns nil most of the time.

2009-01-01  Tobias C. Rittweiler  <tcr@freebits.de>

	Arglists of user-defined types are now displayed by slime-autodoc
	on SBCL.

	  (deftype foo (x y) `(cons ,x ,y))
	  (declare (type (foo |

	* swank-sbcl.lisp ([method] type-specifier-arglist): Make use of
	recently introduced SB-INTROSPECT:DEFTYPE-LAMBDA-LIST.

2009-01-01  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-loader.lisp (*contribs*): Add `swank-sbcl-exts'.

2009-01-01  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-eval-async, slime-dispatch-event): Canoncalize
	return value. Previously they returned an arbitrary value which
	was displayed to the minibuffer due to a bug in slime-autodoc. The
	arbitrariness of the return value made debugging this a chore.

2009-01-01  Helmut Eller  <heller@common-lisp.net>

	* swank-openmcl.lisp (frame-source-location-for-emacs)
	(pc-source-location): Fall back to the source-note of the function
	if there is no source-note for a pc offset.

2009-01-01  Helmut Eller  <heller@common-lisp.net>

	For buffers without filename, map the name of the tempfile back to
	the buffer name.

	* swank-openmcl.lisp (*temp-file-map*): New variable.
	(note-temp-file): New function.
	(compile-temp-file, source-note-to-source-location): Use it.

2009-01-01  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (sleep-for): New function
	* slime.el ([test] break): Use SWANK::SLEEP-FOR to help CCL pass
	this test.
	([test] arglist): Update arglist of
	swank::compile-string-for-emacs.
	([rest] find-definition.2): Allow some whitespace before the actual
	position.  Otherwise, CCL would fail on this test.

2008-12-31  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (maybe-redirect-global-io): Don't consider
	connections without streams.
	(*new-connection-hook*): Don't add MAYBE-REDIRECT-GLOBAL-IO.
	(create-repl): Call MAYBE-REDIRECT-GLOBAL-IO here.

2008-12-31  Helmut Eller  <heller@common-lisp.net>

	* swank-openmcl.lisp ([method] source-locations (symbol)): Drop
	the unused _; the compiler dosn't like it.

2008-12-31  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-cd, slime-pwd): New commands.
	(slime-change-directory): New function.
	(slime-change-directory-hooks): New hook.

2008-12-31  Helmut Eller  <heller@common-lisp.net>

	* slime.el ([test] find-definition.2): Also fails for Lispworks.
	([test] interrupt-at-toplevel, [test] interrupt-in-debugger): Those
	don't work well if there's no REPL thread.

	* swank-backend.lisp (wait-for-input, wait-for-one-stream): Don't
	use PEEK-CHAR because we can't interrupt that cleanly.
	* swank.lisp (simple-serve-requests): Run the REPL inside
	WITH-CONNECTION.
	* swank-lispworks.lisp (emacs-connected): Don't install the signal
	handler here ...
	(install-sigint-handler): ... use this instead

2008-12-30  Tobias C. Rittweiler  <tcr@freebits.de>

	As of now, `C-u C-c C-c' compiled a function with maximum debug
	settings (SBCL only.)

	Now, `M-- C-c C-c' will compile a function with maximum _speed_
	settings (still SBCL only) --- useful to elicit compiler notes.

	* slime.el (slime-compilation-debug-level): Renamed to
	`slime-compilation-policy'.
	(slime-normalize-optimization-level): Renamed to
	`slime-compute-policy'.

	* swank.lisp (compile-string-for-emacs): Takes a policy now.
	(compile-multiple-strings-for-emacs): Ditto.

	* swank-backend.lisp (swank-compile-string): Change :DEBUG key arg
	to :POLICY.

	* swank-scl.lisp, swank-openmcl.lisp, swank-lispworks.lisp
	* swank-ecl.lisp, swank-corman.lisp, swank-cmucl.lisp,
	* swank-clisp.lisp, swank-allegro.lisp, swank-sbcl.lisp:

	Changed accordingly.

2008-12-29  Helmut Eller  <heller@common-lisp.net>

	* swank-openmcl.lisp (find-definitions, source-locations): Use
	ccl:find-definition-sources.
	(swank-compile-string, compile-temp-file): Use new parameters to
	compile-file to adjust source locations.

2008-12-28  Helmut Eller  <heller@common-lisp.net>

	Recent CCLs support much better source location recording.
	Let's use the new features in SLIME.

	* swank-openmcl.lisp (function-source-location): Use
	ccl:function-source-note.
	(pc-source-location): New function, based on
	ccl:find-source-note-at-pc.
	(frame-source-location-for-emacs): Use it.

2008-12-27  Helmut Eller  <heller@common-lisp.net>

	* slime.el: Move slime-lisp-package and
	slime-lisp-package-prompt-string to slime-repl.el

	* swank.lisp (create-repl): Return initial package and prompt.

2008-12-25  Helmut Eller  <heller@common-lisp.net>

	Don't restore window configs in sldb.
	That doesn't work in the native repl, because output
	may have moved point.

	* slime.el (sldb-setup, sldb-exit): Use temp buffer code.
	(slime-display-popup-buffer): Don't overwrite existing
	variables.
	(slime-close-popup-window): Factored out from
	slime-popup-buffer-quit.
	(slime-save-local-variables): New macro.
	(sldb-maybe-kill-buffer, sldb-saved-window-configuration): Deleted.

2008-12-23  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (connection.env): New slot. To hold dynamic variable
	bindings for this connection.
	(with-io-redirection): Use it.
	(create-repl): New function.  Currently only redirects IO for the
	connection.  Could potentially be used to create multiple
	listeners, each with a set of streams and corresponding buffers.
	(*redirect-io*, maybe-call-with-io-redirection)
	(call-with-redirected-io): Deleted.

2008-12-23  Helmut Eller  <heller@common-lisp.net>

	Move most of the REPL mode to contrib.
	Disable some commands that depend on the
	existence of a REPL buffer.

2008-12-23  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-set-connection-info): Don't create a repl
	buffer.
	(slime-start-lisp): Bind process-connection-type to nil to avoid
	problems witht CLISPs readline code.

	* swank.lisp (read-non-blocking, make-repl-input-stream)
	(simple-repl): New functions.
	(simple-serve-requests): Use it.

	* swank-backend.lisp (wait-for-one-stream, wait-for-streams): New
	functions.
	(wait-for-input): Use it to support wainting on multiple streams.

	* swank-cmucl.lisp (to-fd-stream): New function.
	(wait-for-input): Use it.

2008-12-23  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-run-mode-hooks): Wrapper for Emacs21.
	(slime-repl-mode): Use it.
	Reported by Peter Denno.

2008-12-23  Sven Van Caekenberghe <sven@beta9.be>

	* swank.lisp (connection): Add a slot to store the
	auto-flush-thread.
	(cleanup-connection-threads): Also kill the auto-flush-thread.

	(stop-server): list-threads returns the thread name in second
	position and not in first position.

2008-12-23  Willem Broekema <metawilm@gmail.com>

	* slime.el (sldb-insert-restarts): Make the space before each
	restart also propertized, consistent with how each line in the
	backtrace is fully sensitive.

2008-12-09  Helmut Eller  <heller@common-lisp.net>

	Reset the stream column to 0 after eval requests.

	* swank.lisp (interactive-eval, eval-region): Use FRESH-LINE
	to reset the stream column.
	* slime.el (test repl-test): Adjust test accordingly.

2008-12-09  Helmut Eller  <heller@common-lisp.net>

	Be a bit more careful when computing the toplevel restart.

	* swank.lisp (throw-to-toplevel): Test *sldb-quit-restart* for
	nilness.
	* sldb-quit (sldb-quit): Show the returned value in brackets.

2008-12-09  Helmut Eller  <heller@common-lisp.net>

	Make the modeline a bit shorter.

	* slime.el (slime-compute-modeline-string): Remove PKG: and CON:
	to save space.
	(slime-compute-modeline-connection-state): Don't include zeros.

2008-12-09  David Reitter <david.reitter@gmail.com>

	* slime.el (slime-repl-mode): Use `run-mode-hooks' rather than
	just `run-hooks'.  That way, after-change-major-mode-hook is
	called automatically.

2008-12-07  Nikodemus Siivola <nikodemus@random-state.net>

	* slime.el (slime-qualify-cl-symbol-name): Clean up the package
	name using `slime-pretty-package-name', so that packages named with
	strings are not left with the extra doublequotes.

2008-12-05  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-macroexpansion-minor-mode-map): Bind keybindings
	of `undo' to `slime-macroexpansion-undo'.
	(slime-show-macroexpansion): Renamed to
	`slime-initialize-macroexpansion-buffer'
	(slime-initialize-macroexpansion-buffer): Make sure that the user
	can't undo past the initial insertion.
	(slime-macroexpand-undo): New function. Tries to undo-only.

2008-12-05  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-trace-query): SPEC argument can be a symbol.

2008-12-02  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-compute-modeline-connection-state): Fix
	computation of debugged requests.

2008-11-30  Gábor Melis  <mega@retes.hu>

	* slime.el (slime-compute-modeline-connection-state): Print the
	number of debugged requests if non-zero.
	(slime-connection-state-as-string): Removed unused branches.
	(slime-compute-connection-state): Removed :debugged branch making
	most likely return :connected instead.

2008-12-02  Tobias C. Rittweiler  <tcr@freebits.de>

	Modeline wouldn't display {debugged..} after `slime-interrupt'.

	* slime.el (slime-debugged-connection-p): Can't rely on
	`sldb-debugged-continuations' to be non-null in every SLDB buffer.

2008-11-23  Helmut Eller  <heller@common-lisp.net>

	`q' in temp buffers should only delete the window if it was newly
	created for the buffer.

	* slime.el (slime-display-popup-buffer): New function.  Recognize
	if the window didn't exist before.  Save the created window and
	the selected window in buffer local variables.
	(slime-make-popup-buffer): Renamed from slime-popup-buffer.
	(slime-popup-buffer-quit): Delete the created window (if needed)
	and restore the old selected window.  Don't touch other windows.

	(slime-edit-value-callback): Calling lisp-mode deletes all local
	variables.  We need to that inside with-popup-buffer.

2008-11-22  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-update-all-modelines): Only walk through
	widnow-list not buffer-list.
	(slime-restart-or-init-modeline-update-timer): Inrease the timer
	interval to 0.5 seconds.

2008-11-22  Gábor Melis  <mega@retes.hu>

	Reincarnate "eval..." (almost)

	* slime.el (slime-compute-modeline-connection-state): Return the
	number of outstanding requests if connected.
	(slime-update-all-modelines): Renamed from slime-update-modelines,
	loops through all slime buffers.
	(slime-restart-or-init-modeline-update-timer): New function.
	(slime-dispatch-event): Arrange for modelines to be updated on
	:EMACS-REX and :RETURN.

2008-11-22  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (invoke-default-debugger): New condition type.
	(swank-debugger-hook): Handle invoke-default-debugger conditions.
	(sldb-break-with-default-debugger): Signal invoke-default-debugger
	to transfer control to the default debugger.
	New argument DONT-UNWIND to invoke the native debugger without
	unwinding the stack.
	* slime.el (sldb-break-with-default-debugger): By default,
	unwind the stack before invoke the native debugger.
	With prefix argument, run the native debugger in the
	dynamic environment of SLDB.

2008-11-02  Helmut Eller  <heller@common-lisp.net>

	* slime.el ([test] package-updating): Allegro returns "||" as
	prompt for the keyword package.  I guess that's acceptable.

2008-11-02  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-popup-buffer-quit): Always delete windows and
	bury the buffer.

2008-11-02  Helmut Eller  <heller@common-lisp.net>

	* swank-backend.lisp (slime-interrupt-queued): New condition.
	* swank.lisp (invoke-or-queue-interrupt): Raise it here.
	* swank-cmucl.lisp (wait-for-input): Make fd readable in condition
	handler so that we can call serve-events without timeout.

2008-11-02  Helmut Eller  <heller@common-lisp.net>

	* slime.el ([test] find-definition.2, [test] compile-defun):
	Expect to fail for CCL.

2008-10-31  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-repl-history-pattern): Simplify as suggested by
	Knut Olav Bøhmer and Michael Weber.

2008-10-31  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-eval-with-transcript)
	(slime-eval-with-transcript-cont): Restore the current buffer,
	before calling cont.

2008-10-31  Helmut Eller  <heller@common-lisp.net>

	* swank-lispworks.lisp (describe-function): Don't use
	string-upcase on lambda-list-argruments, because not all elements
	must be symbols.

2008-10-31  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (debug-in-emacs): Bind *sldb-quit-restart* here. If
	necessary, use the current abort retstart.

2008-10-30  Helmut Eller  <heller@common-lisp.net>

	* swank-sbcl.lisp (wait-for-input): Return streams which are at
	EOF.

2008-10-30  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-popup-buffer-quit): Call bury-buffer with
	explicit argument for compatibility with XEmacs.

2008-10-30  Ivan Shvedunov <ivan4th@gmail.com>

	* slime.el (slime-repl-history-pattern): Use the part of input
	between its start and (point) as history search pattern.
	Previously we used the entire input.

2008-10-26  Helmut Eller  <heller@common-lisp.net>

	* test.sh: Return the number of failed tests as exit code.

	* slime.el: Fix change from 2008-10-20.
	Use (eval-when (compile)...) instead of (eval-when-compile ...),
	because the latter is more like (eval-when (compile eval) ...).

2008-10-23  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-redirect-inferior-output): New command.

2008-10-21  Helmut Eller  <heller@common-lisp.net>

	* swank-allegro.lisp (frame-restartable-p): Handle errors signaled
	by debugger:frame-retryable-p.  This looks like an Allegro
	bug, though.  Reported by Luke Hope.

2008-10-20  Helmut Eller  <heller@common-lisp.net>

	* slime.el: Require some packages, e.g. apropos, at compile time
	to suppress some "undefined function" warnings.

2008-10-19  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (frame-locals-and-catch-tags): New function.
	Fetch locals and catch tags with a single RPC.

	* slime.el (sldb-frame-details): Use it.

	* swank-backend.lisp (frame-catch-tags): Provide a default
	implementation.  Delete the dummy defs in various backends.

2008-10-19  Mark Evenson <evenson@panix.com>

	* swank-abcl.lisp (handle-compiler-warning): Report source
	location position when we can.
	Use NAMESTRING for *compile-filename*.

2008-10-19  Helmut Eller  <heller@common-lisp.net>

	* swank-clisp.lisp (filename-to-pathname, parse-cygwin-filename):
	Accept Windows and Unix filenames when :CYGWIN is in *features*.

2008-10-17  Helmut Eller  <heller@common-lisp.net>

	* swank-sbcl.lisp (swank-compile-file): Fix typo.

2008-10-17  Helmut Eller  <heller@common-lisp.net>

	* swank-backend.lisp (compute-sane-restarts): Deleted. Use plain
	compute restarts instead.

2008-10-17  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (call-with-retry-restart): Implement this a little
	less confusing.

2008-10-17  Helmut Eller  <heller@common-lisp.net>

	* swank-backend.lisp (frame-restartable-p): New function.
	(swank-frame): Deleted. Update implemenetations accordingly.
	(print-frame): Renamed back from print-swank-frame.

	* swank.lisp (backtrace): Don't clutter the backtrace with
	'(:restartable :unknown).  For practical purposes :unknown is the
	same as nil.

	* slime.el (sldb-compute-frame-face): Only accept nil or t for
	the :restartable prop.

2008-10-16  Helmut Eller  <heller@common-lisp.net>

	* swank-backend.lisp (swank-compile-file): Return the same
	values as COMPILE-FILE.  Update backends accordingly.

	* swank-lispworks.lisp (with-swank-compilation-unit): Return the
	values of BODY.
	(compile-from-temp-file)
	* swank-allegro.lisp (compile-from-temp-file)
	* swank-clisp.lisp (swank-compile-string)
	* swank-abcl.lisp (swank-compile-string): Return T on success.
	* swank.lisp (collect-notes): Check return type of
	FUNCTION.

2008-10-16  Helmut Eller  <heller@common-lisp.net>

	* swank-openmcl.lisp (frame-catch-tags): Disabled as it prevents
	FRAME-LOCALS from working in lx8632.

2008-10-10  Nikodemus Siivola <nikodemus@random-state.net>

	* slime.el (slime-inspector-toggle-verbose): New function.
	(slime-inspector-mode-map): Bind v to slime-inspector-toggle-verbose.
	(slime-cheat-sheet-table): Add slime-inspector-toggle-verbose.
	* swank.lisp (*inspector-verbose*): New variable.
	([defstruct] istate): New slot called verbose.
	(istate>elisp): If the current istate is verbose, use untruncated
	result of TO-STRING as the title.
	(inspect-nth-part): Use the verbosity of the current istate.
	* doc/slime.texi: Document slime-inspector-toggle-verbose.

2008-10-07  Nikodemus Siivola <nikodemus@random-state.net>

	* swank.lisp (*backtrace-printer-bindings*): export.

2008-10-05  Helmut Eller  <heller@common-lisp.net>

	* swank-cmucl.lisp (list-callers): Do a full GC before calling
	map-allocated-objects. That's needed because map-allocated-objects
	seems to cons even if it's inlined.
	(emacs-inspect [code-component]): Try to detect
	byte-code-components.

	(inspect-alien-record, mv-function-end-breakpoint-values): Avoid
	compiler warnigns.

2008-10-04  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-sbcl.lisp: Add support for WHO-SPECIALIZES. This requires
	a patch for SBCL's SB-INTROSPECT contrib which I sent upstream a
	few minutes ago.

2008-10-04  Helmut Eller  <heller@common-lisp.net>

	Some cleanups for compilation commands.

	* slime.el ([defstruct] slime-compilation-result): Rename result
	slot as successp.
	(slime-make-compilation-finished-continuation): Deleted.
	slime-eval-async preserves the current buffer and preserving the
	window-configuration was always a questionable feature.
	(slime-compilation-finished): Simplified.
	(slime-show-note-counts): Also show the success/failure flag.
	(slime-recompile-locations): Take a continuation as argument
	rather than messing around with compilation-finished-hooks.
	(slime-aggregate-compilation-results): New function.
	(slime-xref-recompilation-cont): Renamed from
	slime-make-xref-recompilation-cont.
	(slime-compiler-results): Deleted.
	(slime-goto-first-note-after-compilation): Replaced with hook
	function slime-goto-first-note.
	(slime-compilation-just-finished): Deleted.
	(slime-to-lisp-filename-function): Use convert-standard-filename.
	* swank.lisp ([defstruct] compilation-result): Renamed from
	swank-compilation-result.
	(measure-time-interval): Return seconds as float.
	(collect-notes): Renamed from swank-compiler.  Return a single
	compilation-result.
	(compile-multiple-strings-for-emacs): Return a list of
	compilation-results instead of a single result with merged notes.

	* swank-backend.lisp (filename-to-pathname): Renamed from
	parse-emacs-filename.  Updated callers.
	(pathname-to-filename): New function.  Use it where appropriate.

	* swank-scl.lisp (pathname-to-filename): Implement it in the
	backend to get rid of the #+scl in swank.lisp.

	* swank-cmucl.lisp (swank-compile-file, swank-compile-string):
	Return t on success.

2008-10-04  Alain Picard <Alain.Picard@accenture.com>

	UTF-8 support for Lispworks.

	* swank-lispworks.lisp (accept-connection): Use flexi-streams
	for utf-8.
	(make-flexi-stream): New function.
	(*temp-file-format*): New variable
	(compile-from-temp-file): Use it.

2008-09-28  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-list-compiler-notes): Revert change from
	2008-08-15 which introduced automatic shrinkage of the
	compiler-notes buffer. This turned out to be more annoying than
	worthwhile. On the cases where it's desired, the user can just use
	`C-x -' himself to shrink the notes buffer.

2008-09-28  Helmut Eller  <heller@common-lisp.net>

	Stop handling events in worker threads after sldb-quit.

	* swank.lisp (with-top-level-restart): New macro.
	(handle-requests, spawn-worker-thread): Use it.
	(process-requests): Drop the just-one argument.
	(handle-or-process-requests): Deleted. Call handle-requests
	directly.

2008-09-27  Tobias C. Rittweiler  <tcr@freebits.de>

	Improve ECL's arglist support somewhat.

	* swank-ecl.lisp (grovel-docstring-for-arglist): New function.
	(arglist): Use it. Now also try to find an arglist for special
	operators, and macros.

2008-09-26  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-cycle-connections): Do not make the new
	connection buffer-local if we're currently in a REPL buffer.

2008-09-24  Knut Olav Bøhmer <knut-olav.bohmer@telenor.com>

	* slime.el (slime-cycle-connections): New command.

2008-09-24  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-prefix-map): New keymap.
	(slime-define-key): Use it.  Also drop unused :inferior arg.
	(slime-inspector-mode-map): Bind C-c to slime-prefix-map.
	(slime-define-both-key-bindings): New function.  Factor of
	slime-init-keymaps.
	(slime-init-keymaps): Use it.
	(slime-control-modified-char): Deleted.

2008-09-23  Douglas Crosher <dcrosher@common-lisp.net>

	* swank-scl.lisp: update for Scieneer CL 1.3.8.

	* swank.lisp (ed-in-emacs): customize for the SCL.

	* swank.lisp (signal-interrupt): fix typo.

2008-09-22  Nikodemus Siivola  <nikodemus@random-state.net>

	* swank.lisp (guess-package): Return NIL if string designator is
	NIL: makes files without IN-PACKAGE forms more *BREAK-ON-SIGNALS*
	friendly.

2008-09-22  Helmut Eller  <heller@common-lisp.net>

	* swank-sbcl.lisp (wait-for-input): Implement this in backend,
	since read-char-no-hang doesn't work in fd-handlers.
	(install-sigint-handler): Go through invoke-interruption and
	with-interrupts to support nested interrupts.

	* slime.el (slime-lisp-implementations): Mention :env keyword
	in docstring.

2008-09-21  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-repl-input-end-mark): Deleted. It was always at
	the end of buffer. Use point-max instead.
	(slime-repl-eol): Removed.  The usual end-of-line does the same.

2008-09-21  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-eol-conversion-fixup): Return 0 (not nil) for
	anyting other than CRLF conventions.

2008-09-21  Helmut Eller  <heller@common-lisp.net>

	* swank-openmcl.lisp: Try to remove the first few internal frames
	from backtraces.
	(guess-stack-top): New function.
	(call-with-debugging-environment): Use it

	(frame-arguments): Return a list instead of a string.  Don't quote
	symbols.
	(source-locations): Recognize (:internal FOO) functions.

2008-09-21  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (*backtrace-pprint-dispatch-table*):
	Honor *print-escape*.

2008-09-20  Ariel Badichi <abadichi@bezeqint.net>

	* slime.el (slime-with-output-end-mark):
	slime-repl-show-maximum-output no longer accepts any arguments.

2008-09-20  Helmut Eller  <heller@common-lisp.net>

	* test.sh: Parse the -S option as advertized.

	* slime.el (slime-randomize-test-order): Add the * to the
	docstring.
	([def-slime-test] break2): Also CCL is expected to fail here.

2008-09-20  Helmut Eller  <heller@common-lisp.net>

	Fix some of the bugs that I introduced with the last commits.

	* swank-openmcl.lisp (call-with-debugging-environment): Fix typo.
	(call-with-debugger-hook): Bind *break-in-sldb*.
	(backtrace-context): Return nil, not tcr!
	(map-backtrace): Remove the stack< test. Only test for nil.
	(lisp-implementation-type-name): Return "ccl".

	(emacs-inspect (t)): Fix typo.

	(kill-thread): Use join-process. Otherwise we get strange
	"process-reset" errors when disconnecting.
	(thread-alive-p): Implemented with ccl::process-exhausted-p.

	(source-locations): Use labels for helper functions.
	(function-source-location): Now implemented on top of
	source-locations.

2008-09-20  Helmut Eller  <heller@common-lisp.net>

	Fix frame-source-location-for-emacs for CCL.

	* swank-openmcl.lisp (source-locations): New function.
	(create-source-location): New function.
	(frame-source-location-for-emacs): Use it.

2008-09-20  Helmut Eller  <heller@common-lisp.net>
	Fix inspecting of arrays.

	* swank-openmcl.lisp (emacs-inspect :around (t)): call-next-method
	may return a lazy list.  Detect that case and only append to
	ordinary lists.
	(emacs-inspect (t)): Don't mark labels as inspectable. Just print
	them.

2008-09-20  Helmut Eller  <heller@common-lisp.net>

	Fix BREAK and backtraces after interrupts.

	* swank-openmcl.lisp (*sldb-stack-top-hint*): New variable.
	(call-with-debugging-environment, break-in-sldb)
	(interrupt-thread): Use it.
	(*process-to-stack-top*, record-stack-top)
	(grab-stack-top): Deleted. Use *sldb-stack-top-hint* instead.
	(backtrace-context): Deleted. Use %current-tcr directly.

2008-09-20  Helmut Eller  <heller@common-lisp.net>

	* swank-openmcl.lisp (call-with-debugging-environment): Don't set
	*debugger-hook* to nil.

2008-09-19  Helmut Eller  <heller@common-lisp.net>

	* slime.el ([def-slime-test] break): Split it up in two versions
	to make the debugger-hook issue more explicit.

	* swank-allegro.lisp (frob-allegro-field-def): There seems to be a
	new type :func handle it like :lisp.

2008-09-19  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-save-marker): New marcro. Use it in combination
	with insert-before-markers.
	(slime-check-buffer-contents): Use {} resp. [] to describe the
	position of output resp. input markers.

	(slime-repl-emit-result): Update window-point.

	(slime-randomize-test-order): New variable.
	(slime-shuffle-list): New function.
	(slime-run-tests): Use it.
	(slime-batch-test): Accept test-name and randomize arguments.

	* test.sh (usage): Accept -n and -S options.

2008-09-18  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-ecl.lisp: Forgot to update ECL's backend when introducing
	swank-frames in commit on 2008-09-12.

2008-09-18  Helmut Eller  <heller@common-lisp.net>

	Some cleanups for the REPL code.

	* slime.el (slime-show-last-output)
	(slime-show-last-output-function)
	(slime-show-last-output-region)
	(slime-maybe-display-output-buffer)
	(slime-repl-last-input-start-mark): Delete unused code.

	(slime-repl-emit-result, slime-repl-insert-prompt)
	(slime-repl-show-abort, slime-repl-insert-result)
	(slime-insert-transcript-delimiter)
	(slime-eval-with-transcript-cont): Consistently use save-excursion
	and insert-before-markers.  We always want to preserve the cursor
	position in the input region (for type-ahead).
	(slime-eval-with-transcript):  Change order of arguments to
	make the common case easier to use.

	(slime-batch-test): Use a timer.
	(slime-check-buffer-contents): New function to test contents and
	current position.  Use it in various places.

	(sldb-recenter-region, def-slime-test interactive-eval)
	(def-slime-test interactive-eval-output): Act slightly differently
	when the test suite is executed in batch mode (without terminal).

	* swank.lisp (handle-requests): Flush output.
	(interactive-eval, interactive-eval): Don't use fresh-line, as
	that makes it harder to test the REPL code.

	* test.sh (usage): Add a -T switch to run slime in the current
	directory without copying (and compiling) everything to a
	temporary directory.

2008-09-18  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-eval-with-transcript): Accept some more arguments
	so that we can also use it for compile-file.
	(slime-eval-with-transcript-cont): New. Insert prompt.
	(slime-compile-file): Use slime-eval-with-transcript.
	(slime-repl-show-maximum-output): Update window point.
	(slime-repl-insert-prompt): Don't use insert-before-markers.
	(slime-repl-emit): No longer use slime-with-output-end-mark.

2008-09-17  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-sbcl.lisp (make-definition-source-location): Fix typo
	introduced with crlf-related commit on 2008-09-16.

2008-09-17  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-repl-popup-on-output): New variable.
	(slime-repl-emit): Honor slime-repl-popup-on-output.
	(slime-eval-with-transcript): Use slime-repl-popup-on-output.
	Also remove the function argument, as it was only used once
	and that was slime-message.

2008-09-17  Helmut Eller  <heller@common-lisp.net>

	(*pre-reply-hook*): Add 'force-user-output.

2008-09-17  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (send-user-output): Lifted from make-output-function.
	Make this a top-level function for easier redefinition.

2008-09-17  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-test-find-top-level-restart): New function.
	[def-slime-test] (interrupt-at-toplevel, interrupt-in-debugger):
	Use it.

2008-09-16  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-connection): Optionally select a new default
	connection.
	(slime-auto-select-connection): New variable.
	(slime-auto-select-connection): New function.

2008-09-16  Helmut Eller  <heller@common-lisp.net>

	Adjust positions in files with CRLF style end-on-line markers.

	* slime.el (slime-eol-conversion-fixup): New function.
	(slime-goto-location-position): Use it.  Also add a new position
	type :offset, so that we don't adjust offsets in strings that were
	sent over the wire (which uses LF eol-convention).

	* swank-abcl.lisp
	* swank-allegro.lisp
	* swank-clisp.lisp
	* swank-cmucl.lisp
	* swank-corman.lisp
	* swank-ecl.lisp
	* swank-lispworks.lisp
	* swank-openmcl.lisp
	* swank-sbcl.lisp
	* swank-scl.lisp: Create :offset style positions where needed.

	* swank-lispworks.lisp (skip-comments): New function.
	(dspec-stream-position): Use it.

2008-09-16  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-end-of-list): `backward-down-list' was used
	there which is defined by paredit.el.
	Use `(down-list -1)' instead.

2008-09-15  Helmut Eller  <heller@common-lisp.net>

	* swank-lispworks.lisp (describe-symbol-for-emacs): Revert last
	change.

2008-09-15  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (sldb-loop): Send a :sldb-return event to ourselfes
	to inform the debug session at the lower level.
	(wait-for-event): Drop the report-interrupt argument.  No longer
	needed.
	(event-match-p): Add an OR pattern operator.  Used to wait for
	different events simultaneously.

	(read-packet): Use peek-char to detect EOF. read-sequence wouldn't
	work.

	* slime.el (slime-test-interrupt-in-debugger): Call sldb-quit and
	sldb-continue in the right buffer.

	* swank-backend.lisp (wait-for-input):
	* swank-cmucl.lisp (wait-for-input):
	* swank-clisp.lisp (wait-for-input): Use the idiom
	"(when (check-slime-interrupts) (return :interrupt))".

2008-09-15  Helmut Eller  <heller@common-lisp.net>

	Interrupt related hacking.

	* swank-backend.lisp (*pending-slime-interrupts*): Should be
	thread-local.  Leave global value unbound.

	* swank.lisp (with-interrupts-enabled%): New helper macro.
	(with-slime-interrupts, without-slime-interrupts): Use it.
	(call-with-connection): Bind *pending-slime-interrupts* here.
	(wait-for-event): Add a report-interrupt argument.  Currently used
	by the debugger to detect when a nested debugger session, which
	was triggered by an interrupt in wait-for-event, returns.  Doesn't
	work well, though.

	* slime.el (slime-test-interrupt-in-debugger): New test.

2008-09-14  Helmut Eller  <heller@common-lisp.net>

	Introduce a WAIT-FOR-INPUT backend function.
	CMUCL's blocking input functions READ-CHAR etc.
	are hard to use with interrupts.  In the backend
	we have a more realistic chance to get interrupts working.

	* swank-backend.lisp (wait-for-input): New function.

	* swank-cmucl.lisp, swank-clisp.lisp (wait-for-input): Implement
	it.

	* swank.lisp (wait-for-event/event-loop): Use WAIT-FOR-INPUT and
	rescan the event-queue if WAIT-FOR-INPUT was interrupted.
	(reader-event): Deleted. Merged into wait-for-event/event-loop
	resp.  dispatch-loop.
	(decode-message): Drop the timeout argument.
	(*events-enqueued*): A counter to quickly detect new events after
	a wait.
	(call-with-connection): If the argument is already the current
	connection, don't rebind anything.
	(without-slime-interrupts, with-slime-interrupts): Don't rebind
	*pending-slime-interrupts*. Just to be save.

	* slime.el (sldb-maybe-kill-buffer): New function, to handle
	the case when the debugger was interrupted in WAIT-FOR-INPUT and
	we want to return to the previous debug level.

2008-09-12  Helmut Eller  <heller@common-lisp.net>

	For Lispworks, parse the $LWHOME/lwdoc file.

	* swank-lispworks.lisp (lwdoc, lookup-lwdoc, parse-lwdoc-record):
	New functions.
	(describe-symbol-for-emacs): Use it.

2008-09-12  Tobias C. Rittweiler  <tcr@freebits.de>

	In an SLDB buffer, `C-c C-c' will now recompile the source behind
	a frame. In particular, `C-u C-c C-c' will recompile the frame
	with high debug settings.

	* slime.el (sldb-recompile-frame-source): New function.
	(sldb-mode-map): Bind `C-c C-c' to it.

	* slime.el (sldb-overlays, sldb-delete-overlays, slime-xref-cleanup):
	Removed. Sldb-overlays weren't created anymore since 2008-08-17.

2008-09-12  Tobias C. Rittweiler  <tcr@freebits.de>

	New faces: `sldb-restartable-frame-line-face',
	           `sldb-non-restartable-frame-line-face'.

	The former is the face for frames that are surely restartable, the
	latter for frames that are surely not restartable. If
	restartability of a frame cannot be reliably determined, the face
	`sldb-frame-line-face' is used.

	At the moment, determination of frame restartability is supported
	by the SBCL backend only.

	* slime.el (sldb-frame.string): New.
	(sldb-frame.number): New.
	(sldb-frame.plist): New.
	(sldb-prune-initial-frames): Use them.
	(sldb-insert-frames): Ditto.
	(sldb-compute-frame-face): New.
	(sldb-insert-frame): Use `sldb-compute-frame-face' to insert
	frames with one of the faces described above.

	* swank.lisp (defslimefun backtrace): Changed return value; each
	frame is now accompanied with a PLIST which at the moment can
	contain :RESTARTABLE NIL/T/:UNKNOWN depending on whether the frame
	is restartable, or not.

	* swank-backend.lisp (defstruct swank-frame): New structure.
	(compute-backtrace): Is now supposed to return a list of SWANK-FRAMEs.
	(print-frame): Renamed to PRINT-SWANK-FRAME.

	* swank-sbcl.lisp, swank-cmucl.lisp, swank-lispworks.lisp,
	* swank-allegro.lisp, swank-scl.lisp, swank-openmcl.lisp,
	* swank-abcl.lisp, swank-clisp.lisp: Adapted to swank-backend changes.

2008-09-11  Helmut Eller  <heller@common-lisp.net>

	* doc/slime-refcard.tex: Fix typos.

2008-09-11  Gary King <gwking@metabang.com>

	* swank-allegro.lisp (fspec-definition-locations): add declare
	ignores to prevent warnings

	(emacs-inspect): remove first definition on function since it
	was being overwritten by the next one. Wrap the method on t with
	a excl:without-redefinition-warnings to prevent warning.

2008-09-11  Helmut Eller  <heller@common-lisp.net>

	* swank-cmucl.lisp (slime-output-stream): Remove last-flush-time
	slot.
	(sos/flush): Renamed from sos/misc-force-output.  Don't try to be
	clever: no timestamps and no line buffering.
	(sos/write-char, sos/write-string): Renamed from sos/out
	resp. sos/sout.  Call output-fn outside without-interrupts.
	(sos/reset-buffer): New function.

2008-09-11  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-compilation-unit): Renamed to
	`slime-compilation-result'.
	(slime-last-compilation-unit): Renamed to
	`slime-last-compilation-result'.
	(slime-compiler-notes, slime-compiler-results): Adapted accordingly.
	(slime-compilation-finished): Ditto.

2008-09-11  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-popup-buffer-restore-snapshot): Make sure that
	the buffer-local variable containing the popup buffer's snapshot
	is set to nil in the right buffer.

2008-09-11  Tobias C. Rittweiler  <tcr@freebits.de>

	Reimplement recompilation support. The previous implementation
	involving specials was subtly broken with the :fd-handler
	communcation-style, because of serve-event's polite interplay with
	specials. (Cf. my slime-devel post "Per event bindings" on 2008-08-17.)

	* swank.lisp (with-swank-compilation-unit): Removed.
	(record-note-for-condition): Removed.
	(defstruct swank-compilation-unit): Renamed to
	`swank-compilation-result'.
	(swank-compilation-unit-for-emacs): Renamed to
	`swank-compilation-result-for-emacs'.
	(swank-compiler): Takes additional argument, the
	swank-compilation-result where caught notes should be accumulated
	into.
	(defslimefun compile-file-for-emacs): Adapted accordingly.
	(defslimefun compile-string-for-emacs): Ditto.
	(defslimefun compile-multiple-strings-for-emacs): New RPC call.

	* slime.el (slime-make-compile-expression-for-swank): Removed.
	(slime-compile-string): Don't use above function anymore. Adapted.
	(slime-recompile-locations): Rewritten to use new RPC call above.

2008-09-10  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-backend.lisp (*gray-stream-symbols*): Comment out
	STREAM-FILE-POSITION.

2008-09-10  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank.lisp (eval-for-emacs): Remove WITH-RETRY-RESTART again for
	simplicity reasons.

	(interactive-eval): Add WITH-RETRY-RESTART.
	(eval-and-grab-output): Ditto.
	(interactive-eval-region): Ditto.
	(re-evaluate-defvar): Ditto.
	(pprint-eval): Ditto.
	(repl-eval): Ditto.
	(eval-string-in-frame): Ditto.
	(pprint-eval-string-in-frame): Ditto.
	(init-inspector): Ditto.
	(inspect-in-frame): Ditto.

2008-09-09  Tobias C. Rittweiler  <tcr@freebits.de>

	A RETRY restart is provided for all Slime evaluation requests.

	The rationale is that restarting from a frame is mostly only
	possible for functions compiled with high debug settings; most
	functions aren't, however.

	[Alternatively, we could make EVAL-FOR-EMACS be compiled with a
	high debug level, so it'll become restartable. That would be
	non-obvious to the user, though, and would only work on those
	implementations that implement SWANK-BACKEND:RESTART-FRAME.]

	* swank.lisp (call-with-retry-restart): New function.
	(with-retry-restart): New macro.
	(eval-for-emacs): Use WITH-RETRY-RESTART.

2008-09-09  Tobias C. Rittweiler  <tcr@freebits.de>

	A package "Foo.Bar.1.0" was truncated to "0>" as REPL
	prompt. It'll now be displayed as "Bar.1.0>".

	* swank.lisp (auto-abbreviated-package-name): Adapted accordingly.

2008-08-31  Helmut Eller  <heller@common-lisp.net>

	* swank-backend.lisp (*gray-stream-symbols*): Remove
	stream-file-position because it's called stream-position in CCL.
	(make-fn-streams): Deleted.
	Update callers accordingly.

2008-08-30  Helmut Eller  <heller@common-lisp.net>

	* swank-sbcl.lisp (receive-if): Add #+/-linux to avoid yet more
	WITH-TIMEOUT related problems.

	* swank-gray.lisp (slime-input-stream): Remove the output stream
	slot.  Most of the time we can just call force-output.

	* slime.el [test](inspector): New test.

	* swank.lisp (prepare-part): Also wrap action elements
	in a list.  Reported by Ariel Badichi and Madhu.

2008-08-30  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-pop-to-buffer): Drop the norecord argument,
	since we can't support it easily in Emacs 21.
	Reported by Christophe Rhodes.

2008-08-30  Michael Weber  <michaelw+slime@foldr.org>

	* swank-gray.lisp (make-input-stream): fixed typos

2008-08-30  Michael Weber  <michaelw+slime@foldr.org>

	* swank-backend.lisp (*gray-stream-symbols*): added symbols
	stream-peek-char, stream-read-line, stream-file-position

2008-08-30  Mark Evenson <evenson@panix.com>

	* swank-abcl.lisp (make-output-stream, make-input-stream): provide
	the (trivial) definitions for MAKE-OUTPUT-STREAM and
	MAKE-INPUT-STREAM for ABCL.

2008-08-27  Helmut Eller  <heller@common-lisp.net>

	* slime.el (sldb-setup): Insert "No backtrace" if the backtrace is
	empty.

2008-08-27  Anton Vodonosov <avodonosov@yandex.ru>

	* swank-ecl.lisp: Add :load-toplevel and :execute to EVAL-WHENs to
	fix loading.

2008-08-27  Helmut Eller  <heller@common-lisp.net>

	* swank-cmucl.lisp (remove-sigio-handlers): Fix thinko.

	* swank.lisp (decode-message): Don't ignore EOF.
	(swank-debugger-hook): Remove the default-debugger restart.

2008-08-25  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-compute-modeline-package): Used `when-let'
	before its definition.
	(slime-compute-modeline-string): Display "PKG:" before "CON:".

2008-08-22  Helmut Eller  <heller@common-lisp.net>

	Some focus handling in multiframe setups.

	* slime.el (slime-pop-to-buffer): New function.
	(slime-switch-to-output-buffer): Use it.

2008-08-22  Helmut Eller  <heller@common-lisp.net>

	Use lazy lists in the inspector.

	* swank.lisp (lcons): New data type.
	(lcons*, lcons-car, lcons-cdr, llist-range): New functions.
	(emacs-inspect array): Use lazy lists.
	(istate>elisp): The istate.content is now be a lazy list.
	(iline): New utility.
	(prepare-range, prepare-part): Replaces inspector-content.

2008-08-22  Helmut Eller  <heller@common-lisp.net>

	Implement streams with a length limit.
	Use them to truncate printer output in backtraces.

	* swank-backend.lisp (make-output-stream, make-input-stream):
	Split make-fn-streams up into two functions.

	* swank.lisp (call/truncated-output-to-string): New function.
	(backtrace, istate>elisp, to-line): Use it.
	(frame-locals-for-emacs): Use to-line.

2008-08-22  Helmut Eller  <heller@common-lisp.net>

	In backtraces, escape newlines in strings as \n.

	* swank.lisp (*backtrace-pprint-dispatch-table*): New.
	(*backtrace-printer-bindings*): Use it.

2008-08-22  Stas Boukarev <stassats@gmail.com>

	* metering.lisp: Add deftypes for time-type and cons-type, which
	are not defined in newer versions of CCL.

2008-08-22  Stelian Ionescu <sionescu@common-lisp.net>

	* swank-ecl.lisp: Add a few EVAL-WHENs to fix compilation.

2008-08-22  Helmut Eller  <heller@common-lisp.net>

	Collect most of the inspector state in a structure.
	Truncate the printer output more aggressively.

	* swank.lisp (inspector-state): New structure.
	(*istate*): New variable holds the current state.
	(inspect-object, inspector-content, inspector-nth-part)
	(inspector-range, inspector-call-nth-action, describe-inspectee):
	Use it.
	(inspector-pop, inspector-next): Implemented forward/backward a
	bit differently.
	(emacs-inspect/printer-bindings, istate>elisp): New functions.
	(to-line, truncate-string): New functions.

2008-08-22  Tobias C. Rittweiler  <tcr@freebits.de>

	Compiling a file `let*.lisp' on SBCL via C-c C-k resulted in an
	error, because it parsed the asterisk to a wild pathname. Fix
	that.

	* swank-backend.lisp (definterface parse-emacs-filename): New.
	PARSE-NAMESTRING by default.

	* swank-sbcl.lisp (defimplementation parse-emacs-filename): Use
	SB-EXT:PARSE-NATIVE-NAMESTRING.

	* swank.lisp (compile-file-for-emacs): Use PARSE-EMACS-FILENAME.
	(compile-file-if-needed): Ditto.
	(load-file): Ditto.
	(swank-require): Ditto.

2008-08-18  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (install-fd-handler): Bind *emacs-connection* with
	with-connection, for case when the signal hander is called out of
	the blue.
	(swank-debugger-hook): Don't assume that the hook argument is
	#'swank-debugger-hook itself.

	* test.sh (usage): Use cat rather not echo for here-documents.

2008-08-17  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-inspector-show-source): New command.
	(slime-inspector-mode-map): Bind it to ".".
	(sldb-highlight-sexp): Use slime-flash-region rather than a
	permanent overlay.
	(slime-popup-buffer-quit): Must call bury-buffer without argument.

	* swank.lisp (find-source-location-for-emacs): New function.

	* slime.el (slime-add-local-hook): Renamed from add-local-hook.
	(slime-switch-to-output-buffer): Drop the connection argument.  It
	was never used.
	(slime-switch-to-output-buffer-search-all-frames): Deleted. Use
	display-buffer-reuse-frames instead.
	(slime-switch-to-output-buffer): Use pop-to-buffer to select the
	window and frame.

2008-08-15  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-switch-to-output-buffer): Fix regression
	discovered by Ariel Badichi. Programmatic invocation of this
	function expect this function to also set-buffer to the REPL
	buffer. Even though that's ugly, we do it for now, and declare it
	to be a FIXME.
	(slime-dispatch-event): Don't use `message' for the pipelined
	request message, but `slime-display-oneliner' which will truncate
	the form to be displayed.

2008-08-17  Helmut Eller  <heller@common-lisp.net>

	* swank-cmucl.lisp (waitpid): Don't use unix::pid-t, it's only
	defined for Linux.

	* swank-sbcl.lisp (sb-thread::get-foreground): Don't override.
	Let SBCL people fix this.

2008-08-17  B.Scott Michel <scooter.phd@gmail.com>

	* swank-loader.lisp (dump-image): Move this function to the end of
	the file to stop SBCL from reporting two times the same false
	alarm.

2008-08-15  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-popup-buffer-quit): Fix regression; we have to
	invoke `bury-buffer' without an argument to make it switch buffers
	for us (for the case when the snapshot wasn't restored.)

2008-08-15  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-list-compiler-notes): Only shrink if notes tree
	isn't displayed as being collapsed.

2008-08-15  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-popup-buffer-quit): If not kill, then at least
	bury the buffer.
	(slime-list-compiler-notes): Shrink the compiler-notes window.

2008-08-14  Tobias C. Rittweiler  <tcr@freebits.de>

	If another frame is already displaying a REPL, `C-c C-z' will now
	select this window instead of splitting the current frame, and
	displaying the REPL in the newly created window.

	* slime.el (slime-switch-to-output-buffer-search-all-frames): New
	variable to customize this behaviour, as it may not be optimal for
	people using multiple screens at once.
	(slime-switch-to-output-buffer): Adapted accordingly.

2008-08-14  Tobias C. Rittweiler  <tcr@freebits.de>

	Xref buffers: `M-,' in an Xref buffer will now revert to an Emacs
	state as of before the Xref command.

	* slime.el (slime-xref-mode-map): Add `slime-xref-retract' as `M-,'
	(slime-xref-retract): New. Restores the emacs snapshot unconditionally.
	(slime-xref-quit): Use it.

2008-08-14  Tobias C. Rittweiler  <tcr@freebits.de>

	Xref buffers: `q', and `SPC' will push onto the find-definition
	stack such that M-, will work afterwards.

	* slime.el (defstruct slime-emacs-snapshot): Also save the point
	explicitly.  It is implicitly stored already in the
	window-configuration, but inaccessible therein.
	(slime-current-emacs-snapshot, slime-set-emacs-snapshot): Adapted.
	(slime-push-definition-stack-from-snapshot): New. Reason for above
	changes.

	(slime-with-popup-buffer): Make sure that the current
	emacs-snapshot is taken, not only when the :emacs-snapshot
	argument is NIL at expansion time, but also on runtime.

	(slime-with-xref-buffer): The name of the Xref buffer was created
	at expansion time, but must be computed at runtime. Fix that.
	(slime-xref-quit): Use `slime-push-definition-stack-from-snapshot'
	(sime-xref-goto): Adapted to also push onto the stack.

	* slime.el (slime-compute-modeline-package): Cleaned up.
	(slime-update-modeline-string): Ditto.

2008-08-12  Helmut Eller  <heller@common-lisp.net>

	Add a dump-image function to the loader.

	* swank-loader.lisp (dump-image): New.

	* swank-backend.lisp (save-image): New interface.

	* swank-cmucl.lisp, swank-clisp.lisp, swank-sbcl.lisp
	(save-image): Implemented.

2008-08-12  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-repl-send-input): Disable modification hooks
	when marking old input.
	(slime-check-version): Use y-or-n-p.

2008-08-12  Helmut Eller  <heller@common-lisp.net>

	Finally handle reader-errors without disconnecting.

	* swank.lisp (decode-message): Convert reader-error conditions
	into :reader-error events.
	(dispatch-event): Send :reader-error events to Emacs.

	* slime.el (slime-dispatch-event): Display reader-errors.

2008-08-12  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (with-buffer-syntax): Take package as argument.
	(defslimefun): Derive the package for exporting from the symbol.

2008-08-12  Helmut Eller  <heller@common-lisp.net>

	Let SIGINT create a synthetic event.

	* swank.lisp (install-fd-handler,simple-serve-requests): Dispatch
	a :emacs-interrupt event in the SIGINT handler.

	* slime.el (slime-interrupt): Send nothing over the wire when
	SIGINT is used.

2008-08-11  Helmut Eller  <heller@common-lisp.net>

	* test.sh: Use batch mode by default.

2008-08-11  Helmut Eller  <heller@common-lisp.net>

	Improve interrupt safety for single-threaded lisps.

	* slime.el (slime-interrupt): Send a :emacs-interrupt message
	together with SIGINT.  SIGINT now means "check for new events"
	instead of "invoke the debugger".

	* swank-backend.lisp (install-sigint-handler)
	(call-with-user-break-handler): New functions.

	* swank.lisp (simple-serve-requests,install-fd-handler): Use it.
	(read-packet): New function. Check for interrupts.
	(decode-message): Use it.
	(wait-for-event/event-loop): Check for interrupts.

2008-08-11  Helmut Eller  <heller@common-lisp.net>

	* swank-abcl.lisp (preferred-communication-style): Return nil
	until we implement receive-if.

	* swank-openmcl.lisp (receive-if): Support timeout argument.
	* swank-allegro.lisp (receive-if): Ditto.

2008-08-11  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (*global-debugger*): Change default back to t.

2008-08-10  Helmut Eller  <heller@common-lisp.net>

	* swank-ecl.lisp (thread-id): Assign an non-nil id to unknown
	threads.

	* slime.el (slime-execute-tests): Call slime-test-should-fail-p
	before executing the test (which may close the connection).
	(def-slime-test): Use slime-sync-to-top-level with a timeout.
	(slime-temp-directory): New function.
	(slime-run-tests): Save repl-history in /tmp.
	(slime-repl-mode): Ignore persistent history if
	slime-repl-history-file is nil.
	(slime-quit-lisp-internal): New function.
	(slime-quit-lisp, slime-restart-inferior-lisp): Use it
	(slime-batch-test): Exit, if the Lisp isn't up and running after
	30 secs.

2008-08-10  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (wait-for-event): Add timeout argument.  This is used
	for :fd-handler and :sigio style where we only process events as
	long as we don't block.
	(wait-for-event/event-loop, read-event)
	(decode-message, receive-if): Ditto.
	(process-requests): Renamed from read-from-emacs.
	(handle-requests): Renamed from handle-request. Take timeout
	argument.  Update callers.
	(process-available-input): Deleted.
	(with-swank-error-handler): Renamed from
	with-reader-error-handler.
	(with-connection): Use it.

2008-08-10  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (invoke-slime-debugger): New function.
	Analagous to cl:invoke-debugger.
	(swank-debugger-hook): Use it.

2008-08-09  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-quit-lisp): Optionally send kill signal.
	(slime-quit-connection-at-point): Disconnect after some timeout.

2008-08-09  Helmut Eller  <heller@common-lisp.net>

	Fixes for heap dumping.

	* swank.lisp (*log-output*): Don't initialize at load-time,
	otherwise the stream would end up in a heap image.

2008-08-09  Helmut Eller  <heller@common-lisp.net>

	* swank-lispworks.lisp (defimplementation): Record location.

2008-08-09  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (*maximum-pipelined-output-chunks*): New variable

2008-08-09  Helmut Eller  <heller@common-lisp.net>

	Display the "Use default debugger" restart more prominently
	for testing.

	* swank.lisp (swank-debugger-hook): Bind a user visible restart
	to invoke the native debugger.
	(*global-debugger*): Make this nil by default.
	(sldb-loop): Minor cleanups.
	(sldb-break-with-default-debugger): Invoke the native debugger
	on top of the slime debugger.

	* slime.el (slime-simple-completions): Bind slime-current-thread
	to t so that completion is peformed in a fresh thread.
	(sldb-setup): Always pop to the debugger buffer.
	(sldb-activate): Optionally select the window.

	* swank-sbcl.lisp (sb-thread::get-foreground): Override this
	as the default implementation is unusable for Slime.

	* swank-lispworks.lisp (environment-display-notifier): Just
	return t.

2008-08-09  Helmut Eller  <heller@common-lisp.net>

	* swank-lispworks.lisp (disassemble-frame): Implemented.

2008-08-09  Tobias C. Rittweiler  <tcr@freebits.de>

	M-x slime doesn't destroy the window layout anymore when you
	switch windows/frames while the connection is being set up.

	* slime.el (slime-hide-inferior-lisp-buffer): Search for the
	inferior-lisp buffer's window in all frames.
	(slime-repl-update-banner): Do not pop to the REPL buffer.

2008-08-08  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el: Fixing `q' in Xref buffers.

	(slime-popup-buffer-snapshot-unchanged-p): New.
	(slime-popup-buffer-restore-snapshot): New.
	(slime-xref-quit): Can't use slime-popup-buffer directly. Instead
	implement its own quit behaviour using the above functions.

2008-08-08  Helmut Eller  <heller@common-lisp.net>

	Use wait-for-event instead of catch/throw where needed.

	* swank.lisp (read-user-input-from-emacs, y-or-n-p-in-emacs)
	(eval-in-emacs): Use wait-for-event.
	(make-tag): Replaces intern-catch-tag.
	(take-input): Deleted.
	(dispatch-event): Remove some redundancy.

2008-08-08  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el: Make xref buffers use `slime-with-popup-buffer',
	nee `slime-with-temp-buffer'.

	(slime-with-xref-buffer): Rewritten using a popup buffer.
	(slime-init-xref-buffer): Removed.
	(slime-display-xref-buffer): Removed.

2008-08-08  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el: Rename slime's temp-buffer to popup-buffer.

2008-08-08  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-compiler-notes-mode, slime-connection-ist-mode):
	Add slime-temp-buffer-mode-map to docstring.

2008-08-08  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-connections-buffer-name): New variable.
	(slime-list-connections): Use it.
	(def-slime-selector ?c): Ditto

2008-08-08  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el: Make the threads browser use `slime-with-temp-buffer'.

	(slime-temp-buffer-quit-function): New buffer-local
	variable. Defaults to `slime-temp-buffer-quit'.
	(slime-temp-buffer-mode): `q' invokes above variable now.

	(slime-threads-buffer-name): New variable.
	(slime-list-threads): Use slime-with-temp-buffer.
	(slime-update-threads-buffer): New. Lifted from
	slime-list-threads.
	(slime-thread-quit): Renamed to slime-quit-threads-buffer.

2008-08-08  Helmut Eller  <heller@common-lisp.net>

	Unify event dispatching for single and multi-threaded cases.

	* swank.lisp (send-to-control-thread,read-from-control-thread)
	(send-to-socket-io,read-from-socket-io): Deleted.
	(send-event, read-event, send-to-emacs)
	(signal-interrupt, use-threads-p): New functions.
	And more random changes.

2008-08-08  Helmut Eller  <heller@common-lisp.net>

	Spawn the auto-flush thread in the front end.
	This removes some copy&paste code in various backends.

	* swank.lisp (auto-flush-loop): New function.
	(open-streams): Use it.
	* swank-backend.lisp (make-stream-interactive): Deleted.

2008-08-08  Helmut Eller  <heller@common-lisp.net>

	* slime.el (test disconnect): Call slime-inferior-process
	with explicit connection argument to avoid clashes with
	buffer-local connections.

2008-08-08  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-create-macroexpansion-buffer): Make fontifying
	case insensitive as the result from macroexpansion is most likely
	printed all upper-case.

2008-08-07  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-with-temp-buffer): By default, no longer inherit
	the current connection.

2008-08-07  Tobias C. Rittweiler  <tcr@freebits.de>

	Previously, M-p at the REPL deleted the input if no match could be
	found in the history. Now the input is untouched.

	* slime.el (slime-repl-history-replace): Ditch delete-at-end-p
	argument.
	(slime-repl-next-input, slime-repl-previous-input): Adapted.
	(slime-repl-forward-input, slime-repl-backward-input): Ditto.

2008-08-07  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-with-temp-buffer): Renamed from
	slime-with-output-to-temp-buffer.  Initialize the buffer local
	buffer variables before and after running BODY, so that we don't
	need the mode argument.

2008-08-07  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (def-slime-test narrowing): Adapted to recent changes
	of `slime-with-output-to-temp-buffer'.

2008-08-07  Tobias C. Rittweiler  <tcr@freebits.de>

	Mode-Line will now display a buffer's connection, and a buffer's
	package. Furthermore, stale connections will also be indicated.

	* slime.el: (slime-update-modeline-package): Renamed to
	`slime-extended-modeline'.
	(slime-modeline-string),
	(slime-modeline-connection-name),
	(slime-modeline-connection-state): New variables.
	(slime-update-modeline-package): Renamed to
	`slime-compute-modeline-package'.
	(slime-compute-modeline-connection): New.
	(sime-compute-modeline-connection-state): New.
	(slime-compute-modeline-string): New.
	(slime-update-modeline-string): New.
	(slime-shall-we-update-modeline-p): New.
	(slime-update-modeline): New. Run periodically by idle timer.

	(slime-mode, slime-temp-buffer-mode): Install extended mode-line.

	(slime-stale-connection-p, slime-debugged-connection-p): New.
	(slime-compute-connection-state): New.
	(slime-connection-state-as-string): New.
	(slime-state-name): Removed.
	(slime-set-state): Removed.

	(slime-length>): Fix typecase.

2008-08-07  Helmut Eller  <heller@common-lisp.net>

	* swank-allegro.lisp, swank-cmucl.lisp,
	swank-scl.lisp (receive-if): Periodically check for interrupts.

2008-08-06  Nikodemus Siivola <nikodemus@random-state.net>

	* swank-sbcl.lisp (handle-notification-condition): resignal
	warnings as-is before replacing with COMPILER-CONDITION so that
	handlers higher up the stack can muffle them should they choose
	to. This silences redefinition warnings for definitions inside
	EVAL-WHEN :COMPILE-TOPLEVEL in newish SBCLs when compiling the
	file for a second time.
	(call-with-compilation-hooks): STYLE-WARNINGs are WARNINGs, and
	don't need a separate handler.

2008-08-06  Helmut Eller  <heller@common-lisp.net>

	* swank-sbcl.lisp (short-backtrace): New function.
	(thread-description): Use it.

	* slime.el (slime-show-apropos): Use lisp-syntax-table to make
	M-. more useful.

2008-08-06  Helmut Eller  <heller@common-lisp.net>

	Queue interrupts in various places.

	* swank-backend.lisp (*pending-slime-interrupts*): New variable.
	(check-slime-interrupts): New function.

	* swank-lispworks.lisp (receive-if): Use it.

	* swank-sbcl.lisp, swank-openmcl.lisp: Ditto.

	* swank.lisp (*slime-interrupts-enabled*): New variable.
	(with-slime-interrupts, without-slime-interrupts): New macros.
	(invoke-or-queue-interrupt): New function.
	(interrupt-worker-thread, eval-for-emacs, swank-debugger-hook)
	(debug-nth-thread, wait-for-event, read-from-emacs): Use them.

2008-08-05  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-with-output-to-temp-buffer): Make sure that we
	don't make the wrong buffer read-only.

	* swank-lispworks.lisp (make-stream-interactive): Run our own
	thread to periodically flush streams instead of relying on
	soft-force-output.

	* swank.lisp (encode-message): Inhibit interrupts
	while writing the length and the body.

	* swank-backend.lisp (make-recursive-lock)
	(call-with-recursive-lock-held): Deleted.  Make the default locks
	"recursive" instead.
	(thread-id): Add a default implementation which works
	with the default implementation of current-thread.

	* swank-gray.lisp (stream-write-string): New method.

	* swank-backend.lisp (*gray-stream-symbols*): Include
	write-string.

2008-08-04  Helmut Eller  <heller@common-lisp.net>

	* swank-gray.lisp (slime-output-stream): Undo last change.
	Make force-output and finish-output do the same.

2008-08-04  Masayuki Onjo <masayuki.onjo@gmail.com>

	Updates for CLISP-2.46.

	* swank-clisp.lisp (fspec-pathname, fspec-location): The structure
	of (documentation symbol 'sys::file) used to be (path . lines)
	but is now ((type path . lines) ...).

2008-08-04  Helmut Eller  <heller@common-lisp.net>

	* swank-gray.lisp (slime-output-stream): Add a slot
	"interactive-p" which should be true for streams which are flushed
	periodically by the Lisp system.  Update the relevant backends
	accordingly.

	* swank-scl.lisp (receive-if): Implemented.

	* swank-cmucl.lisp (receive,receive-if): Test for new messages in
	a loop.

	* swank.lisp (eval-for-emacs): Don't flush streams here as that
	may now block.

	* swank-lispworks.lisp (receive-if): Handle interrupts.

	* slime.el (slime-repl-clear-buffer): Delete stuff after the
	prompt too.
	(slime-with-output-to-temp-buffer): Add read-only argument.
	(slime-temp-buffer): Renamed from slime-get-temp-buffer-create.
	Drop noselect argument.

2008-08-03  Helmut Eller  <heller@common-lisp.net>

	Add some flow-control.

	* swank.lisp (make-output-function): Synchronize with Emacs on
	every 100th chunk of output.
	(wait-for-event,wait-for-event/event-loop,event-match-p): New
	functions.  Used to selectively wait for some events and to queue
	the other events.
	(dispatch-event, read-from-socket-io): Tag non-queueable events
	with :call.
	(read-from-control-thread, read-from-emacs): Process
	:call events only; enqueue the others.

	(*log-output*): Don't use synonym-streams here.  Dereference the
	symbol until we get at the real stream.
	(log-event): Escape non-ascii characters more carefully.

	* swank-backend.lisp (receive-if): New function.
	Update backends accordingly. (not yet for ABCL and SCL)

	* slime.el (slime-dispatch-event): Handle ping event.

2008-08-03  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el: Make code related to temp buffers more consistent.

	(slime-with-output-to-temp-buffer): Docstring update. New keyarg
	:connection to specify whether the current connection should be
	stored buffer-locally. New key arg :emacs-snapshot to explicitly
	pass the snapshot to be stored. The created buffer is not
	automatically set to slime-mode anymore.
	(slime-temp-buffer-mode): Add `C-c C-z', and `M-.' bindings to all
	temp buffers.

	(slime-list-compiler-notes): Use `slime-with-output-to-...',
	rename the buffer from "*compiler notes*" to "*SLIME
	Compiler-Notes*".
	(slime-compiler-notes-mode-map): Remove explicit binding of "q",
	as it's inherited from the temp buffer.
	(slime-edit-value-callback): Use `slime-with-output-to-...'.
	(slime-show-apropos): Adapted to above changes.
	(slime-macroexpansion-minor-mode): Removed "q" binding, as it's
	inherited.
	(slime-eval-macroexpand): Adapted. Rename buffer from "*SLIME
	macroexpansion*" to "*SLIME Macroexpansion*".
	(slime-list-connections): Use `slime-with-output-to-...', rename
	buffer from "*SLIME connections*" to "*SLIME Connections*".

2008-07-27  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (make-slime-buffer-location): New.
	(make-slime-file-location): New.

2008-07-29  Richard M Kreuter <kreuter@progn.net>

	Environment variables for Lisp process.

	* slime.el (slime-start, slime-maybe-start-lisp)
	(slime-reinitialize-inferior-lisp-p, slime-start-lisp)
	(slime-restart-sentinel): Pass new parameter "env" through.

2008-07-29  Richard M Kreuter <kreuter@progn.net>

	* swank-sbcl.lisp (add-sigio-handler, add-fd-handler): Be quiet
	as a workaround for non-properly initialized *debug-io*.

2008-07-29  Richard M Kreuter <kreuter@progn.net>

	Fix slime-quit-lisp in non-default REPL buffer.

	* slime.el (slime-quit-lisp): Killing the REPL buffer also removes
	the buffer local binding of slime-buffer-connection.  Remember the
	connection before killing the buffer.

2008-07-27  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix bug when invoking an abort
	restart on a failed compilation attempt.

	* swank-sbcl.lisp (swank-compile-string): If a compilation attempt
	fails, COMPILE-FILE returns NIL which we tried to LOAD. Fix that.

	* swank-backend.lisp (swank-compile-string, swank-compile-file):
	Document return value.

2008-07-23  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-loader.lisp (*contribs*): Added `swank-package-fu'.

2008-07-23  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-at-list-p): New. Returns t if point is at a list.
	(slime-at-expression-p): New. Similiar to `slime-in-expression-p'.
	(slime-end-of-list): New. Pendant to `slime-beginning-of-list'.

2008-07-19  Tobias C. Rittweiler  <tcr@freebits.de>

	REPL shortcuts now leave an appropriate Common Lisp form in the
	REPL history.

	* slime.el (slime-within-repl-shortcut-handler-p): New global. T
	if truly inside a repl shortcut handler invoked by ,foo on the
	REPL.
	(slime-handle-repl-shortcut): Bind above global appropriatly.
	(slime-repl-shortcut-eval): New; should be used in repl shortcut
	handlers instead of `slime-eval'.
	(slime-repl-shortcut-eval-async): New; should be used in repl
	shortcut handlers instead of `slime-eval-async'.
	(defslime-repl-shortcut): Update docstring.
	(slime-repl-set-package): Use slime-repl-shortcut-eval.
	(slime-set-default-directory): Ditto.
	(slime-sync-package-and-default-directory): Ditto.

2008-07-18  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-recompile-locations): Locations were potentially
	recompiled within a wrong package. Fix that.

2008-07-18  Tobias C. Rittweiler  <tcr@freebits.de>

	An explicit numeric value as prefix-arg given to `C-c C-c' will
	now represent the debug level the defun is compiled with;
	`C-u C-c C-c' defaults to maximum debug like before. (Now also
	works for recompilation commands in xref buffers.)

	* slime.el (slime-compilation-debug-level): Renamed from
	`slime-compile-with-maximum-debug'.
	(slime-normalize-optimization-level): New.
	(slime-compile-defun): Adapted accordingly.
	(slime-compile-region): Ditto.
	(slime-recompile-location): Added setting of debug-level.
	(slime-recompile-locations): Ditto.
	(slime-recompile-xref): Now takes debug-level prefix-arg.
	(slime-recompile-all-xrefs): Ditto.

	* swank-sbcl.lisp (defimplementation swank-compile-string):
	Adapted accordingly.

2008-07-16  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-xref-dspec-at-point): Make more robust.
	(slime-xref-insert-recompilation-flags): Ditto.
	(slime-column-max): New.

2008-07-16  Tobias C. Rittweiler  <tcr@freebits.de>

	Recompilation support added to xref buffers. You can now use
	`C-c C-c' in an xref buffer to recompile the defun represented by
	the xref at point. Similiarly, you can use `C-c C-k' to recompile
	all xrefs displayed.

	For example, if you've changed a macro, and want to recompile all
	the functions in the image which use that macro, you first call
	`slime-who-macroexpands' (C-c C-w RET), and then issues `C-c C-k'
	in the xref buffer that just popped up.

	[There's no guarantee that this will actually recompile all
	functions that depend on the changed macro, as this obviously
	depends on the quality of the backend's WHO-MACROEXPANDS
	implementation.]

	* swank.lisp: Introduced the notion of a SWANK-COMPILATION-UNIT,
	so we're able to compile different stuff comming from Slime one
	after the other, and have compiler notes &c. collected in a
	contiguous manner.

	(defstruct :swank-compilation-unit): New. Contains compilation
	notes, compilation results, etc.
	(*swank-compilation-unit*): New. Current Swank Compilation Unit.
	(with-swank-compilation-unit): New. Like WITH-COMPILATION-UNIT.
	(swank-compilation-unit-for-emacs): New.
	(swank-compiler): Adapted; collect compilation stuff into the
	current swank-compilation-unit.
	(compile-string-for-emacs): Use WITH-SWANK-COMPILATION-UNIT.
	(compile-file-for-emacs): Ditto.

	(*compiler-notes*, clear-compiler-notes): Removed.
	(compiler-notes-for-emacs): Removed.

	* slime.el (slime-compilation-unit, slime-last-compilation-unit),
	(slime-compiler-notes, slime-compiler-results): New/Adapted.

	(slime-make-compile-expression-for-swank): Factored out from
	`slime-compile-string'.
	(slime-recompile-location): New.
	(slime-recompile-locations): New.
	(slime-pop-to-location): &optional `where' arg can now also be
	'excursion to only reset the current-buffer, but not switch.

	(slime-xref-mode-map): Add `C-c C-c' and `C-c C-k'.
	(slime-xref-dspec-at-point): New.
	(slime-all-xrefs): New.
	(slime-recompile-xref): New.
	(slime-recompile-all-xrefs): New.
	(slime-make-xref-recompilation-cont): New.
	(slime-xref-inert-recompilation-flags): New.

	(slime-trim-whitespace): New utility.

2008-07-05  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank.lisp: Revert Melis' change from 2008-07-04; Global IO
	redirection seems currently to be broken, and while it's not due
	to that commit (it seems that it's been broken since longer), I
	want to be on a safe bet.

2008-07-05  Tobias C. Rittweiler  <tcr@freebits.de>

	`M-x slime-lisp-threads' will now contain a summary of what's
	currently executed in a thread that was created by Swank.

	* swank-backend.lisp (thread-description, set-thread-description):
	New interface functions to associate strings with threads.
	* swank-sbcl.lisp (thread-description, set-thread-description):
	Implemented.

	* swank.lisp (call-with-thread-description),
	(with-thread-description): New.
	(read-from-emacs): Now temporarily sets the thread-description of
	the current thread to a summary of what's going to be executed by
	the current request.
	(defslimefun list-threads): Changed return value to also contain
	a thread's description.

	* slime.el (slime-list-threads, slime-thread-insert): Adapted to
	new return value of LIST-THREADS.

2008-07-04  Gábor Melis  <mega@retes.hu>

	* swank.lisp (call-with-redirected-io): Rebind only standard
	streams if *GLOBALLY-REDIRECT-IO*. Fixes lost output after
	disconnect, reconnect.

2008-07-04  Willem Broekema  <metawilm@gmail.com>

	* slime-allegro.lisp (fspec-definition-locations): Workaround for
	the issue that Allegro does not record the source file location
	for methods defined inside a defgeneric form. The idea is that if
	the source location of a method is not found, then the defgeneric
	form is almost certainly the right place.

2008-07-04  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-call-defun): Properly signal error message when
	used in a context that is not a function definition.

2008-07-04  Richard M Kreuter  <kreuter@progn.net>

	* swank-sbcl.lisp (code-location-source-location),
	(code-location-debug-source-name): Patched for incompatible
	structure change in SBCL 1.0.18.10.

2008-07-04  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-call-defun): Broken on DEFMETHOD forms. Fix
	that. Also, don't insert package qualifier anymore if the inserted
	qualifier is the same as the current REPL package.

2008-07-02  Martin Simmons  <martin@lispworks.com>
	* swank-lispworks.lisp (install-debugger-globally): hook into the
	environment globally to catch BREAK.

2008-06-07  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (def-slime-test find-definition.2, arglist):
	SWANK:COMPILE-STRING-FOR-EMACS since recently takes 5 instead of 4
	parameters. Fix that.

2008-06-07  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-extract-context, slime-parse-context): Recognize
	more toplevel forms, e.g. DEFINE-COMPILER-MACRO &c. Such that
	`slime-parse-toplevel-form' will also recognize these.
	(slime-trace-query): Adapted to above changes. Errors if spec is
	untraceable.
	(slime-call-defun): Adapted to also support the new toplevel forms.

	(slime-cl-symbol-name),
	(slime-cl-symbol-package),
	(slime-qualify-cl-symbol-name): Resurrected from the `slime-parse'
	contrib, as they've been used by `slime-call-defun'.

2008-06-02  Raymond Toy  <toy.raymond@gmail.com>

	Unicode support for CMUCL.

	* swank-cmucl.lisp (accept-connection, make-socket-io-stream):
	Handle external-format argument.
	(find-external-format): Implemented.
	(*external-format-to-coding-system*): New variable.

2008-05-19  Helmut Eller  <heller@common-lisp.net>

	* swank-sbcl.lisp: Don't require asdf.

2008-05-19  Helmut Eller  <heller@common-lisp.net>

	* swank-sbcl.lisp (swank-compile-string): Add reader-conditionals
	for sb-ext::restrict-compiler-policy.

2008-05-19  Geo Carncross  <geocar@gmail.com>

	* contrib/swank-asdf.lisp: Require asdf.

2008-05-17  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-prin1-to-string): Bind print-length and
	print-level.

2008-05-17  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-inspector-limit): New variable.
	(slime-inspector-insert-content): Use it.
	(slime-inspector-fetch-chunk, slime-inspector-fetch)
	(slime-inspector-next-range, slime-inspector-join-chunks): New.

2008-05-08  Geo Carncross  <geocar@gmail.com>

	* swank-ecl.lisp (call-with-debugging-environment)
	(frame-decode-env): Bugfix: qualify fixnump

2008-05-01  Geo Carncross  <geocar@gmail.com>

	* swank-ecl.lisp (call-with-debugging-environment)
	(is-ignorable-fun-p, is-swank-source-p, in-swank-package-p):
	Trim swank sources from the ECL backtrace.

2008-04-30  Geo Carncross  <geocar@gmail.com>

	* swank-ecl.lisp (call-with-debugging-environment)
	(in-swank-package-p): Remove frames from the backtrace that are
	in a swank package as those are misleading. Fixup locals
	display.

2008-04-29  Geo Carncross  <geocar@gmail.com>

	* swank-ecl.lisp: Backtrace and frame/eval improvements

2008-04-24  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-backend.lisp: Clarified docstrings of interface functions
	in the Debugging section.

2008-04-23  Geo Carncross  <geocar@gmail.com>

	* swank-source-file-cache.lisp (skip-comments-and-whitespace):
	Include #\Page as whitespace

	* swank-ecl.lisp (find-source-location): Initial support for
	find-source-location with functions
	(flush-streams): Workaround differences in different ECL versions
	(find-definitions): basic/simple implementation of find-definitions

	* swank-loader.lisp (*sysdep-files*): Include swank-source-path-parser
	and swank-source-file-cache for ECL


2008-04-17  Travis Cross <travis@travislists.com>

	* swank.asd: Don't make a compile-op a no-op so that a
	swank-loader.fasl file gets generated and (require 'swank) can be
	called multiple times.

2008-04-17  Zach Beane <xach@xach.com>

	C-c C-c with prefix args now uses the maximal debug level.
	Only implemented for SBCL.

	* slime.el (slime-compile-with-maximum-debug): New variable.
	(slime-compile-defun, slime-compile-region): Use it.

	* swank.lisp (compile-string-for-emacs): Accept new debug
	argument. Update backend accordingly.

2008-04-17  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-set-default-directory): Send absolute filenames.

2008-04-06  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-edit-definition): The `slime-edit-definition-hooks'
	are now invoked with the same args as `slime-edit-definition'.

2008-03-27  Martin Simmons <martin@lispworks.com>

	* swank-lispworks.lisp (map-error-database): Make mapping work for
	LispWorks 5.1 too.

2008-03-26  Tobias C. Rittweiler  <tcr@freebits.de>

	On SBCL,

	  (block outta
	    (let ((*debugger-hook* #'(lambda (c hook)
				       (declare (ignore hook))
				       (return-from outta 42))))
	      (error "FOO")))

	would just silently skip over the *DEBUGGER-HOOK*, and pop right
	into SLDB to handle the error. Fix that.

	* swank-sbcl (make-invoke-debugger-hook): New function; returns a
	hook for SB-EXT:*INVOKE-DEBUGGER-HOOK* that checks for the
	presence of *DEBUGGER-HOOK*, and calls that if available.
	(install-debugger-globally): Use it.
	(call-with-debugger-hook): Ditto.

	(getpid): Declaim return type explicitly, to make SBCL shut up about
	being unable to optimize %SAP-ALIEN in ENABLE-SIGIO-ON-FD.

	* slime.el (def-slime-test break): Test additionally that BREAK
	turns into SLDB even when *DEBUGGER-HOOK* is locally bound.
	(def-slime-test locally-bound-debugger-hook): New test case; tests
	that a locally-bound *DEBUGGER-HOOK* is adhered, and not skipped.

2008-03-26  Helmut Eller  <heller@common-lisp.net>

	By default, don't ask if SLIME should be started.

	* slime.el (slime-auto-connect): New variable.
	(slime-auto-connect): New function.
	(slime-connection): Use it.

2008-03-24  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-check-version): New function.  Make the
	prompt fit in a single line.

	* swank-loader.lisp (load-swank): Call swank::before-init.

	* swank.lisp (before-init): New function.
	(init): Renamed from setup.

2008-03-24  Tobias C. Rittweiler  <tcr@freebits.de>

	* HACKING: Updated due to broken links.
	Reported by Mirko Vukovic.

2008-03-24  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-set-connection-info): Display SLIME and SWANK
	versions explicitly in Protocol Mismatch message.  Adapted from
	idea and patch by Jeronimo Pellegrini.

2008-03-24  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-source-path-parser.lisp

	The source parser READs in files, and if such a file contains some
	nasty #. hackery that results in an error being signalled, M-. would
	fail on anything that's defined in those files. Fix that by using
	a special #. reader function that invokes the original #. reader
	with an IGNORE-ERRORS wrapped around.

	(make-sharpdot-reader): New function.
	(make-source-recording-readtable): Use it and install it on #.

	* slime.el (find-definition.2): New test case to guard against it.

2008-03-18  Geo Carncross <geocar@gmail.com>

	* swank-ecl.lisp: ECL moved gray streams into GRAY package.

2008-03-18  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-xref-group): Handle :zip files.

2008-03-17  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-source-path-parser.lisp:

	Multibyte characters in files could screw up compiler-notes
	highlighting on SBCL. Fix that.

	(skip-toplevel-forms): Abstracted out from READ-SOURCE-FORM.
	(source-path-file-position): Don't operate on the file stream
	directly, since CL:FILE-POSITION may not return character but
	binary offsets on such streams; instead slurp file content into a
	buffer string, and operate on that.

2008-03-16  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank.lisp (load-file-set-package): Removed; the function was
	only used in `slime-load-file-set-package' which invokes
	`slime-repl-set-package' which set the package for a second time.

	* slime.lisp (slime-load-file-set-package): Don't call
	SWANK:LOAD-FILE-SET-PACKAGE, but merely call SWANK:LOAD-FILE,
	then invoke `slime-repl-set-package' which will set the package.

	(slime-pretty-find-buffer-package): Removed. (Nowhere used.)
	(slime-set-package): Ditto.

2008-03-14  Helmut Eller  <heller@common-lisp.net>

	Remove some rarely used code.

	* slime.el (with-lexical-bindings): Removed.  Updated callers
	accordingly.
	(slime-make-default-connection, slime-choose-connection)
	(slime-find-connection-by-name, slime-symbol-at-point): Remove.
	Unused code.
	(slime-obsolete-commands, slime-bind-obsolete-commands)
	(slime-bind-obsolete-command, slime-upgrade-notice)
	(slime-timebomb, slime-timebomb-progress, slime-timebomb-message):
	Remove.  Obsolete.

2008-03-14  Helmut Eller  <heller@common-lisp.net>

	Move filename translation code to contrib.

	* slime.el (slime-find-filename-translators)
	(slime-filename-translations): Move to contrib/slime-tramp.el.
	(slime-to-lisp-filename-function)
	(slime-from-lisp-filename-function): New variables.

2008-03-14  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-repl-return-behaviour): Deleted.  Rebind
	the key if you don't like what the command does.

2008-03-14  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank.lisp (classify-symbol, symbol-classification->string): Add
	classification of symbols denoting type specifier, and denoting
	constants.

2008-03-13  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-eval-macroexpand): Indent expansion.

2008-03-13  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-edit-definition-cont): If no definition could
	be found, print also the package name in the error message where
	the definition was tried to be found in.

2008-03-13  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-region-for-defun-function): Deleted.
	(slime-region-for-defun-at-point): Use beginning-of-defun
	and not beginning-of-sexp.
	(slime-flash-region): New function.
	(slime-compile-region): Use it.

2008-03-13  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-xref-group): Renamed from slime-location-to-string.
	Handle source-form locations.

2008-03-12  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-find-definitions-function): Renamed from
	slime-edit-definition-fallback-function.
	(slime-find-definitions): Use it.
	(slime-find-tag-if-tags-table-visited): Deleted.

2008-03-12  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-inspector-operate-on-point): Signal an error if
	there is no object to operate on.

2008-03-08  Helmut Eller  <heller@common-lisp.net>

	* slime.el (sldb-toggle-details): Inhibit point-motion-hooks.
	This is a workaround for problems with the --more-- field.

2008-03-07  Helmut Eller  <heller@common-lisp.net>

	Be GC friendlier when parsing net packets.

	* slime.el (slime-net-read): Instead of consing a fresh string,
	use narrow-to-region and read the packet out of the buffer.

2008-03-04  Helmut Eller  <heller@common-lisp.net>

	* test.sh: Updated for Emacs 23.

2008-03-04  Andreas Fuchs <asf@boinkor.net>

	* swank.asd (asdf:output-files, asdf:perform): Make compile-op on
	swank-loader-file a noop.

2008-03-02  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-edit-definition-hooks): This variable can be
	used to hook into the M-. machinery.
	(slime-edit-definition): Run above hooks until one succeeds. By
	default, try to find a definition for the symbol at point.

2008-02-28  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (find-definition-for-thing): New DEFSLIMEFUN.

	* swank-backend (find-source-location): New DEFINTERFACE.

	* swank-sbcl (find-source-location): Implement it.

	* slime.el (slime-edit-definition-cont): Use `slime-length='.

2008-02-28  Tobias C. Rittweiler  <tcr@freebits.de>

	Fix regressions in the `find-definition' test case on SBCL:

	M-. on e.g. SWANK::READ-FROM-EMACS would bring the user to

	  (|defun read-from-emacs ...)

	and not

	  |(defun read-from-emacs ...)

	* swank-sbcl.lisp (source-file-position): Don't 1+ the returned
	position; i.e. return a position usable as a CL /file position/
	which start from 0, and not a position usable in Emacs where
	buffer points start from 1. This is important because the return
	value is passed to SWANK-BACKEND::READ-SNIPPET which invokes
	CL:FILE-POSITION on it.
	(make-definition-source-location): Adapted to 1+ the position
	passed to Emacs, to reflect above change.

2008-02-25  Helmut Eller  <heller@common-lisp.net>

	Make it easier to prepare core-files.

	* swank-loader.lisp (init): Two new keyword args: :SETUP and
	:LOAD-CONTRIBS.  :SETUP=nil can be used to suppress init hooks and
	loading user init files.

	* swank.asd: Call swank-loader:init with :SETUP=nil.

	* swank.lisp (init-global-stream-redirection): Guard against
	redirecting already redirected streams.

2008-02-24  Helmut Eller  <heller@common-lisp.net>

	Work harder to avoid wrong guesses for slime-repl-set-package.

	* slime.el (slime-repl-set-package): Use slime-pretty-package-name
	to strip double quotes from slime-current-package before comparing
	it with slime-lisp-package.  Still doesn't deal with nicknames and
	other reader tricks.

2008-02-23  Ariel Badichi <abadichi@bezeqint.net>

	Allow ED-IN-EMACS to edit new files.

	* swank.lisp (ed-in-emacs): Accept non-existing files.
	(canonicalize-filename): Merged into ed-in-emacs.

2008-02-23  Nikodemus Siivola  <nikodemus@random-state.net>

	If there is no connection, offer the option to start SLIME.

	* slime.el (slime-connection): Ask and maybe start SLIME.
	(slime-selector-method: ?r): No need to ask here any more.

2008-02-23  Helmut Eller  <heller@common-lisp.net>

	In the inspector, show one-element lists as list not as pair.

	* swank.lisp (emacs-inspect cons)

2008-02-23  Zach Beane  <xach@xach.com>

	Add customization variable for the `slime-connect' port.

	* slime.el (slime-port): New variable.

2008-02-22  Mark Evenson <mark.evenson@gmx.at>

	* swank-abcl.lisp (getpid): Return '0' in case of error.
	Apparently needed bacause $PPID isn't not a standard feature.
	"[T]his is not a disentanglement from, but a progressive knotting
	into."

2008-02-22  Mark Harig <idirectscm@aim.com>

	Fix typos: "contribs" -> "contrib".

	* slime-autoloads.el (slime-setup-contribs):
	* slime.el (slime-setup):

2008-02-22  Mark Harig <idirectscm@aim.com>

	Fixes for CLISP 2.44.

	* swank-clisp.lisp (sldb-backtrace, %parse-stack-values):
	sys::frame-up-1 no longer exists; use sys::frame-up instead.

2008-02-22  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-pop-to-location): Slight cleanups.
	(slime-goto-xref, slime-goto-next-xref): Use it.

2008-02-22  Helmut Eller  <heller@common-lisp.net>

	Remove save-restriction-if-possible.

	* slime.el (save-restriction-if-possible): Deleted.  It was only
	used in one place.
	(slime-goto-source-location): Obey widen-automatically.
	(slime-location-offset): New function.

2008-02-21  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-location-to-string): New function.
	(slime-analyze-xrefs): Use it; display definitions defined
	interactively via C-c C-c as comming from #<buffer foo.lisp>
	instead of foo.lisp.

2008-02-20  Helmut Eller  <heller@common-lisp.net>

	Better factorization for M-. and xref commands.

	* slime.el (slime-xref): Renamed from slime-definition.
	(slime-location, slime-location-p): New ADT def.
	(slime-xref-has-location-p, slime-analyze-xrefs): New functions.
	This work used to be done on the Lisp side.
	(slime-pop-to-location): New function.
	(slime-edit-definition, slime-edit-definition-cont): Simplified.
	(slime-find-definitions): New function.
	(slime-goto-definition, slime-goto-definition-other-window)
	(slime-pop-to-other-window, slime-show-definitions): Deleted.
	(slime-insert-xrefs): Simplified.
	(slime-insert-xref-location): Deleted. No need to show the filename
	twice.

	* swank.lisp (find-definitions-for-emacs, xref): Use common
	representation for "definitions" and "xrefs".
	(xref>elisp): New helper.
	(group-xrefs, alistify, parition, location-position<, xref-position)
	(xref-buffer, location-valid-p): Deleted. This work is now done on
	the Emacs side.

2008-02-20  Helmut Eller  <heller@common-lisp.net>

	Emit a warning if the SWANK package already exists.

	* swank-loader.lisp (init): Issue a warning when SWANK will not be
	reloaded.

2008-02-18  Helmut Eller  <heller@common-lisp.net>

	Minor cleanups for inspector code.

	* swank.lisp (inspector-content, inspect-list-aux): Slight
	cleanups.

2008-02-17  Marco Baringer  <mb@bese.it>

	* swank.asd: Update for recent changes to swank-loader.lisp, we
	need to call swank-loader::init after loading.

2008-02-16  Helmut Eller  <heller@common-lisp.net>

	In the REPL, mark the trailing newline also as input.

	* slime.el (slime-repl-send-input): Mark the newline with
	the 'slime-repl-old-input property.
	(slime-repl-grab-old-input): Strip the newline.

2008-02-16  Helmut Eller  <heller@common-lisp.net>

	Split loading and initialization (again).

	* swank-loader.lisp (init): New.  Delete old packages only if
	explicitly requested.  Also, if the swank package already exists
	don't load swank again.
	(setup): New function.

	* swank.lisp (setup): New function.  Moved over here from
	swank-loader.lisp.

	* slime.el (slime-init-command): Call swank-loader:init.

2008-02-10  Helmut Eller  <heller@common-lisp.net>

	Remove remaining traces of make-default-inspector.

	* swank-scl.lisp (make-default-inspector, scl-inspector): Deleted.
	* swank-lispworks.lisp (make-default-inspector)
	(lispworks-inspector): Deleted.

2008-02-09  Helmut Eller  <heller@common-lisp.net>

	Drop the first return value of emacs-inspect.

	* swank.lisp (emacs-inspect): Drop the first return value. It
	wasn't used anymore.  Update all methods and callers.

2008-02-09  Helmut Eller  <heller@common-lisp.net>

	Remove obsolete *slime-inspect-contents-limit*.

	* swank.lisp (*slime-inspect-contents-limit*): Deleted and all its
	uses.  The new implementation isn't specific to hash-tables or
	arrays.

2008-02-09  Helmut Eller  <heller@common-lisp.net>

	Limit the length of the inspector content.
	That's similar to the limitation of the length of backtraces in
	the debugger.

	* swank.lisp (*inspectee-content*): New variable.
	(content-range): New function.
	(inspect-object): Use it with a length of 1000.
	(inspector-range): New function. Called from Emacs.

	* slime.el (slime-inspector-insert-content)
	(slime-inspector-insert-range, slime-inspector-insert-range-button)
	(slime-inspector-fetch-range): New functions.
	(slime-inspector-operate-on-point): Handle range-buttons.

2008-02-09  Helmut Eller  <heller@common-lisp.net>

	Make slime-property-bounds more useful.

	* slime.el (slime-property-bounds): Remove special casing for
	whitespace at the end.
	(slime-repl-send-input): Don't mark the newline with the
	slime-repl-old-input property.
	(sldb-frame-region): Use slime-property-bounds.

2008-02-09  Helmut Eller  <heller@common-lisp.net>

	Inspector cleanups.

	* swank.lisp (emacs-inspect): Renamed from inspect-for-emacs.
	Changed all method-defs accordingly.
	(common-seperated-spec, inspector-princ): Moved to
	swank-fancy-inspector.lisp.
	(inspector-content): Renamed from inspector-content-for-emacs.
	(value-part): Renamed from value-part-for-emacs.
	(action-part): Renamed from action-part-for-emacs.
	(inspect-list): Renamed from inspect-for-emacs-list.
	(inspect-list-aux): New.
	(inspect-cons): Renamed from inspect-for-emacs-simple-cons.
	(*inspect-length*): Deleted.
	(inspect-list): Ignore max-length stuff.
	(inspector-content): Don't allow nil elements.
	(emacs-inspect array): Make the label of element type more
	consistent with the others.

2008-02-09  Helmut Eller  <heller@common-lisp.net>

	Cleanup slime-repl-set-package.

	* slime.el (slime-repl-set-package): Make it fit within 80 columns.

2008-02-05  Marco Baringer  <mb@bese.it>

	* slime.el (slime-search-buffer-package): Ask the lisp to read the
	in-package form so that we properly deal with #+foo and |WHATEVER|
	package names.
	(slime-repl-set-package): Only prompt with a default package if
	the repl's package is different from the current package.

2008-02-04  Marco Baringer  <mb@bese.it>

	* swank-openmcl.lisp (ccl::advise ccl::break): advise the
	lower-level ccl::cbreak-loop instead of cl:break.
	(frame-locals): If the value is a value-cell (a closed over value)
	show the closed over value and not the value cell.
	(disassemble-frame): add in x86-64 code.

	* slime-autoloads.el (slime-setup-contribs): Add contribs
	directory to load-path.

	* slime.el (slime-setup): Add contribs directory to load-path.

	* swank-abcl.lisp, swank-allegro.lisp, swank-backend.lisp,
	swank-clisp.lisp, swank-cmucl.lisp, swank-corman.lisp,
	swank-ecl.lisp, swank-lispworks.lisp, swank-openmcl.lisp,
	swank-sbcl.lisp, swank-scl.lisp, swank.lisp,
	contrib/swank-fancy-inspector.lisp: Remove second argument from
	swank:inspect-for-emacs. This functionality, choosing an inspector
	at runtime, was never actually used and is, now, needless
	complexity.

2008-02-04  Helmut Eller  <heller@common-lisp.net>

	Simpler code to bind 0-9 in the debugger.

	* slime.el (sldb-mode-map): When binding the keys 0-9, use eval
	instead of two macros.

2008-02-04  Helmut Eller  <heller@common-lisp.net>

	Move some functions to swank-arglist.lisp.

	* swank.lisp (length=, ensure-list, recursively-empty-p)
	(maybecall, exactly-one-p, read-softly-from-string)
	(unintern-in-home-package, valid-function-name-p): Moved to
	contrib/swank-arglist.lisp.

2008-02-03  Marco Baringer  <mb@bese.it>

	* swank.lisp (*sldb-condition-printer*): New variable.
	(safe-condition-message): Use the current binding
	of *sldb-condition-printer* to print the condition to a string.

	* slime.el (sldb-invoke-restart-by-name): New function. Invokes a
	restart by name, uses completion to read restart's name.
	(slime-define-keys sldb-mode-map): Bind
	sldb-invoke-restart-by-name to I in sldb buffers.

	* swank-loader.lisp: When loading swank delete all swank packages
	first. This protects the lisp from broken reloads of swank. Leave
	the swank-loader package so that users can set *fasl-directory*
	and *source-directory* as per the documentation.
	(lisp-version-string): On openmcl use the full
	cl:lisp-implementation-version, ccl::*openmcl-major-version* and
	ccl::*openmcl-minor-version* aren't sufficently precise to notice
	changes in openmcl's cvs.

2008-01-27  Helmut Eller  <heller@common-lisp.net>

	Make it easier to start a non-default Lisp from ELisp code.

	* slime.el (slime): If the argument is a symbol start the
	corresponding entry in slime-lisp-implementations.
	Typical use is something like:
	  (defun cmucl () (interactive) (slime 'cmucl))

2008-01-22  Luís Oliveira  <loliveira@common-lisp.net>

	* swank-source-path-parser.lisp (make-source-recording-readtable):
	don't suppress the #. reader macro.
	(read-and-record-source-map): don't bind *read-eval* to nil.
	(suppress-sharp-dot): unused, delete it.

	* slime.el (test compile-defun): test with #+#.'(:and).

2008-01-21  Helmut Eller  <heller@common-lisp.net>

	* slime.el (sldb-mode): Don't throw to toplevel in the
	kill-buffer-hook, since the buffer can be killed for other reasons
	too.
	(test break): Test BREAK and CONTINUE in a loop.
	(slime-wait-condition): Display the current time.

2008-01-20  Matthias Koeppe  <mkoeppe@mail.math.uni-magdeburg.de>

	New hooks that allow the slime-presentations contrib to hook
	into the debugger and inspector.

	* slime.el (sldb-insert-frame-variable-value-function): New
	variable.
	(sldb-insert-frame-variable-value): New function, default value
	for sldb-insert-frame-variable-value-function.
	(sldb-insert-locals): Use it here.

	* slime.el (slime-inspector-insert-ispec-function): New variable.
	(slime-open-inspector): Use it here.

2008-01-20  Matthias Koeppe  <mkoeppe@mail.math.uni-magdeburg.de>

	* doc/slime.texi (Presentations): Improve documentation of
	presentations.

2008-01-19  Geo Carncross  <geocar@gmail.com>

	* swank-ecl.lisp (inspect-for-emacs): Make ECL inspection better;
	should be able to handle all builtin types and CLOS objects now.

2008-01-17 Nikodemus Siivola <nikodemus@random-state.net>

	* swank-sbcl.lisp (sbcl-source-file-p): When a buffer is not
	associated with any file, M-. for names defined there ends up
	calling SBCL-SOURCE-FILE-P with NIL -- guard against that.

2008-01-14  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (sldb-mode): Add `sldb-quit' to `kill-buffer-hook' to
	close the debugging machinery on swank side when the SLDB buffer
	is killed. (Notice that killing the SLDB buffer manually will not
	restore window configuration in contrast to typing `q'.)

2008-01-10  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-delete-and-extract-region): New
	function. Portable version of `delete-and-extract-region' which
	returned NIL instead of "", as experienced by Matthias Koeppe.

2008-01-09  Matthias Koeppe  <mkoeppe@mail.math.uni-magdeburg.de>

	* slime.el (slime-repl-mode-map): Bind C-c C-t to
	slime-toggle-trace-fdefinition (as in Lisp buffers) instead of
	slime-repl-clear-buffer.  This binding is useful for untracing
	functions directly from the trace output.  Move
	slime-repl-clear-buffer to the keybinding C-c M-o.

2008-01-04  Juho Snellman  <jsnell@iki.fi>

	* swank-sbcl.lisp (source-file-source-location): Use the
	debootstrap readtable when appropriate (fixes occasional reader
	errors when using "v" on debugger frames that point to functions
	defined in SBCL). Likewise for the debootstrapping packages.
	(code-location-debug-source-name): Ensure that we always return a
	physical namestring, Emacs won't like a pathname or a logical
	namestring.

2008-01-02  Luís Oliveira  <loliveira@common-lisp.net>

	Use sane default values for slime-repl-set-package.

	Previously, when typing `,!p' at the REPL, the current package
	would have been inserted as a default (although the whole intent
	was to /change/ the current package in the first place), now
	nothing is inserted anymore.

	* slime.el (slime-pretty-current-package): rename it to
	slime-pretty-find-buffer-package and make it use
	slime-find-buffer-package instead of slime-current-package.
	(slime-repl-set-package, slime-set-package): use new function.

2008-01-02  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-print-apropos): Simplified: Don't insert action
	properties anymore for the symbol; they were ignored anyway,
	because `apropos-follow' (bound to RET in the resulting
	*SLIME Apropos* buffer) looks for buttons only.

2008-01-02  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-apropos): Update docstring: Apropos doesn't
	match on regular expressions anymore since 2007-11-24.

2007-12-22  Douglas Crosher <dcrosher@common-lisp.net>

	* swank-scl.lisp (set-stream-timeout, make-socket-io-stream): update
	for Scieneer CL 1.3.7.

2007-12-21  Geo Carncross  <geocar@gmail.com>

	* swank-ecl.lisp: try to parse the Args: line in most ecl functions to
	make modeline/autodoc more interesting

2007-12-20  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank.lisp (read-softly-from-string): Now actually returns all
	three values as explained in its docstring.

2007-12-14  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-insert-xref-location): New function. Tries to
	either insert the file name a function is defined in, or inserts
	information about the buffer a function was interactively
	`C-c C-c'd from. Idea from Knut Olav Bøhmer.
	(slime-insert-xrefs): Use it.

2007-12-14  Geo Carncross  <geocar@gmail.com>

	* Add ECL threads implementation to swank

2007-12-04  Helmut Eller  <heller@common-lisp.net>

	Simplify the inspector.

	* swank.lisp (inspect-object): Ignore the title value returned
	from backends.

	* slime.el (slime-open-inspector): Updated accordingly.

2007-12-04  Helmut Eller  <heller@common-lisp.net>

	Fix slime-list-thread selector.

	* slime.el (slime-list-threads): Wait for the result before
	continuing.

2007-12-04  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-repl-insert-result): Use slime-repl-emit-result
	since handling of markers has changed.
	(slime-repl-emit-result): New argument: bol.

2007-12-02  Alan Caulkins <fatman@maxint.net>

	Make it possible to close listening sockets.

	* swank.lisp (stop-server, restart-server): New functions.
	(*listener-sockets*): New variable.
	(setup-server): Store open sockets in *listener-sockets*.

2007-12-02  Helmut Eller  <heller@common-lisp.net>

	Add hook to customize the region used by C-c C-c.
	Useful to recognize block declarations in CMUCL sources.

	* slime.el (slime-region-for-defun-function): New variable.
	(slime-region-for-defun-at-point): Use it.

2007-11-30  Helmut Eller  <heller@common-lisp.net>

	Handle byte-functions without debug-info.

	* swank-cmucl.lisp (byte-function-location): Return an error
	if the component has no debug-info.

2007-11-30  Helmut Eller  <heller@common-lisp.net>

	Disable the pretty-printer for backtraces.
	Would be nice if we could print newlines in strings as \n.

	* swank.lisp (*backtrace-printer-bindings*):  New varaible.
	(backtrace, frame-locals-for-emacs): Use it.

2007-11-29  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank.lisp (valid-function-name-p): Fixed wrt. setf functions.

2007-11-29  Helmut Eller  <heller@common-lisp.net>

	Prettify package names for slime-repl-set-package.

	* slime.el (slime-repl-set-package): slime-current-package may
	have leading colons.  Use slime-pretty-package-name to remove
	them.  Reported by Constantine Vetoshev.
	(slime-pretty-current-package): New function.
	(slime-set-package): Use it.

2007-11-24  Helmut Eller  <heller@common-lisp.net>

	Drop remaining dependencies on nregex.

	* swank-lispworks.lisp (unmangle-unfun): Use sys::setf-symbol-p
	instead of regexp matching.

	* swank-loader.lisp (*sysdep-files*): Don't include nregex.

2007-11-24  Helmut Eller  <heller@common-lisp.net>

	Mirror *modules* in Emacs.

	* slime.el (slime-lisp-modules): New connction variable.
	(slime-set-connection-info): Load requested modules.
	(slime-required-modules): New variable.
	(slime-require, slime-load-contribs): New functions.

	* swank.lisp (connection-info): Include *modules*.
	(swank-require): Accept a list of modules as argument.

2007-11-24  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (parse-package): The old version didn't pass the
	test-suite.  Now use the reader directly instead of emulating it
	half-heartedly.

	* slime.el (slime-search-buffer-package): Don't remove double
	quotes or "#:", swank:parse-package takes care of that.

2007-11-24  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (apropos-symbols):  Use simple search instead of
	regexps.
	(make-apropos-matcher): Used to be make-regexp-matcher.

	(*sldb-printer-bindings*): Set *print-right-margin* to
	most-positive-fixnum. This prints each frame in the backtrace in a
	single long line.  But is suboptimal for other purposes, like
	eval-in-frame.

	(setup-server): Initialize multiprocessing here, so that is also
	done for create-server.

2007-11-23  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank.lisp (swank-require): Fix typo (:key was used instead of
	:test.)  Reported by Stelian Ionescu.

2007-11-22  Helmut Eller  <heller@common-lisp.net>

	* swank.lisp (swank-require): Don't search the file if the
	module-name is present in *modules*. That should avoid problems if
	swank is included in a core file and moved to a different
	location.  Reported by John Wiegley.

2007-11-19  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-repl-mode-map, slime-repl-read-mode),
	(slime-compiler-notes-mode-map, slime-xref-mode-map),
	(sldb-mode-map, slime-connection-list-mode-map),
	(slime-inspector-mode-map): Added bindings for [return] in
	addition to (kbd "RET"). The reason is that pressing enter in X is
	translated to (kbd "RET") only if no binding for [return] is
	active; if [return] is bound to something, pressing enter is
	translated to this key binding henceforth, as was explained to me
	by Pierre Gaston, thanks! This can cause quite confusing behaviour
	as Andreas Davour faced in his post
	<cs9k5ofqbt7.fsf@Psilocybe.Update.UU.SE> to comp.lang.lisp.

2007-11-06  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-events-buffer, slime-inspector-buffer): Disable
	undo.

2007-11-01  Tobias C. Rittweiler  <tcr@freebits.de>

	The inspector page layout has changed slightly. Before the header
	looked like

	  A proper list.
            [type: CONS]
	  -------------------

	It now looks like

	  #<CONS {B3DBD39}>:
	     A proper list.
	  --------------------

	Rationale is to have a "presentation link" to the currently
	inspected object itself, to copy it down to the REPL via `M-RET'.
	This is mostly useful when trying to get a value from the Slime
	Debugger to the REPL, which you can do by inspecting the value
	first by `i', and then using `M-RET' on the object representation
	in the new header layout.

	Such a "presentation link" existed already but was removed in
	2007-08-23. The old behaviour was to have the title ("A proper
	list" in the above example) to contain the link. I decided to make
	the link more explicit.

	* swank.lisp (inspect-object): Now additionally returns a
	string-representation of the object itself, and an inspector id
	for it. Removed returning its type as this is implicit in the new
	string representation.

	* slime.el (slime-open-inspector): Adapted for new header layout.

2007-10-22  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank.lisp (read-softly-from-string, unintern-in-home-package):
	Moved from `contrib/swank-arglist.lisp'.
	(parse-package): Use them. (Removes FIXME about interning
	symbols.)  Also changed the logic somewhat to avoid passing :|| to
	FIND-PACKAGE as ECL chokes on that.

2007-10-22  Steve Smith  <tarkasteve@gmail.com>

	* swank-loader.lisp (compile-files-if-needed-serially): Added
	missing `load' argument to function definition on Corman Lisp /
	ECL.

2007-10-22  Mark Evenson  <mark.evenson@gmx.at>

	* swank-abcl.lisp (getpid): Implemented.

2007-10-22  R. Matthew Emerson  <rme@thoughtstuff.com>

	* swank-openmcl.lisp (closure-closed-over-values): Use
	CCL::NTH-IMMEDIATE instead of CCL::%SVREF.  This makes it work on
	x86-64 OpenMCL. (The %SVREF worked on PPC, but this will work on
	both.)

2007-09-27  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-filesystem-toplevel-directory): New function.
	Windows doesn't have a filesystem that is as hierarchical as the
	Unix' one. Reported by Carsten Blaauw and Stefan Kluehspies.
	(slime-file-name-merge-source-root): Use it.
	(slime-highlight-differences-in-dirname): Use it.

2007-09-26  Utz-Uwe Haus  <haus+slime@mail.math.uni-magdeburg.de>

	* swank-allegro.lisp (fspec-definition-locations): Allow the
	POSITION datum of :top-level-form fspecs to be missing.  This
	apparently helpful for Allegro CL 8.1.

2007-09-21  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-length=, slime-length>): Restore support for
	vectors, as `slime-length=' was already used with strings in
	`slime-parse.el'. This broke extended arglist display.

2007-09-20  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-setup): Call the respective init functions of
	contribs.

	* slime-autoloads.el (slime-setup-contribs): Ditto.

2007-09-19  Helmut Eller  <heller@common-lisp.net>

	Simplify slime-compile-file.

	* slime.el (slime-compile-file): Don't save window config.
	(slime-curry, slime-rcurry): New functions.

	* slime.el (slime-complete-symbol*-fancy): Move defcustom to
	contrib/slime-c-p-c.el

	* swank-version.el: Delete file. No longer used.

	* bridge.el: Moved to contrib.

	* tree-widget.el: File deleted. Only needed by contribs and is
	distributed with Emacs 21.

	* slime.el: Reorder some devfars and menus code so that the
	compiler doesn't complain about free variables.

	Fix apropos in Emacs 22.

	* slime.el (slime-print-apropos): Add button props for Emacs 22.
	(slime-call-describer): ARG is a marker in Emacs 22.

	(def-slime-selector-method ?c): Wait until slime-list-threads
	returns.

	Remove define-slime-dialect.

	* slime.el (define-slime-dialect): Deleted. Use
	slime-lisp-implementations instead.

	Introduce a slime-start-and-init function.

	* slime.el (slime-start-and-init, slime-lisp-options): New
	functions.
	(slime-start-and-load): Use it.

	Simplify slime-length=.

	* slime.el (slime-length=, slime-length>): No need for vectors.

	Remove explicit support for Scheme mode.

	* slime.el (slime-scheme-mode-hook, slime-shared-lisp-mode-hook)
	Deleted.
	(slime-indentation-update-hooks): New hook.
	(slime-handle-indentation-update): Use it.

	Fix close-connection.

	* swank.lisp (close-connection): Use *log-output* instead of
	*debug-io* (which could be redirected to the to-be-closed
	connection).

2007-09-15  Helmut Eller  <heller@common-lisp.net>

	Let slime-setup load contribs.

	* slime.el (slime-setup): Take a list of contribs to load as
	argument.

	* slime-autoloads.el (slime-setup): Ditto, but delay the actual
	loading until slime is loaded.
	(slime-setup-contribs): New function.

2007-09-15  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-maybe-warn-for-different-source-root): Catch
	returned NIL from `slime-file-name-merge-source-root' if the two
	filenames don't share a common source root.
	Reported by Frank Goenninger.

2007-09-15  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-split-string): New semi-portability function.
	The behaviour of `split-string' changed between Emacs21 and
	Emacs22. Thanks to Christophe Rhodes for reporting this.
	(slime-file-name-merge-source-root): Use `slime-split-string'.
	(slime-highlight-differences-in-dirname): Likewise.

2007-09-14  Helmut Eller  <heller@common-lisp.net>

	Some cleanups for the REPL.

	* slime.el (slime-repl-write-string): Split it up into smaller
	functions.
	(slime-repl-emit, slime-repl-emit-result)
	(slime-emit-string): New functions.

	(slime-repl-save-history): Use prin1 instead of pp.

	(repl-type-ahead): New test case.

2007-09-12  Christophe Rhodes  <csr21@cantab.net>

	Make ASDF:LOAD-OP (and SBCL REQUIRE) happy with swank.asd

	* swank.asd: Define and use a CL-SCRIPT-FILE class for loading as
	source, even with ASDF:LOAD-OP.

2007-09-11  Tobias C. Rittweiler  <tcr@freebits.de>

	* swank-loader.lisp: Aways compile-file `contrib/swank-asdf.lisp'
	on SBCL. This fixes "Undefined function" style-warnings when using
	`slime-asdf' in combination with SBCL. Reported by Cyrus Harmon.

	* swank-sbcl.lisp: Explicitly require ASDF. (While this is not
	strictly necessary, as it's implicitly loaded on requiring the
	other modules, I think it's better to be explicit about it.)

2007-09-10  Helmut Eller  <heller@common-lisp.net>

	Fix some bugs introduced while moving doc refs to contrib.

	* swank-sbcl.lisp (condition-references): It's still needed.

	* slime.el (sldb-dispatch-extras): Add missing quote.
	(slime-sbcl-manual-root): Move definition to
	contrib/slime-references.el.
	(slime-cl-symbol-name, slime-cl-symbol-package): Move to
	contrib/slime-parse.el.

2007-09-10  Helmut Eller  <heller@common-lisp.net>

	Move SBCL doc references to contrib.

	* slime.el (sldb-insert-condition): Merge REFERENCES and EXTRAS.
	(sldb-extras-hooks, sldb-dispatch-extras): New hook.

	* swank-backend.lisp (condition-references): Removed. Merged with
	condition-extras.

	* swank-sbcl.lisp (condition-references): Removed.
	(condition-extras): Include references.
	(externalize-reference): New function.  Don't return plain
	symbols.

	* swank-allegro.lisp (condition-references): Removed.

2007-09-10  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-cl-symbol-name, slime-cl-symbol-package):
	Ressurected, as they're still used in this file.
	Reported by Edward Cant.

2007-09-10  Tobias C. Rittweiler  <tcr@freebits.de>

	When working on multiple source trees simultaneously, the way
	`slime-edit-definition' (M-.) works can sometimes be confusing:

	`M-.' visits locations that are present in the current Lisp image,
	which works perfectly well as long as the image reflects the
	source tree that one is currently looking at.

	In the other case, however, one can easily end up visiting a file
	in a different source root directory (the one corresponding to the
	Lisp image), and is thus easily tricked to modify the wrong source
	files---which can lead to quite some stressfull cursing.

	If the variable `slime-warn-when-possibly-tricked-by-M-.' is
	T (the default), a warning message is issued to raise the user's
	attention whenever `M-.' is about opening a file in a different
	source root that also exists in the source root directory of the
	user's _current buffer_.

	There's no guarantee that all possible cases are covered, but if
	you encounter such a warning, it's a strong indication that you
	should check twice before modifying.

	* slime.el (slime-file-name-merge-source-root): New function.
	(slime-highlight-differences-in-dirname): New function.
	(slime-maybe-warn-for-different-source-root): New function.
	(slime-warn-when-possibly-tricked-by-M-.): New variable (T by default.)
	(slime-goto-location-buffer): Where appropriate, call
	`slime-maybe-warn-for-different-source-root'

2007-09-08  Stelian Ionescu  <sionescu@common-lisp.net>

	* slime.el (save-restriction-if-possible): Place macro definition
	above use of the macro, to regain ability to byte-compile-file.

2007-09-08  Tobias C. Rittweiler  <tcr@freebits.de>

	Fix message displaying on XEmacs. Reported by Steven E. Harris,
	and Ken Causey.

	* slime.el (slime-display-message): Resurrect secondary
	`buffer-name' argument which got lost in 2007-08-24.
	(slime-format-display-message): Resurrect passing "*SLIME Note*"
	as default buffer-name to `slime-display-message'.

2007-09-08  Matt Pillsbury  <mtbp@rci.rutgers.edu>

	* swank-backend.lisp (definterface): Updated docstring.

2007-09-06  Matthias Koeppe  <mkoeppe@mail.math.uni-magdeburg.de>

	* slime.el (slime-repl-write-string): Use case, not ecase, for
	dispatching targets.Should fix XEmacs compatibility.
	Reported by Steven E. Harris.

2007-09-05  Didier Verna  <didier@xemacs.org>

	* slime.el (slime-filename-translations): Fix custom type.

2007-09-05  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-toggle-trace-fdefinition):  Fix typo.  The
	 argument for interactive should be "P" not "p".

2007-09-04  Mark Evenson  <mark.evenson@gmx.at>

	* swank-abcl.lisp: Call accessors of compiler-condition at load
	time to work around some ABCL problems.

2007-09-04  Helmut Eller  <heller@common-lisp.net>

	Move asdf support to contrib.

	* swank-backend.lisp (operate-on-system): Moved to
	swank-asdf.lisp. It wasn't specialized in any backend.

	* swank.lisp (operate-on-system-for-emacs)
	(list-all-systems-known-to-asdf, list-asdf-systems): Moved to
	swank-asdf.lisp.

	* slime.el: Move asdf commands to contrib slime-adsf.el.

	* swank-loader.lisp: Load swank-asdf if ASDF is in
	*FEATURES*. Also add the contrib source directory to
	swank::*load-path*.

2007-09-04  Helmut Eller  <heller@common-lisp.net>

	* slime.el: Move tramp support to contrib.

2007-09-04  Helmut Eller  <heller@common-lisp.net>

	Move startup animation to contrib.

	* slime.el (slime-repl-banner-function): New hook.
	(slime-repl-update-banner): Use it and reset markers after calling
	it.
	(slime-set-default-directory): Don't call slime-repl-update-banner
	here.
	(slime-repl-insert-prompt): Set slime-repl-input-end-mark to
	point-max.

2007-09-04  Helmut Eller  <heller@common-lisp.net>

	* slime.el: Move inferior-slime-mode to contrib.

2007-09-04  Helmut Eller  <heller@common-lisp.net>

	* slime.el: Fix the test suite (except for SBCL).

2007-09-04  Helmut Eller  <heller@common-lisp.net>

	Simplify slime-process-available-input.

	* slime.el (slime-process-available-input): We are called in a
	process filter, i.e. at arbitrary times and in an aribtrary
	buffer.  So it doesn't make sense to save-and-restore the current
	buffer here
	(slime-eval-async): Instead, save and restore the buffer here.
	(slime-net-read-or-lose): New.

2007-09-04  Helmut Eller  <heller@common-lisp.net>

	Remove request-abort condition.

	* swank-backend.lisp (request-abort): Removed
	(abort-request): Removed.  Replace all (3) uses with ERROR.
	* swank.lisp (eval-for-emacs): No special case for request-abort.
	* slime.el (slime-eval-async): Remove optional arg of :abort.

2007-09-04  Helmut Eller  <heller@common-lisp.net>

	Rename slime-insert-possibly-as-rectangle to slime-insert-indented.

	* slime.el (slime-insert-indented): Renamed. Update callers.

2007-08-31  Helmut Eller  <heller@common-lisp.net>

	Move compound prefix completion and autodoc to contrib.

	* swank.lisp (simple-completions): Rewritten for simplicity.
	(operator-arglist): Rewritten for simplicity.

	* slime.el (slime-complete-symbol-function): Make simple
	completion the default.
	(slime-echo-arglist-function, slime-echo-arglist): New hook.

	Remove corresponding key bindigs.

	* slime.el (slime-obsolete-commands): New table. Use it to bind
	a command with an upgrade notice.

2007-08-31  Andreas Fuchs <asf@boinkor.net>

	* slime.el (slime-reindent-defun): Fixed when used in lisp file
	buffers. (Similiar patch also provided by Gábor Melis; problem
	also reported by Jeff Cunningham.)

2007-08-31  Jon Allen Boone <ipmonger@delamancha.org>

	* swank-cmucl.lisp: CMUCL now has an x86-Darwin port as well as
	  the PPC-Darwin version. Changed to conditionalize on the
	  presence of darwin instead of ppc so that slime works with both
	  Darwin versions of CMUCL.

2007-08-31  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-sexp-at-point): Explicitely set current syntax
	table to operate in `lisp-mode-syntax-table' because
	`thing-at-point' is used which depends on the syntax table. (E.g.
	 keywords like `:foo' aren't recognized as sexp otherwise.)

	* slime.el (slime-parse-extended-operator/declare): Wrap regexp
	stuff in `save-match-data'
	(slime-internal-scratch-buffer): Removed again. Was only
	introduced as a performance hack; but it turned out that the bad
	performance was because of unneccessary recursive calls of
	`slime-make-form-spec-from-string'. (Which was fixed on 2007-08-27
	already.)
	(slime-make-form-spec-from-string): Use `with-temp-buffer' instead
	of `slime-internal-scratch-buffer'. Removed activation of
	`lisp-mode' in the temporary buffer, because this made
	`lisp-mode-hooks' run. This activated autodoc in the temp buffer,
	although the temp buffer is used to compute an autodoc
	itself (which resulted in some very mutual recursion which caused
	the current arglist to be displayed again and again---as could
	have been witnessed in `*Messages*'.) `Lisp-mode' was activated to
	get the right syntax-table for `slime-sexp-at-point', but this one
	sets the correct syntax-table itself now.

2007-08-28  Matthias Koeppe  <mkoeppe@mail.math.uni-magdeburg.de>

	Fix user input type-ahead again (this change from 2007-08-25 got
	lost).  Testcase: Type (dotimes (i 5) (format t "Number ~A~%"
	i) (sleep 1)) and then type ahead while the command is executing
	and output arrives.

	* slime.el (slime-repl-insert-prompt): Don't go to point-max but
	to slime-repl-input-start-mark if there is one.
	(slime-repl-write-string): Insert a :repl-result before the
	prompt, not at point-max.  Update markers properly.

2007-08-28  Helmut Eller  <heller@common-lisp.net>

	* swank-cmucl.lisp (safe-definition-finding): Remove whitespace
	around error messages.
	(trim-whitespace): New function.

2007-08-28  Helmut Eller  <heller@common-lisp.net>

	Fix some output related bugs.

	* swank.lisp (send-repl-results-to-emacs): Emit a fresh line.

	* slime.el (slime-insert-transcript-delimiter): Use
	insert-before-markers since slime-output-end is no longer left
	inserting.  Reported by Austin Haas <austin@pettomato.com>.

2007-08-28  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-display-or-scroll-completions,
	slime-scroll-completions): New functions.  Factored out of
	slime-expand-abbreviations-and-complete.

2007-08-28  Matthias Koeppe  <mkoeppe@mail.math.uni-magdeburg.de>

	* slime.el (slime-repl-write-string): Handle arbitrary targets
	using slime-output-target-marker.
	(slime-last-output-target-id, slime-output-target-to-marker)
	(slime-output-target-marker)
	(slime-redirect-trace-output): Move back here from
	slime-presentations.el.

2007-08-28  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (classify-symbol, symbol-classification->string):
	Resurrected in swank.lisp. (I was bitten by cvs-pcl which
	committed (2007-08-27) my locally changed `contribs/swank-fuzzy.lisp'
	where I already removed these functions from.)

2007-08-28  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-make-form-spec-from-string): Elisp Hacking 101:
	Don't use `beginning-of-buffer' and `end-of-buffer' in Elisp code.

	* swank.lisp (read-form-spec): Unintern just newly interned
	symbols when an reader error occurs.

2007-08-28  Helmut Eller  <heller@common-lisp.net>

	Move presentations to contrib.  Part II.

	* swank.lisp (*listener-eval-function*): New variables.
	(listener-eval): Use it
	(repl-eval): Used to be listener-eval.
	(*send-repl-results-function*): New variable.
	(eval-region): Simplify.
	(track-package, cat): New functions.
	(slime-repl-clear-buffer-hook): New hook.
	(slime-repl-clear-buffer): Use it.

2007-08-28  Matthias Koeppe  <mkoeppe@mail.math.uni-magdeburg.de>

	Remove the ID argument from :write-string protocol messages.
	Everything, except for rigid-indentation tricks, can be achieved
	by using :write-string in conjunction with :presentation-start and
	:presentation-end.

	* swank.lisp (present-in-emacs): Unused, removed.

	* swank.lisp (make-output-function-for-target): Remove id argument
	from :write-string.
	(send-repl-results-to-emacs): Don't call
	save-presented-object. Remove id argument from :write-string.

	* slime.el (slime-dispatch-event): Change it here.
	(slime-write-string, slime-repl-write-string): And here.

2007-08-28  Matthias Koeppe  <mkoeppe@mail.math.uni-magdeburg.de>

	* swank-loader.lisp (*contribs*): Add swank-presentations.

2007-08-27  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-make-extended-operator-parser/look-ahead): Move
	to end of symbol at point.
	(slime-make-form-spec-from-string): Fixes unexpected behaviour of
	`save-excursion'.

2007-08-27  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-sexp-at-point): Fixes a few edge cases were
	Emacs' `(thing-at-point 'sexp)' behaves suboptimally. For example,
	`foo(bar baz)' where point is at the ?\(.
	(slime-internal-scratch-buffer): New. This variable holds an
	internal scratch buffer that can be reused instead of having to
	create a new temporary buffer again and again.
	(slime-make-extended-operator-parser/look-ahead): Uses
	`slime-make-form-spec-from-string' to parse nested expressions
	properly.
	(slime-nesting-until-point): Added docstring.
	(slime-make-form-spec-from-string): Added new optional parameter
	for stripping the operator off the passed string representation of
	a form. Necessary to work in the context of
	`slime-make-extended-operator-parser/look-ahead'. Added safety check
	against a possible endless recursion.

	* swank.lisp (parse-form-spec): Looses restriction for nesting.

2007-08-27  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-eval-feature-conditional): Fix typo.
	(slime-keywordify): Simplify.

2007-08-27  Helmut Eller  <heller@common-lisp.net>

	Move presentations to contrib.  Part I.

	* slime.el (slime-event-hooks, slime-dispatch-event): New hook.
	(slime-write-string-function, slime-write-string): New hook.
	(slime-repl-return-hooks, slime-repl-return): New hook.
	(slime-repl-current-input-hooks, slime-repl-current-input): New hook.
	(slime-open-stream-hooks, slime-open-stream-to-lisp): New hook.
	(sldb-insert-locals, slime-inspector-insert-ispec)
	(slime-last-expression): Don't use presentations.

2007-08-26  Tobias C. Rittweiler <tcr@freebits.de>

	Reduces needless interning of symbols that was introduced by my
	recent work on autodoc to a minimum. Also fixes this issue for
	`slime-complete-form' which always interned symbols even before my
	changes.

	* slime.el (slime-sexp-at-point): If N is given, but there aren't
	N sexps available at point, make it return a list of just as many
	as there are.
	(slime-make-form-spec-from-string): New. Creates a ``raw form
	spec'' from a string that's suited for determining newly interned
	symbols later in Swank.
	(slime-parse-extended-operator/declare): Uses it.

	* swank.lisp (parse-symbol): Returns internal knowledge, to
	provide a means for callers to perform a sanity check.
	(call-with-ignored-reader-errors): New. Abstracted out from
	`read-incomplete-form-from-string.'

	* swank.lisp (read-form-spec): New. Only READs elements of a form
	spec if necessary. And if it does have to READ, it keeps track
	of newly interned symbols which are returned as secondary
	return value.
	(parse-form-spec): Use it. Propagate newly interned symbols.
	(parse-first-valid-form-spec): Likewise.
	(arglist-for-echo-area, complete-form, completions-for-keyword):
	Adapted to unintern the newly interned symbols.


2007-08-26  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (current-slime-narrowing-configuration):
	Renamed to `slime-current-narrowing-configuration'.
	(set-slime-narrowing-configuration):
	Renamed to `slime-set-narrowing-configuration'.
	(current-slime-emacs-snapshot):
	Renamed to `slime-current-emacs-snapshot'.
	(current-slime-emacs-snapshot-fingerprint):
	Renamed to `slime-current-emacs-snapshot-fingerprint'.
	(set-slime-emacs-snapshot):
	Renamed to `slime-set-emacs-snapshot'.

2007-08-26  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (save-restriction-if-possible): Fixed another typo,
	duh! Thanks again to Matthias Koeppe.

2007-08-26  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-cl-symbol-name): Handle vertical bars (|)
	(%slime-nesting-until-point): Renamed to `slime-nesting-until-point'.

2007-08-25  Matthias Koeppe  <mkoeppe@mail.math.uni-magdeburg.de>

	Fix a bug where REPL results would sometimes be indented by a
	random amount.

	* slime.el (slime-insert-presentation): Make the
	rectangle-ification of multi-line presentations, introduced
	2006-12-19, optional.
	(slime-write-string): Use it here only for regular output, but not
	for REPL results.
	(sldb-insert-locals): Use it here.
	(slime-inspector-insert-ispec): Use it here.

2007-08-25  Matthias Koeppe  <mkoeppe@mail.math.uni-magdeburg.de>

	Fix handling of user-input type-ahead in the REPL.
	Reported by Madhu <enometh@meer.net> on 2007-04-24.

	* slime.el (slime-write-string): Make sure text properties are
	rear-nonsticky, so typed-ahead user input does not pick up the
	text properties.  Fix up some markers.
	(slime-reset-repl-markers): Make the marker slime-output-end of
	insertion type nil (no automatic advances on insertions).
	(slime-with-output-end-mark): Update the location of
	slime-output-end here manually.
	(slime-repl-update-banner): Use insert-before-markers.

2007-08-25  Matthias Koeppe  <mkoeppe@mail.math.uni-magdeburg.de>

	New command slime-redirect-trace-output creates a separate Emacs
	buffer, where all subsequent trace output is sent.

	* slime.el (slime-last-output-target-id): New variable.
	(slime-output-target-to-marker): New variable.
	(slime-output-target-marker): New function.
	(slime-write-string): Handle general "target" arguments using
	slime-output-target-marker.
	(slime-redirect-trace-output): New command.
	(slime-easy-menu): Add a menu item for it.

	* slime.el (slime-mark-presentation-start)
	(slime-mark-presentation-end): Make "target" argument optional.
	Use slime-output-target-to-marker.

	* swank.lisp (make-output-stream-for-target): New function,
	factored out from open-streams.
	(open-streams): Use it here.

	* swank.lisp (connection): New slot "trace-output".
	(call-with-redirected-io): Use it here.
	(redirect-trace-output): New slimefun; set the slot to a new
	target stream.

2007-08-25  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (save-restriction-if-possible): Fixed typo in
	macroexpansion. Thanks to Matthias Koeppe for reporting.

2007-08-24  Matthias Koeppe  <mkoeppe@mail.math.uni-magdeburg.de>

	* slime.el (slime-insert-arglist): Removed, superseded by
	slime-complete-form since 2005-02-20.

	* swank.lisp (arglist-for-insertion): Now unused, removed.

2007-08-24  Matthias Koeppe  <mkoeppe@mail.math.uni-magdeburg.de>

	Some fixes to the presentation-streams contrib.

	* slime.el (slime-dispatch-event): Handle new optionals args of
	messages :presentation-start and :presentation-end.

	* slime.el (slime-mark-presentation-start)
	(slime-mark-presentation-end): New arg "target"; record
	presentation boundaries separately for REPL results and regular
	process output.  This fixes the presentation markup of REPL
	results when the presentation-streams contrib is loaded.

2007-08-24  Matthias Koeppe  <mkoeppe@mail.math.uni-magdeburg.de>

	Make the fancy presentation-streams feature a contrib.
	Previously, it was only available if "present.lisp" was loaded
	manually.  Now it can be loaded automatically using:

	   (add-hook 'slime-load-hook
	             (lambda () (require 'slime-presentation-streams)))

	Note that the normal presentations that are created by REPL
	results, the inspector, and the debugger are NOT dependent on this
	code.

	* present.lisp: Moved to contrib/swank-presentation-streams.lisp.
	* swank-loader.lisp (*contribs*): Add swank-presentation-streams.

2007-08-24  Helmut Eller  <heller@common-lisp.net>

	Move typeout frame to contrib.

	* slime.el (slime-message-function, slime-background-message-function)
	(slime-autodoc-message-function): New variables.
	(slime-message, slime-background-message)
	(slime-autodoc-message): Call the function in the respective
	variable, so that the typeout window can be plugged in.

2007-08-24  Helmut Eller  <heller@common-lisp.net>

	Move xref and class browser to contrib.

	* slime.el (slime-browse-classes, slime-browse-xrefs): Gone. The
	Common Lisp part is still there.

2007-08-24  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-forward-blanks): Wrapped w/ `ignore-errors.'
	(slime-sexp-at-point): Return results as a list of strings, rather
	than just one big string if called with arg > 1.
	(slime-parse-extended-operator-name): Wrapping some movement code
	in `ignore-errors'. Adapted to new return value of
	`slime-enclosing-form-specs'. Minor cosmetic changes.
	(slime-make-extended-operator-parser/look-ahead): Adapted to
	changes of the ``raw form spec'' format; returns a form of
	strings, instead of a string of a form.
	(slime-parse-extended-operator/declare): Simplified. Adapted to
	changes of the ``raw form spec'' format; passes decl-identifiers,
	or typespec-operators respectively, along the decl/type-spec.
	(%slime-in-mid-of-typespec-p): Removed. Replaced by an regexp
	based approach.
	(%slime-nesting-until-point): New helper for
	`slime-parse-extended-operator/declare'.

	* swank.lisp (parse-form-spec): Adapted to new ``raw form spec''
	format. Updated format description in docstring accordingly.  The
	new format allows less interning of wrong symbols names comming
	from Slime. Thanks to Matthias Koeppe for spotting this.

2007-08-24  Helmut Eller  <heller@common-lisp.net>

	Move slime-highlight-edits-mode to contrib.

2007-08-24  Helmut Eller  <heller@common-lisp.net>

	Move slime-scratch to contrib.

	* slime.el (slime-scratch): Gone.

2007-08-24  Helmut Eller  <heller@common-lisp.net>

	Various cleanups related to slime-insert-propertized.

	* slime.el (slime-with-rigid-indentation): Fix evaluation order.
	(slime-indent-rigidly): New.
	(slime-insert-possibly-as-rectange): Don't set mark.
	(slime-insert-propertized): Use plain insert instead of
	slime-insert-possibly-as-rectange.

2007-08-24  Helmut Eller  <heller@common-lisp.net>

	* swank-sbcl.lisp (sbcl-inspector): Fix typo.

2007-08-23  Matthias Koeppe  <mkoeppe@mail.math.uni-magdeburg.de>

	Repair inspection of presentations.

	* swank.lisp (inspect-presentation): New slimefun.
	* slime.el (slime-inspect-presentation-at-mouse): Use it here.

2007-08-23  Helmut Eller  <heller@common-lisp.net>

	Move Marco Baringer's inspector to contrib.

	* swank.lisp (*default-inspector*): New variable. Set this
	variable dispatch to different inspectors.
	(inspect-object): Use it.

	* swank-loader.lisp (*contribs*): Add 'swank-fancy-inspector.

	* swank-backend.lisp (backend-inspector): New class.  Introduce a
	named class to give as another way to dispatch to backend methods.

	* swank-cmucl.lisp: Use backend-inspector class.
	* swank-sbcl.lisp: Use backend-inspector class.
	* swank-clisp.lisp: Use backend-inspector class.
	* swank-lispworks.lisp: Use backend-inspector class.
	* swank-allegro.lisp: Use backend-inspector class.
	* swank-openmcl.lisp: Use backend-inspector class.
	* swank-abcl.lisp: Use backend-inspector class.
	* swank-corman.lisp: Use backend-inspector class.
	* swank-scl.lisp: Use backend-inspector class.

2007-08-23  Tobias C. Rittweiler <tcr@freebits.de>

	Added arglist display for declaration specifiers and type
	specifiers.

	Examples:

	`(declare (type' will display

	   (declare (type type-specifier &rest vars))

	`(declare (type (float' will display

	   [Typespec] (float &optional lower-limit upper-limit)

	`(declare (optimize' will display

	   (declare (optimize &any (safety 1) (space 1) (speed 1) ...))

	&ANY is a new lambda keyword that is introduced for arglist
	description purpose, and is very similiar to &KEY, but isn't based
	upon plists; they're more based upon *FEATURES* lists. (See the
	comment near the ARGLIST defstruct in `swank.lisp'.)

	* slime.el:
	(slime-to-feature-keyword): Renamed to `slime-keywordify'.
	(slime-eval-feature-conditional): Adapted to use `slime-keywordify'.
	(slime-ensure-list): New utility.
	(slime-sexp-at-point): Now takes an argument that specify how many
	sexps at point should be returned.
	(slime-enclosing-operator-names): Renamed to
	`slime-enclosing-form-specs'.
	(slime-enclosing-form-specs): Returns a list of ``raw form specs''
	instead of what was called ``extended operator names'' before, see
	`swank::parse-form-spec' for more information. This is a
	simplified superset. Additionally as tertiary return value return
	a list of points to let the caller see where each form spec is
	located. Adapted callers accordingly. Extended docstring.
	(slime-parse-extended-operator-name): Adapted to changes in
	`slime-enclosing-form-specs'. Now gets more context, and is such
	more powerful. This was needed to allow parsing DECLARE forms.
	(slime-make-extended-operator-parser/look-ahead): Because the
	protocol for arglist display was simplified, it was possible to
	replace the plethora of parsing function just by this one.
	(slime-extended-operator-name-parser-alist): Use it. Also add
	parser for DECLARE forms.
	(slime-parse-extended-operator/declare): Responsible for parsing
	DECLARE forms.
	(%slime-in-mid-of-typespec-p): Helper function for
	`slime-parse-extended-operator/declare'.
	(slime-incomplete-form-at-point): New. Return the ``raw form
	spec'' near point.
	(slime-complete-form): Use `slime-incomplete-form-at-point'.

	* swank.lisp: New Helper functions.
	(length=, ensure-list, recursively-empty-p): New.
	(maybecall, exactly-one-p): New.

	* swank.lisp (arglist-for-echo-area): Adapted to take ``raw form
	specs'' from Slime.
	(parse-form-spec): New. Takes a ``raw form spec'' and returns a
	``form spec'' for further processing in Swank. Docstring documents
	these two terms.
	(split-form-spec): New. Return relevant information from a form
	spec.
	(parse-first-valid-form-spec): Replaces `find-valid-operator-name'.
	(find-valid-operator-name): Removed.
	(operator-designator-to-form): Removed. Obsoleted by `parse-form-spec'.

	(defstruct arglist): Add `any-p' and `any-args' slots to contain
	arguments belonging to the &ANY lambda keyword.
	(print-arglist): Adapted to also print &ANY args.
	(print-decoded-arglist-as-template): Likewise.
	(decode-arglist): Adapted to also decode &ANY args.
	(remove-actual-args): Adapted to also remove &ANY args.
	(remove-&key-args): Split out from `remove-actual-args'.
	(remove-&any-args): New. Removes already provided &ANY args.
	(arglist-from-form-spec): New. Added detailed docstring.
	(arglist-dispatch): Dispatching generic function for
	`arglist-from-form-spec' that does all the work. Renamed from
	prior `form-completion'.
	(arglist-dispatch) Added methods for dealing with declaration and
	type-specifiers.
	(complete-form): Adapted to take ``raw form specs'' from Slime.
	(completions-for-keyword): Likewise.
	(format-arglist-for-echo-area): Removed. Not needed anymore.

	* swank-backend.lisp (declaration-arglist): New generic
	function. Returns the arglist for a given declaration
	identifier. (Backends are supposed to specialize it if they can
	provide additional information.)
	(type-specifier-arglist): New generic function. Returns the
	arglist for a given type-specifier operator. (Backends are
	supposed to specialize it if they can provide additional
	information.)
	(*type-specifier-arglists*): New variable. Contains the arglists
	for the type specifiers in Common Lisp.

	* swank-sbcl.lisp: Now depends upon sb-cltl2.
	(declaration-arglist 'optimize): Specialize the `optimize'
	declaration identifier to pass it to
	sb-cltl2:declaration-information.


2007-08-23  Helmut Eller  <heller@common-lisp.net>

	Some inspector cleanups.

	* slime.el (slime-inspect): Remove dwim stuff and drop keyword
	args.
	(slime-read-object): Killed.
	(slime-open-inspector): Drop keyword args.  Update callers
	accodordingly, expect presentation related code. Presentations no
	longer work in the inspector.

	* swank.lisp (*inspector-dwim-lookup-hooks*)
	(default-dwim-inspector-lookup-hook): Deleted.
	(init-inspector): Sanitize arglist.
	(inspect-object): Don't return an :id for *inspectee-parts*.

	* swank-backend (type-for-emacs): Removed. No backend implemented
	it.

2007-08-23  Helmut Eller  <heller@common-lisp.net>

	* slime.el (slime-fuzzy-upgrade-notice): New function.  Bound to
	the key where slime-fuzzy-complete-symbol used to be.

2007-08-22  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-close-all-parens-in-sexp): Fix interplay with
	`slime-close-parens-limit'. This should also affect
	`slime-complete-form' (C-c C-s) in a positive way.

2007-08-19  Helmut Eller  <heller@common-lisp.net>

	* contrib: New directory.  Move fuzzy completion code to that
	directory.

	* swank.lisp (swank-require): New function to load contrib code.
	(*find-module*, module-filename, *load-path*, merged-directory)
	(find-module, module-canditates): New. Pathname acrobatics for
	swank-require.

	* swank-loader.lisp: Compile (but don't load) contribs.
	(*contribs*, contrib-source-files): New.

2007-08-16  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-process-available-input): Correct yesterday's
	change: the buffer a request was originally performed in doesn't
	necessarily exist at this time anymore, so we check for buffer
	liveness now.

	 The problem arised when quitting in SLDB which would cause Swank
	 to send a `:debug-return' message before the acknowledgement
	 message for `sldb-quit' is sent. So the acknowledgement is
	 received in a context where the sldb-buffer is closed already.

2007-08-15  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-process-available-input): Make sure that the
	event received from SWANK is processed in the context of the
	original buffer the request of the response was performed in.
	Previously, the clauses of `slime-rex' were processed in the
	internal *cl-connection* buffer. And as a result the continuations
	passed to `slime-eval' and `slime-eval-async' ditto.

2007-08-15  Tobias C. Rittweiler <tcr@freebits.de>

	Make `M-.' work on definitions outside the current restriction.
	`M-,' will also properly restore the narrowing as of before the
	jump. Similiarly for quiting from the compilation notes buffer and
	the Xref buffers.

	* slime.el (slime-narrowing-configuration, slime-emacs-snapshot),
        (current-slime-narrowing-configuration),
        (set-slime-narrowing-configuration),
	(current-slime-emacs-snapshot),
	(set-slime-emacs-snapshot),
	(current-slime-emacs-snapshot-fingerprint): New. Emacs' window
	configurations do not restore narrowing, so introduce a
	snapshot facility that contains the necessary information.

	* slime.el: Various renaming and adaptions in the Slime temp
	buffer, xref, goto-definition and compilation notes section to use
	the newly introduced snapshots instead of mere window
	configurations.

	* slime.el: (slime-highlight-notes, slime-remove-old-overlays):
	Still operate on whole buffer, but restore previous restriction if
	there was any.
        (slime-goto-location-position): Now widens the buffer to properly
	jump to definitions outside of the current restriction.

	* slime.el (slime-push-definition-stack),
	(slime-pop-find-definition-stack): Now also stores information
	about narrowing on the definition stack, in order to properly
	restore narrowing on `M-,'.

	* slime.el (def-slime-test narrowing): Test case for properly
	dealing with narrowing.

	* slime.el (slime-buffer-narrowed-p): New function, tests whether
	the current buffer is narrowed or not.
	(save-restriction-if-possibly): Like `save-restriction', but not
	as strict---see doc string.

	* slime.el (slime-length=): New function; semantically the same
	as (= (length seq) n), but more efficiently implemented for lists.
	Changed the above pattern into a call to SLIME-LENGTH= where
	appropriate.

2007-08-05  Matthias Koeppe  <mkoeppe@mail.math.uni-magdeburg.de>

	* swank.lisp (backtrace): Handle printer errors while printing a
	frame.  This makes debugging print-object methods with SLIME
	easier.  Reported by Utz-Uwe Haus.

2007-08-02  Tobias C. Rittweiler  <tcr@freebits.de>

	* slime.el (slime-kill-all-buffers): Now also kills all buffers
	beginning with a `*SLIME' prefix (like, for instance, `*SLIME
	Apropos*', or `*SLIME macroexpansion*'.)

2007-06-28  Helmut Eller  <heller@common-lisp.net>

	* slime.el (def-slime-selector-method): Revert Marco's change from
	2007-05-23.  BODY can return a buffer name, like "*slime-events*".
	Handle that and never ignore invalid return values.  Force BODY to
	abort if there's no suitable buffer.  Why would you want to switch
	buffers if the desired buffer doesn't exist?

2007-06-27  Tobias C. Rittweiler <tcr@freebits.de>

	Fixing `C-c M-q' at the REPL. Thanks to André Thieme for pointing
	out that it has been broken since several months.

	* slime.el (slime-reindent-defun): Use functions
	`slime-beginning-of-defun' and `slime-end-of-defun' that were
	introduced in the last changeset.

2007-06-16  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Pressing `C-M-a' (beginning-of-defun) in midst of the
	last REPL prompt directs the cursor to the beginning of the
	prompt. Pressing it again, would do nothing; now it moves the
	cursor to the start of the previous prompt (as it's consistent
	with the behaviour when the cursor was placed midst one of the old
	prompts.)

	Likewise for `C-M-e' (end-of-defun)

	Additionally fixing `C-c C-s' (slime-complete-form) at the REPL.

	(slime-keys): New bindings for `C-M-a' and `C-M-e' to
	SLIME-BEGINNING-OF-DEFUN and SLIME-END-OF-DEFUN respectively.
	(slime-keys): Making `C-c C-q' (slime-close-parens-at-point)
	obsolete, as it didn't work correctly on the REPL.
	(slime-repl-mode-map): Removed bindings for `C-M-a' and `C-M-e',
	as they're now inherited from SLIME-KEYS.
	(slime-repl-beginning-of-defun, slime-repl-end-of-defun): Jump to
	the previous (next) prompt if called twice in a row.

	(slime-close-parens-at-point): Commented out.
	(slime-close-all-sexp): Renamed to SLIME-CLOSE-ALL-PARENS-IN-SEXP.
	(slime-close-all-parens-in-sexp): Modified to take
	SLIME-CLOSE-PARENS-LIMIT into account.
	(slime-complete-form): Use SLIME-CLOSE-ALL-PARENS-IN-SEXP.


2007-05-24  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Fixed regression in completion: "swank[TAB]" would
	previously be completed to "swank-backend:"; "get-internal[TAB]"
	would be completed to "get-internal-r-time" (instead of simply
	"get-internal-r"); and "custom:*comp[TAB]" would be completed to
	"custom:*compiled-" on CLISP, even though there's a
	"custom:*complile-".

	Thanks to Ken Causey for helping me find the first two.

	(completions): Revert changes from 2007-05-11.
	(longest-compound-prefix): Fixed to properly generate a compound
	_prefix_.

2007-05-23  Marco Baringer  <mb@bese.it>

	* slime.el (def-slime-selector-method): Allow the selector body to
	not return a buffer. This means that, instead of being to forced
	to signal an error when a choosen buffer can't be found (like
	choosing d when there are no debugger buffers) can simply display
	a message.

	Fix handling of auto-flushing on sbcl:

	* swank-sbcl.lisp (*auto-flush-interval*): New variable
	controlling how often streams are flushed.
	(*auto-flush-lock*): New lock guarding access to the shared
	variable *auto-flush-streams*.
	(make-stream-interactive): Wrapped access to *auto-flush-streams*
	in a call-with-recursive-lock-held.
	(flush-streams): Wrapped in call-with-recursive-lock-held.

2007-05-17  Martin Simmons <martin@lispworks.com>

	* swank-lispworks.lisp (lispworks-inspect): Fix hanging caused by
	mapcan, i.e. nconc, on a constant list returned by
	label-value-line.

2007-05-17  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-complete-form): Only insert a closing
	parenthesis if the form is not already closed. Reported by and
	adapted from Mac Chan.

2007-05-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Fixed bug in completion as previously "swank:[tab]"
	would correctly list all the symbols in SWANK, but would
	simultaneously append a spooky dash to the original
	string ("swank:-").

	(completions): Strip off the package identifier part, and only
	compute the longest compound prefix for the actual symbol
	identifiers.
	(untokenize-symbol): New function. Inverse of TOKENIZE-SYMBOL.
	(format-completion-result): Use UNTOKENIZE-SYMBOL.

2007-05-17  Dustin Long <dlong@stevens.edu>

	* swank-ecl.lisp (compile-from-stream): Fixed typo that prevented
	`slime-compile-defun' from actually compiling a function.

2007-05-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-loader.lisp (*sysdep-files*): Load the auxiliary files
	swank-source-*.lisp before swank-sbcl.lisp to avoid
	undefined-function style warnings.

2007-05-16  Takehiko Abe <keke@gol.com>

	* swank.lisp (inspect-for-emacs file-stream, stream-error): Fixed
	typo in keyword arg; it's `:refreshp', not `:refresh'.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-symbols): Really use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Previously when using SLIME-APROPOS-PACKAGE, only
	those symbols were considered whose home package matched the
	given package; this would, however, prevent all those symbols from
	being listed that are imported from another package, and then
	exported again in the package they got imported into. (As an
	example, SWANK:RESTART-FRAME is actually from SWANK-BACKEND.)

	(apropos-matcher): Renamed to MAKE-REGEXP-MATCHER.
	(make-regexp-matcher): Changed to only match for a given regexp.
	(apropos-symbols): Use MAKE-REGEXP-MATCHER.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Fix macroexpanding on things like ",(loop ...)".

	(slime-sexp-at-point-for-macroexpansion): New function; like
	SLIME-SEXP-AT-POINT-OR-ERROR, but fixes up some misbehaviour with
	respect to macroexpansion.
	(slime-eval-macroexpand, slime-eval-macroexpand-inplace): Use the
	new function.

2007-05-10  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el: Within the Slime Inspector, `S-Tab' will now also work
	 on X.  Furthermore `Tab' and `S-Tab' will now correctly wrap
	 around the beginning and end of the buffer; priorly it'd hang on
	 the beginning with a message "Beginning of buffer", and would
	 require an additional `S-Tab'.

	(slime-inspector-mode-map): Attached `[backtab]' to
	SLIME-INSPECTOR-PREVIOUS-INSPECTABLE-OBJECT, as Emacs translates
	`S-Tab' to `Backtab' on X.
	(slime-find-inspectable-object): New function; finds next or
	previous inspectable object.
	(slime-inspector-next-inspectable-object): Mostly rewritten. Use
	SLIME-FIND-INSPECTABLE-OBJECT to make the code clearer.

2007-04-19  Tobias C. Rittweiler <tcr@freebits.de>

	* swank-backend.lisp (label-value-line): Add :newline as &key
	argument; if true (the default) inserts a newline.

	* swank.lisp (inspect-for-emacs-list): Don't add a newline after
	the last value of the list.

2007-04-18  Marco Baringer  <mb@bese.it>

	* swank.lisp (log-event): Setup the printer so that, no matter
	what the global values of the *print-XYZ* variables, this function
	works as expected.
	(*debug-on-swank-error*): New variable.
	(defpackage :swank): Export *debug-on-swank-error*.
	(with-reader-error-handler): When *debug-on-swank-error* is
	non-nil drop into a debugger.
	(dispatch-loop): Idem.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Instead of just having all the symbols of a package
	listed alphabetically in the inspector page recently introduced
	for that purpose, add a button to that page to group them by their
	classification.

	(%package-symbols-container): New slot GROUPING-KIND.
	(%make-package-symbols-container): New function; wraps around
	%%MAKE-PACKAGE-SYMBOLS-CONTAINER, which will actually create the
	structure. We need this, to make GROUPING-KIND an entirely
	internal affair.

	(make-symbols-listing): New generic function to dispatch on
	GROUPING-KIND.
	(make-symbols-listing :symbol): Just the stuff that was priorly
	wired into INSPECT-FOR-EMACS (%PACKAGE-SYMBOLS-CONTAINER).
	(make-symbols-listing :classification): New; returns the passed
	symbols grouped by their classification.
	(inspect-for-emacs %package-symbols-container): Most code split
	off into MAKE-SYMBOLS-LISTING.

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (swank-compiler): Fix the return value to always be a
	list of two elements even if the abort restart is invoked which
	originally just returned NIL. (Which wouldn't play with the recent
	change to use DESTRUCTURING-BIND in SLIME-COMPILATION-FINISHED.)

2007-04-17  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (inspect-for-emacs %package-symbols-container):
	Revert Marco's change from 2007-04-08; he had the good idea of
	adding a facility to jump to the relevant source line of a symbol,
	but `M-.' is already bound to SLIME-FIND-DEFINITION in the
	inspector, which is a nicer way of doing this alltogether.

2007-04-16  Takehiko Abe <keke@gol.com>

	* swank-openmcl.lisp (accept-connection, find-external-format):
	utf-8 support.

2007-04-16  Marco Baringer <mb@bese.it>

	* slime.el (slime-with-xref-buffer): ectory.iler <tcr@freebits.de>

	* slime.el: Fixed proper handling of the abortion of a
	request. (For instance, when calling (SWANK::ABORT-REQUEST "FOO")
	from the REPL.)

	(sldb-quit): Updated the DESTRUCTURE-CASE clause for (:abort) to
	take an argument.
	(sldb-continue): Likewise.
	(sldb-invoke-restart): Likewise.
	(sldb-break-with-default-debugger): Likewise.
	(sldb-return-from-frame): Likewise.
	(sldb-restart-frame): Likewise.
	(slime-repl-eval-string) Likewise.
	(slime-repl-show-abort): Now also inserts the reason for the abort
	into the REPL buffer.

	* swank.lisp (eval-for-emacs): Remove code that would suggest that
	it's possible to use the rex `(:abort ...)' with more than one
	argument.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp: Liberated from unnecessary style-warnings!

	(eval-for-emacs): Don't use SLOT-VALUE on condition objects!
	(inspect-bigger-piece-actions): Changed from DEFMETHOD to DEFUN.
	(inspect-whole-thing-action): Likewise.
	(inspect-show-more-action): Likewise.
	(make-symbols-listing): Adds an explicit DEFGENERIC.
	(menu-choices-for-presentation): Likewise.

	(make-symbols-listing (eql :classification)): Use `(loop for k
	being EACH hash-key ...)' rather than `(loop for k being THE
	hash-key)', to omit the justified style-warning from CLISP.

2007-05-14  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (package-names): Make sure to return a fresh list.
	(fuzzy-find-matching-packages): Use PACKAGE-NAMES.
	(list-all-package-names): Use PACKAGE-NAMES.

2007-05-13  Tobias C. Rittweiler <tcr@freebits.de>

	* slime.el (slime-pretty-lambdas): Removed. If you really want
	this, please use one of the external ressources that provide this;
	for instance, `pretty-lambda.el', `pretty-greek.el', or even
	`pretty-symbols.el'. For more information, please see

	   http://www.emacswiki.org/cgi-bin/wiki/PrettyLambda

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (fuzzy-find-matching-symbols): Modified to take
	package nicknames into account. Previously, fuzzy completing on
	nicknames did (except for some incidental cases) not work. Thanks
	to Luís Oliveira and Attila Lendvai for pointing that out.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	Removed support for completing to the longest compound pre- and
	suffix with the default completion method (C-c TAB, or just TAB on
	the REPL), because it has been causing trouble all the time, but
	didn't offer any real advantage besides niftiness. E.g.:

	    previous behaviour:

	      asdf:*com TAB => asdf:*compile-file--behaviour*

	    now simply:

	      asdf:*com TAB => asdf:*compile-file-

	For discussing on this subject, please see the mail with
	message-id <87y7l53lch.fsf@freebits.de> that was posted to
	slime-devel 2007-04-06, or alternatively:

	http://common-lisp.net/pipermail/slime-devel/2007-April/006087.html

	* swank.lisp (make-compound-prefix-matcher): New function.
	Abstracted from COMPOUND-PREFIX-MATCH.
	(compound-prefix-match): Use MAKE-COMPOUND-PREFIX-MATCHER.
	(compound-prefix-match/ci/underscores): Removed.

	(longest-completion): Renamed to LONGEST-COMPOUND-PREFIX. Changed
	to only return a compound prefix, instead of a concatenation of a
	compound prefix and a compound suffix. Added an &optional
	parameter to specify what delimeter the passed string is
	compounded with.
	(tokenize-completion): Takes additional parameter to specify the
	delimeter for tokenization.
	(longest-completion/underscores): Removed; not needed anymore.
	(tokenize-completion/underscores): Likewise.
	(untokenize-completion/underscores): Likewise.

	(completions): Slight docstring modification, also added an
	examplary use case; use LONGEST-COMPOUND-PREFIX instead of
	LONGEST-COMPLETION.
	(completions-for-character): Use LONGEST-COMPOUND-PREFIX, and
	MAKE-COMPOUND-PREFIX-MATCHER.
	(completions-for-keyword): Use LONGEST-COMPOUND-PREFIX.

2007-05-11  Tobias C. Rittweiler <tcr@freebits.de>

	* swank.lisp (apropos-sym                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      