update protocol version to 2014-09-13

support new `swank-repl:...` protocol (as well as old protocol)

new function `swank:init-presentations`

Set up the REPL reporting function in it, not at toplevel

add `swank:apropos-list-for-emacs`

and also `swank:describe-definition-for-emacs`, helping to make it
useful.  It's still a bit weird with the confusion between name of
thing, name of help file, and so on (and also because
describe-definition-for-emacs must return a definition kind from a
restricted set defined in base slime) but it's basically working.

add `swank:clear-repl-variables`

null implementation (we don't have any repl variables)

implement new slimefun swank:lookup-and-save-presented-object-or-lose

For better presentations

we did slime-c-p-c completion a while ago

implement swank-c-p-c

now users with c-p-c completion style can rejoice!  Matching is a little
hacky, but not too surprising.

make it work with org-mode 8

(no, don't preserve workingness with org-mode 7.  I bet this comes
back to bite me.)

record resolutions of things in BUGS and TODO

Adjust the README instructions to have --interactive in the R
startup invocation, so base graphics display automatically.

update README for new slime location

`swank:describe-function` and `swank:describe-symbol` implementations

from Philipp Marek, about an eternity ago.

more srcref frobbing

I do not pretend to understand whether this is new, but in 2.14
parsing an expression, in addition to adding srcref attributes to the
results of the parse, can result in actual srcref elements being in
the results.  Those srcrefs also need to be frobbed so that display of
functions at the repl works properly.  (I do think this worked in 2.12
without this extra frobbing, but I am totally prepared to admit that I
can't really remember).

Since we're on the case, also frob things that look like srcrefs but
aren't under "srcref" attributes, such as "wholeSrcref"s

fix compilation of x[y,]

Oh boy.  I do not pretend to totally understand what is going on, but
what seemed to be happening is that somehow when walking the parse
tree to adjust srcrefs to the real file position rather than the
string position, the `empty' space in x[y,] was turning from a
zero-element name to a missing object, and then subsequent attempts to
evaluate the missing object (or even return it) were failing.

The workaround is to short-circuit the process for name objects, which
are atomic and (empirically) do not have srcrefs attached anyway and
so can be returned without modification.

fix null implementation of operator-arglist

actually return a list of two elements, not a bare string

some elisp code that slime/swankr users probably want

Should try to find out how to have it loaded automatically

make inspector printing more reasonable

I don't yet know what's right, but it's fairly nonsensical to have
"[1] " prepending every label and value, so use prin1ToString

rework `swank:simple-completions`

In the process, implement looking up foo$bar$baz, and passing those
completions back.  It's not completely robust to somewhat exotic
syntax, as it assumes that the text being completed can be used
directly as character vectors naming objects or fields; it is good
enough to get started, and now a lot less annoying to
use (particularly when lots of fields have underscores in them...)

log wishlist completion bug

Also note some other bugs as fixed.

declare a version in `swank:connection-info`

Useful both for me, to track what slime version is most likely to be
maximally compatible, and for SLIMV users, which dispatch on the
version to know whether the protocol is byte-count-based or
character-count-based.

implement `swank:operator-arglist` properly

Now that slime-operator-at-point is overrideable, I can even test this
from within Emacs -- but thanks to Philipp Marek for implementing this
in his SLIMV-based environment first.

fix bug #21

%in% needs a `vector' first argument, so make it so, listifying
anything that isn't already a vector.  (Note: there seem to be plenty
of non-vector first arguments that work, such as
as.Date("2012-01-01"), which returns FALSE to is.vector() -- but the new
code seems to get that right anyway, based on very limited testing.

log bug #21, regarding inspection of environments

Reported by Philipp Marek

log and fix bug #20: infinite errors on disconnect.

Check for a zero-element character vector return from readChar.  (This
is not documented as the EOF return value, no, but it makes sense).

Also commit bug reports #18 and #19, and some README rearrangement.

give us a chance with utf-8

Calculate the length of the output to emacs using nchar(type="bytes")

This makes help files sort-of work again

log the external-format / encoding bug

pass an :encoding stanza in the connection information

Allows slime-repl to start again.  I've said "utf-8-unix" but that is
almost certainly a lie; I have no real idea how R handles encodings of
text.  Simply passing in "ë" to the R slime repl breaks things without
too much effort.

don't print out "locals" from the global environment

This is important because e.g. the repl evaluation happens in the
global environment, so errors on code called from the repl will pull
up a backtrace with that evaluation frame, which can be inspected for
locals.  But printing out all the locals is a hugely expensive and not
helpful thing to do.

fix for visible values from region and interactive eval

editing thinko: need tmp$value (not just value)

fix swank-media repl-result-maker for complex

There ought to be some way of catching this mistake, which is passing
a non-length-1 vector to the swank functions, which then vectorise and
confuse the event stream.

log a couple more bugs

catch errors during printing of frame locals

tryCatch is R's handler-case.  (Spent some time wondering why
withCallingHandlers wasn't working, but that's handler-bind.)

log some more bugs

escape names when searching for completions

otherwise extended regexp metacharacters, particularly ".", get
interpreted as those metacharacters rather than literals.  (bug #12)

support ?help buffers

use new fancy :popup-buffer event in slime-media.

log some more bugs

deal with 0 or multiple expressions at the repl

It's easy really; just iterate over expressions.  Resolves bug #10.

update BUGS file

We've resolved and :FIXED: several.  Log a bug related to repl handling
of multiple expressions.

use withVisible() in appropriate places

Makes C-c C-r substantially less painful, and also produces slightly
fewer surprises at the REPL.  (resolves #5)

use a similar repl result method in swank-media.R for ggplot objects

Should refactor (and provide width/height options)

log wishlist bug #9 (wanting help() and ? to work)

previous commit sorted out #8 (filesystem-location-independence)

make contribs load when the working directory isn't swankr's

depends on swank.R itself being source()d with chdir=TRUE, but doesn't
break any previously-working use case.

update BUGS and TODO

enough support for emacs/slim to start swank for itself

There's a race condition, I think, in between writing the socket port
and running the socket server; it might be as simple as reordering the
writing and the socket opening, but strange things happened once when
I did that.

implement swank:interactive-eval-region

Because of our vaguely dodgy heuristic for finding the "defun" to
evaluate, C-c C-c is not terribly useful.  This allows at least C-c
C-r to be used without thinking.

fix swank:compile-file-for-emacs when loadp is true

also retain source information in swank:load-file for maximum emacs
goodness.

support translation of t and nil

Parse them into TRUE and FALSE in the lisp->R translator

implement swank:quit-lisp

absolutify some more source file finding

experiment with different printing methods (using swank-media)

remove debugging code from swank-presentations

add .htaccess for utf-8 html encoding

capture output from evaluating swank requests

This fixes bug #1.  It is somewhat on the risky side given that there
are current known protocol problems in the presence of non-ASCII
encodings, but it does make working in the slime repl much more
pleasant.

log another wishlist bug

This time about visibility of evaluation results.

improve html export of org files

Allow ="foo"= to be exported as code.

webup Makefile target

for no better reason than my convenience

srcrefs in swank:compile-string-for-emacs

Wow, this was hard.  parse() constructs a vector with mode
"expression", consisting of multiple, possibly nested calls.
Scattered throughout this structure are srcrefs with absolute
locations.  This means that we need to walk the parsed data structure
and adjust every srcref that we can find, giving it an offset based on
the location information passed to compile-string-for-emacs (which
requires bleeding-edge 2010-10-08 slime, because earlier versions
don't pass line/column information in the position argument).

But we can't simply adjust the "srcref" attribute on our parsed data
structure, because R tries very hard to be pure.  Instead we need to
return a copy with the right modifications (but preserving everything
else of importance).  It's straightforward once you know how, but
there were many painful missteps to get to this point.  Still, now
M-. works on function names assigned with C-c C-c in source buffers.

add tags to bugs

log a bug in multibyte character handling

1:£ crashes the swank connection (and is fairly easy to mistype when
demoing)

better swank:find-definitions-for-emacs

In particular, include enough of a kludge to be able to handle both
relative and absolute paths.

less debugging output cruft in `swank:frame-locals-and-catch-tags`

more working `swank:compile-file-for-emacs`

Firstly, only parse, don't source, as that seems to be the
protocol (the emacs side is responsible for requesting a load if
desired).  Secondly, the protocol is also to return a
compilation-result structure rather than just TRUE, so do that too.

log issue with srcref in swank:compile-string-for-emacs

implement swank:load-file and swank:compile-file-for-emacs

Easy, peasy.  The only trick here is to use parse() in the case that
compile-file-for-emacs is not being asked to load the `compiled' file.

implement swank:default-directory and swank:set-default-directory

It was surprisingly hard to intuit getwd() and setwd(), what with
apropos("dir") and apropos("cwd") failing.  Nevertheless, they exist
and function, so use them for the interface (but not slimefun)
functions.

convenience Makefile for generating html from org files

create BUGS and TODO files

Link to them from README for webby goodness.  (Actually for webby
goodness I have to call them BUGS.org and TODO.org, *sigh*).

update README for swank-media information

sort out printing functions

R has capture.output as equivalent to with-output-to-string, so use it.

printToString, used by the slime-repl, now reverts back to calling
print.  New function prin1ToString, used by swank:interactive-eval and
swank:eval-and-grab-output, uses deparse.

R implementation of the swank side of the (brand-new) slime-media contrib

Define a generic function to be used with the new
makeReplResultFunction hook, with an implementation using png files
for trellis objects.

new makeReplResultFunction hook

default makeReplResult function doing the standard
(:write-string value :repl-result) thing for the REPL.

implement swank:eval-string-in-frame

Reified environments make quite a lot of this fairly easy...

implement swank:inspect-current-condition and swank:inspect-frame-var

implement a default method for emacsInspect

Stands a chance of making the inspector not utterly annoying

implement swank:inspector-eval

It took me quite some time to remember that parse returns a list of
expressions rather than just a single expression...

implement swank:inspector-pop and swank:inspector-next

Wow, nearly working.  There's some way of causing R to get into the
proper debugger; not sure how to reproduce it yet.

fix one multiple-string bug in the inspector

slightly more working inspector

Use an environment for istate rather than a list

implement swank:inspector-nth-part and swank:inspect-nth-part

implement `swank:quit-inspector`

the beginnings of an inspector

Implement enough that C-c I begins to work, at least for values like
list(1,2,3).  The resulting inspector on the emacs side apparently has
no features, and an error message results on quitting the inspector
because I've only implemented `swank:init-inspector`, and not
`swank:quit-inspector`.  Still, good enough to checkpoint.

implement withRetryRestart

Use it in swank:interactive-eval and swank:eval-and-grab-output

implement withOutputToString

Possibly, anyway.  I think the semantics are right.  Use it in
printToString and in swank:eval-and-grab-output.

swank:value-for-editing and swank:commit-edited-value

These are (in principle, at least) really, really easy.

alternative printing for the REPL

instead of using print(), use str().  Also, be even more cautious
about cleaning up in printToString; previously, errors in printing
would lead to a sink to a closed fifo...

Printing is still not really right, and I forsee that we will end up
writing our own printer to get something more lispy.  But at least
this approach tends not to dump huge tables into the REPL.

integrate into R's event loop, possibly

in readPacket, call socketSelect() before actually trying to read on
the connection.  This seems to allow R to update graphics windows and
other such niceties.

It would be nice to be able to preserve the (inferior) R REPL as well,
but I haven't yet discovered whether that's possible.

implement swank:find-definitions-for-emacs

A simple implementation, only looking for a single function
definition (no methods, whether S3 or S4, or indeed anything else).
Enough to support M-., though.

use srcfile$wd when going to source for an sldb frame

it worked before while emacs and R were started with the same working
directory; this is not always going to be the case.

support swank:clear-repl-results in swank-presentations

This makes my worry about lacking weak hash tables a bit less
pressing.

initial implementation of support for REPL presentations

There's a lot here that's ugly, unfinished or just downright horrible.
Most notably, presentation support depends on swank-side read-time
evaluation (indicated with Common Lisp syntax, which hilariously is a
comment in R).  We can't support that in general, but we can
special-case the presentation-specific operator.

But then the next difficulty comes along; actually performing that
read-time evaluation needs to happen in a different environment than
the evaluation of the REPL form.  In order to achieve this, we abuse
bquote() the equivalent of Lisp's backquote facility, by calling what
in CL terms would be its macro-function on the parsed, preprocessed
expression; only after doing that (and hence resolving the `read-time'
evaluations) do we evaluate the call itself.

The implementation of presentation protocol messages is also slightly
ugly; having to implement cl:nth-value is particulraly horrible, but
the lack of weak references / weak tables in R (at least as far as I
can tell at the moment) is a cause of niggling concern.

A proper implementation of swank:swank-require

We can do this nicely now that we have an evaluator of :emacs-rex
forms that can cope with quote.

implement a mini code-walker to support nested function calls in :emacs-rex

This is all a bit horrible, but probably limited in maintenance headaches.

make swank:listener-eval be a bit more like the CL version

don't return (:ok (:values "string")); instead, send a separate
(:write-string "string" :repl-result) and return (:ok ())

use an environment holding the Slime I/O connection

Rather than having a bare io argument everywhere, encapsulate it in an
environment.  (An environment is just about the only thing I can find
in R that isn't copy-on-write; this isn't helpful for the i/o
connection, but will be once we start implementing inspectors and
presentations...)

slightly clarified the relationship to ESS

In particular, be careful not to overclaim.  Motivated by preparing to
announce to the ESS mailing list.

add README

Add licence information to swank.R

Same terms as R itself: GNU GPLv2 or later version

implement swank:frame-source-location

Now v in the debugger mostly works.

factor out backtraceForEmacs() into `swank:backtrace`

write `swank:debugger-info-for-emacs` out, and hence delete
debuggerInfoForEmacs().

Now wandering past the --more-- prompt in sldb gives an infinite
sequence of NULLs, but at least it's not a cascade of errors any more.

implement swank:interactive-eval and swank:eval-and-grab-output

This allows C-c : and C-u C-c : to work, modulo the printing of an
unnecessary [1].  The evaluation semantics of R are not what a Lisper might
expect; printToString(eval(parse(...))) does not necessarily perform the
evaluation before altering the output stream with sink() -- so capturing
all sorts of incidental output if something goes wrong.

This commit brought to you using C-c C-c.