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.

ensure that the fifo is closed in printToString()

Whoops.  Good to know that I can make the same basic stream mistakes
in any language.

implement swank:compile-string-for-emacs

As long as my defun-prompt-regexp is set up right, I can now use C-c
C-c to develop swankr.  Go me.

implement swank:simple-completions

Probably fails as soon as slime and R disagree about what are token
constituents, or if an R token contains regexp metacharacters.

stub for swank:operator-arglist

return properly from sldbLoop()

Always emit a :debug-return message.  The extra :sldb-return stuff in
swank.lisp is (I think) only needed for multiple threads.

put abort restarts around the main and sldb loops

Also hide the abort restart imposed on us by the R interpreter itself,
which has the side-effect of aborting swank completely.

The beginnings of a vaguely-useful sldb

Implement swank:frame-locals-and-catch-tags.  There are problems:

1. it seems that some names can be present in an environment but not have
   a value, causing eval to blow up;
2. the default printing routines aren't really adapted to the constraints
   of rendering in sldb;
3. trying to display locals of some of the swank frames (perhaps anything
   with a tryCatch or similar block?) causes R to complain about a promise
   already in the process of evaluation;
4. (probably) other things I haven't yet found

store calls and frames on entry to sldb itself

Rather than do complicated stuff to keep track of where we are in the
stack, simply store the interesting frames and calls in the sldb state
structure.

implement swank:buffer-first-change

Simply stub it in, to stop things whining at me when I type into the
wrong window and edit a Lisp file (which happens to be in slime
mode...)

return stack frames in slime's order (most recent first)

get definitions (use of <-) to work in the REPL

the REPL now evaluates with envir=globalenv(), rather than in the
environment of `swank:listener-eval`...

support invoking restarts from sldb

use a restart description for restart printing, if available

rework to support sldb

R doesn't have much in the way of dynamic binding; you can fake it by
messing with environments, but that's not fun.

So instead, pass around the connection (`io') and an object
representing the SLDB state (`sldbState') to all functions.
Poor-man's explicit continuation-passing-style...

We need to call some of the mainLoop internal functions from elsewhere
now, so make them not-internal any more.

Fix ridiculous thinko in the logical branch of writeSexpToString

use simpleCondition rather than simpleError in swank:throw-to-toplevel

implement swank:debugger-info-for-emacs

Now `q' in sldb (sldb-quit) works.  Things that don't work:
1. the backtrace is the wrong way up.
2. calling any restarts
3. frame locals
4. returning from frames (dunno if R actually supports this)
5. zoom to source
6. probably other things

implement swank:throw-to-toplevel

include swank.R hacks from today

We get far enough to start up a swank server in R and connect to it from
emacs; we get a REPL which formats the R-style results from parsing and
evaluating the input it receives.  Debugging, stepping, documentation,
arglist and so on is basically entirely missing.