### latest version of the GNU General Public Licence is available at
### <http://www.gnu.org/licenses/gpl.txt>.
+### KLUDGE: this assumes that we're being sourced with chdir=TRUE.
+### (If not, `swank:swank-require` will work under the circumstances
+### that it used to work anyway -- i.e. the working directory is the
+### swankr directory)
+swankrPath <- getwd()
+
swank <- function(port=4005) {
acceptConnections(port, FALSE)
}
startSwank <- function(portFile) {
- acceptConnections(FALSE, portFile)
+ acceptConnections(4005, portFile)
}
acceptConnections <- function(port, portFile) {
+ if(portFile != FALSE) {
+ f <- file(portFile, open="w+")
+ cat(port, file=f)
+ close(f)
+ }
+ ## FIXME: maybe we should support dontClose here?
s <- socketConnection(host="localhost", server=TRUE, port=port, open="r+b")
on.exit(close(s))
- serve(s)
+ tryCatch(serve(s), endOfFile=function(c) NULL)
}
serve <- function(io) {
}
dispatch <- function(slimeConnection, event, sldbState=NULL) {
- str(event)
kind <- event[[1]]
if(kind == quote(`:emacs-rex`)) {
do.call("emacsRex", c(list(slimeConnection), list(sldbState), event[-1]))
sendToEmacs <- function(slimeConnection, obj) {
io <- slimeConnection$io
- str(obj)
payload <- writeSexpToString(obj)
- writeChar(sprintf("%06x", nchar(payload)), io, eos=NULL)
+ writeChar(sprintf("%06x", nchar(payload, type="bytes")), io, eos=NULL)
writeChar(payload, io, eos=NULL)
flush(io)
- cat(sprintf("%06x", nchar(payload)), payload, sep="")
}
callify <- function(form) {
emacsRex <- function(slimeConnection, sldbState, form, pkg, thread, id, level=0) {
ok <- FALSE
value <- NULL
+ conn <- textConnection(NULL, open="w")
+ condition <- NULL
tryCatch({
withCallingHandlers({
call <- callify(form)
- value <- eval(call)
+ capture.output(value <- eval(call), file=conn)
+ string <- paste(textConnectionValue(conn), sep="", collapse="\n")
+ if(nchar(string) > 0) {
+ sendToEmacs(slimeConnection, list(quote(`:write-string`), string))
+ sendToEmacs(slimeConnection, list(quote(`:write-string`), "\n"))
+ }
+ close(conn)
ok <- TRUE
}, error=function(c) {
+ condition <<- c
+ string <- paste(textConnectionValue(conn), sep="", collapse="\n")
+ if(nchar(string) > 0) {
+ sendToEmacs(slimeConnection, list(quote(`:write-string`), string))
+ sendToEmacs(slimeConnection, list(quote(`:write-string`), "\n"))
+ }
+ close(conn)
newSldbState <- makeSldbState(c, if(is.null(sldbState)) 0 else sldbState$level+1, id)
withRestarts(sldbLoop(slimeConnection, newSldbState, id), abort=paste("return to sldb level", newSldbState$level)) })},
- finally=sendToEmacs(slimeConnection, list(quote(`:return`), if(ok) list(quote(`:ok`), value) else list(quote(`:abort`)), id)))
+ finally=sendToEmacs(slimeConnection, list(quote(`:return`), if(ok) list(quote(`:ok`), value) else list(quote(`:abort`), as.character(condition)), id)))
}
makeSldbState <- function(condition, level, id) {
readChunk <- function(io, len) {
buffer <- readChar(io, len)
+ if(length(buffer) == 0) {
+ condition <- simpleCondition("End of file on io")
+ class(condition) <- c("endOfFile", class(condition))
+ signalCondition(condition)
+ }
if(nchar(buffer) != len) {
stop("short read in readChunk")
}
} else if(grepl("^[0-9]+\\.[0-9]+$", token)) {
as.double(token)
} else {
- as.name(token)
+ name <- as.name(token)
+ if(name == quote(t)) {
+ TRUE
+ } else if(name == quote(nil)) {
+ FALSE
+ } else {
+ name
+ }
}
}
readToken <- function() {
writeSexpToStringLoop(obj)
}
-withOutputToString <- function(expr) {
- call <- substitute(expr)
- f <- fifo("")
- sink(f)
- tryCatch({ tryCatch(eval.parent(call), finally=sink())
- readLines(f) },
- finally=close(f))
+prin1ToString <- function(val) {
+ paste(deparse(val, backtick=TRUE, control=c("delayPromises", "keepNA")),
+ sep="", collapse="\n")
}
printToString <- function(val) {
- withOutputToString(str(val, indent.str="", list.len=5, max.level=2))
+ paste(capture.output(print(val)), sep="", collapse="\n")
}
`swank:connection-info` <- function (slimeConnection, sldbState) {
list(quote(`:pid`), Sys.getpid(),
quote(`:package`), list(quote(`:name`), "R", quote(`:prompt`), "R> "),
+ quote(`:encoding`), list(quote(`:coding-systems`), list("utf-8-unix")),
quote(`:lisp-implementation`), list(quote(`:type`), "R",
quote(`:name`), "R",
quote(`:version`), paste(R.version$major, R.version$minor, sep=".")))
`swank:swank-require` <- function (slimeConnection, sldbState, contribs) {
for(contrib in contribs) {
- filename <- sprintf("%s.R", as.character(contrib))
+ filename <- sprintf("%s/%s.R", swankrPath, as.character(contrib))
if(file.exists(filename)) {
- source(filename, verbose=TRUE)
+ source(filename)
}
}
list()
makeReplResult <- function(value) {
string <- printToString(value)
- list(quote(`:write-string`), paste(string, collapse="\n"),
+ list(quote(`:write-string`), string,
quote(`:repl-result`))
}
sendReplResultFunction <- sendReplResult
`swank:listener-eval` <- function(slimeConnection, sldbState, string) {
+ ## O how ugly
string <- gsub("#\\.\\(swank:lookup-presented-object-or-lose([^)]*)\\)", ".(`swank:lookup-presented-object-or-lose`(slimeConnection, sldbState,\\1))", string)
- expr <- parse(text=string)[[1]]
- lookedup <- do.call("bquote", list(expr))
- value <- eval(lookedup, envir = globalenv())
- sendReplResultFunction(slimeConnection, value)
+ for(expr in parse(text=string)) {
+ expr <- expr
+ ## O maybe this is even uglier
+ lookedup <- do.call("bquote", list(expr))
+ tmp <- withVisible(eval(lookedup, envir = globalenv()))
+ if(tmp$visible) {
+ sendReplResultFunction(slimeConnection, tmp$value)
+ }
+ }
list()
}
if(is.null(srcfile)) {
list(quote(`:error`), "no srcfile")
} else {
+ filename <- get("filename", srcfile)
+ ## KLUDGE: what this means is "is the srcfile filename
+ ## absolute?"
+ if(substr(filename, 1, 1) == "/") {
+ file <- filename
+ } else {
+ file <- sprintf("%s/%s", srcfile$wd, filename)
+ }
list(quote(`:location`),
- list(quote(`:file`), sprintf("%s/%s", srcfile$wd, srcfile$filename)),
+ list(quote(`:file`), file),
list(quote(`:line`), srcref[[1]], srcref[[2]]-1),
FALSE)
}
}
`swank:frame-locals-and-catch-tags` <- function(slimeConnection, sldbState, index) {
- str(sldbState$frames)
frame <- sldbState$frames[[1+index]]
objs <- ls(envir=frame)
+ if(identical(frame, globalenv())) {
+ objs <- c()
+ }
list(lapply(objs, function(name) { list(quote(`:name`), name,
quote(`:id`), 0,
- quote(`:value`), paste(printToString(eval(parse(text=name), envir=frame)), sep="", collapse="\n")) }),
+ quote(`:value`),
+ tryCatch({
+ printToString(eval(parse(text=name), envir=frame))
+ }, error=function(c) {
+ sprintf("error printing object")
+ }))}),
list())
}
`swank:simple-completions` <- function(slimeConnection, sldbState, prefix, package) {
- ## fails multiply if prefix contains regexp metacharacters
- matches <- apropos(sprintf("^%s", prefix), ignore.case=FALSE)
+ literal2rx <- function(string) {
+ ## list of ERE metacharacters from ?regexp
+ gsub("([.\\|()[{^$*+?])", "\\\\\\1", string)
+ }
+ matches <- apropos(sprintf("^%s", literal2rx(prefix)), ignore.case=FALSE)
nmatches <- length(matches)
if(nmatches == 0) {
list(list(), "")
} else {
longest <- matches[order(nchar(matches))][1]
- while(length(grep(sprintf("^%s", longest), matches)) < nmatches) {
+ while(length(grep(sprintf("^%s", literal2rx(longest)), matches)) < nmatches) {
longest <- substr(longest, 1, nchar(longest)-1)
}
list(as.list(matches), longest)
}
`swank:compile-string-for-emacs` <- function(slimeConnection, sldbState, string, buffer, position, filename, policy) {
- # FIXME: I think in parse() here we can use srcref to associate
- # buffer/filename/position to the objects. Or something.
- withRestarts({ times <- system.time(eval(parse(text=string), envir = globalenv())) },
+ lineOffset <- charOffset <- colOffset <- NULL
+ for(pos in position) {
+ switch(as.character(pos[[1]]),
+ `:position` = {charOffset <- pos[[2]]},
+ `:line` = {lineOffset <- pos[[2]]; colOffset <- pos[[3]]},
+ warning("unknown content in pos", pos))
+ }
+ frob <- function(refs) {
+ lapply(refs,
+ function(x)
+ srcref(attr(x,"srcfile"),
+ c(x[1]+lineOffset-1, ifelse(x[1]==1, x[2]+colOffset-1, x[2]),
+ x[3]+lineOffset-1, ifelse(x[3]==1, x[4]+colOffset-1, x[4]),
+ ifelse(x[1]==1, x[5]+colOffset-1, x[5]),
+ ifelse(x[3]==1, x[6]+colOffset-1, x[6]))))
+ }
+ transformSrcrefs <- function(s) {
+ srcrefs <- attr(s, "srcref")
+ attribs <- attributes(s)
+ new <-
+ switch(mode(s),
+ "call"=as.call(lapply(s, transformSrcrefs)),
+ "expression"=as.expression(lapply(s, transformSrcrefs)),
+ s)
+ attributes(new) <- attribs
+ if(!is.null(attr(s, "srcref"))) {
+ attr(new, "srcref") <- frob(srcrefs)
+ }
+ new
+ }
+ withRestarts({
+ times <- system.time({
+ exprs <- parse(text=string, srcfile=srcfile(filename))
+ eval(transformSrcrefs(exprs), envir = globalenv()) })},
abort="abort compilation")
- list(quote(`:compilation-result`), list(), TRUE, times[3])
+ list(quote(`:compilation-result`), list(), TRUE, times[3], FALSE, FALSE)
}
withRetryRestart <- function(description, expr) {
`swank:interactive-eval` <- function(slimeConnection, sldbState, string) {
withRetryRestart("retry SLIME interactive evaluation request",
- value <- eval(parse(text=string), envir=globalenv()))
- printToString(value)
+ tmp <- withVisible(eval(parse(text=string), envir=globalenv())))
+ if(tmp$visible) {
+ prin1ToString(tmp$value)
+ } else {
+ "# invisible value"
+ }
}
`swank:eval-and-grab-output` <- function(slimeConnection, sldbState, string) {
withRetryRestart("retry SLIME interactive evaluation request",
{ output <-
- withOutputToString(value <- eval(parse(text=string),
- envir=globalenv())) })
- list(output, printToString(value))
+ capture.output(tmp <- withVisible(eval(parse(text=string),
+ envir=globalenv()))) })
+ output <- paste(output, sep="", collapse="\n")
+ if(tmp$visible) {
+ list(output, prin1ToString(tmp$value))
+ } else {
+ list(output, "# invisible value")
+ }
+}
+
+`swank:interactive-eval-region` <- function(slimeConnection, sldbState, string) {
+ withRetryRestart("retry SLIME interactive evaluation request",
+ tmp <- withVisible(eval(parse(text=string), envir=globalenv())))
+ if(tmp$visible) {
+ prin1ToString(tmp$value)
+ } else {
+ "# invisible value"
+ }
}
`swank:find-definitions-for-emacs` <- function(slimeConnection, sldbState, string) {
list()
} else {
filename <- get("filename", srcfile)
+ ## KLUDGE: what this means is "is the srcfile filename
+ ## absolute?"
+ if(substr(filename, 1, 1) == "/") {
+ file <- filename
+ } else {
+ file <- sprintf("%s/%s", srcfile$wd, filename)
+ }
list(list(sprintf("function %s", string),
list(quote(`:location`),
- list(quote(`:file`), sprintf("%s/%s", srcfile$wd, srcfile$filename)),
+ list(quote(`:file`), file),
list(quote(`:line`), srcref[[2]][[1]], srcref[[2]][[2]]-1),
list())))
}
valuePart <- function(istate, object, string) {
list(quote(`:value`),
- if(is.null(string)) paste(printToString(object),collapse=" ") else string,
+ if(is.null(string)) printToString(object) else string,
assignIndexInParts(object, istate))
}
object <- get(name, envir=frame)
inspectObject(slimeConnection, object)
}
+
+`swank:default-directory` <- function(slimeConnection, sldbState) {
+ getwd()
+}
+
+`swank:set-default-directory` <- function(slimeConnection, sldbState, directory) {
+ setwd(directory)
+ `swank:default-directory`(slimeConnection, sldbState)
+}
+
+`swank:load-file` <- function(slimeConnection, sldbState, filename) {
+ source(filename, local=FALSE, keep.source=TRUE)
+ TRUE
+}
+
+`swank:compile-file-for-emacs` <- function(slimeConnection, sldbState, filename, loadp, ...) {
+ times <- system.time(parse(filename, srcfile=srcfile(filename)))
+ if(loadp) {
+ ## KLUDGE: inelegant, but works. It might be more in the spirit
+ ## of things to keep the result of the parse above around to
+ ## evaluate.
+ `swank:load-file`(slimeConnection, sldbState, filename)
+ }
+ list(quote(`:compilation-result`), list(), TRUE, times[3], substitute(loadp), filename)
+}
+
+`swank:quit-lisp` <- function(slimeConnection, sldbState) {
+ quit()
+}