X-Git-Url: http://christophe.rhodes.io/gitweb/?p=swankr.git;a=blobdiff_plain;f=swank.R;h=f0aee27babe75b918535f5a6efdae9264d70e78e;hp=1dc95b48800c305489292bc95f4cdb92f381e16e;hb=9b83d84a9630016cf93de94109d6ac01090e8f68;hpb=c15f7575dad3773f1f56e37f5943d8d277f76ee8

diff --git a/swank.R b/swank.R
index 1dc95b4..f0aee27 100644
--- a/swank.R
+++ b/swank.R
@@ -113,6 +113,7 @@ sldbLoop <- function(slimeConnection, sldbState, id) {
 }
 
 readPacket <- function(io) {
+  socketSelect(list(io))
   header <- readChunk(io, 6)
   len <- strtoi(header, base=16)
   payload <- readChunk(io, len)
@@ -244,10 +245,13 @@ writeSexpToString <- function(obj) {
   writeSexpToStringLoop(obj)
 }
 
+prin1ToString <- function(val) {
+  paste(deparse(val, backtick=TRUE, control=c("delayPromises", "keepNA")),
+        sep="", collapse="\n")
+}
+
 printToString <- function(val) {
-  f <- fifo("")
-  tryCatch({ sink(f); print(val); sink(); readLines(f) },
-           finally=close(f))
+  paste(capture.output(print(val)), sep="", collapse="\n")
 }
 
 `swank:connection-info` <- function (slimeConnection, sldbState) {
@@ -272,12 +276,17 @@ printToString <- function(val) {
   list("R", "R")
 }
 
-sendReplResult <- function(slimeConnection, value) {
+makeReplResult <- function(value) {
   string <- printToString(value)
-  sendToEmacs(slimeConnection,
-              list(quote(`:write-string`),
-                   paste(string, collapse="\n"),
-                   quote(`:repl-result`)))
+  list(quote(`:write-string`), string,
+       quote(`:repl-result`))
+}
+
+makeReplResultFunction <- makeReplResult
+
+sendReplResult <- function(slimeConnection, value) {
+  result <- makeReplResultFunction(value)
+  sendToEmacs(slimeConnection, result)
 }
 
 sendReplResultFunction <- sendReplResult
@@ -360,13 +369,19 @@ computeRestartsForEmacs <- function (sldbState) {
   FALSE
 }
 
+`swank:eval-string-in-frame` <- function(slimeConnection, sldbState, string, index) {
+  frame <- sldbState$frames[[1+index]]
+  withRetryRestart("retry SLIME interactive evaluation request",
+                   value <- eval(parse(text=string), envir=frame))
+  printToString(value)
+}
+
 `swank:frame-locals-and-catch-tags` <- function(slimeConnection, sldbState, index) {
-  str(sldbState$frames)
   frame <- sldbState$frames[[1+index]]
   objs <- ls(envir=frame)
   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`), printToString(eval(parse(text=name), envir=frame))) }),
        list())
 }
 
@@ -393,30 +408,30 @@ computeRestartsForEmacs <- function (sldbState) {
   list(quote(`:compilation-result`), list(), TRUE, times[3])
 }
 
-`swank:interactive-eval` <-  function(slimeConnection, sldbState, string) {
+withRetryRestart <- function(description, expr) {
+  call <- substitute(expr)
   retry <- TRUE
-  value <- ""
   while(retry) {
     retry <- FALSE
-    withRestarts(value <- eval(parse(text=string), envir = globalenv()),
-                 retry=list(description="retry SLIME interactive evaluation request", handler=function() retry <<- TRUE))
+    withRestarts(eval.parent(call),
+                 retry=list(description=description,
+                   handler=function() retry <<- TRUE))
   }
-  printToString(value)
+}
+
+`swank:interactive-eval` <-  function(slimeConnection, sldbState, string) {
+  withRetryRestart("retry SLIME interactive evaluation request",
+                   value <- eval(parse(text=string), envir=globalenv()))
+  prin1ToString(value)
 }
 
 `swank:eval-and-grab-output` <- function(slimeConnection, sldbState, string) {
-  retry <- TRUE
-  value <- ""
-  output <- NULL
-  f <- fifo("")
-  tryCatch({
-    sink(f)
-    while(retry) {
-      retry <- FALSE
-      withRestarts(value <- eval(parse(text=string), envir = globalenv()),
-                   retry=list(description="retry SLIME interactive evaluation request", handler=function() retry <<- TRUE))}},
-           finally={sink(); output <- readLines(f); close(f)})
-  list(output, printToString(value))
+  withRetryRestart("retry SLIME interactive evaluation request",
+                   { output <-
+                       capture.output(value <- eval(parse(text=string),
+                                                    envir=globalenv())) })
+  output <- paste(output, sep="", collapse="\n")
+  list(output, prin1ToString(value))
 }
 
 `swank:find-definitions-for-emacs` <- function(slimeConnection, sldbState, string) {
@@ -443,3 +458,176 @@ computeRestartsForEmacs <- function (sldbState) {
     list()
   }
 }
+
+`swank:value-for-editing` <- function(slimeConnection, sldbState, string) {
+  paste(deparse(eval(parse(text=string), envir = globalenv()), control="all"),
+        collapse="\n", sep="")
+}
+
+`swank:commit-edited-value` <- function(slimeConnection, sldbState, string, value) {
+  eval(parse(text=sprintf("%s <- %s", string, value)), envir = globalenv())
+  TRUE
+}
+
+resetInspector <- function(slimeConnection) {
+  assign("istate", list(), envir=slimeConnection)
+  assign("inspectorHistory", NULL, envir=slimeConnection)
+}
+
+`swank:init-inspector` <- function(slimeConnection, sldbState, string) {
+  withRetryRestart("retry SLIME inspection request",
+                   { resetInspector(slimeConnection)
+                     value <- inspectObject(slimeConnection, eval(parse(text=string), envir=globalenv()))
+                   })
+  value
+}
+
+inspectObject <- function(slimeConnection, object) {
+  previous <- slimeConnection$istate
+  slimeConnection$istate <- new.env()
+  slimeConnection$istate$object <- object
+  slimeConnection$istate$previous <- previous
+  slimeConnection$istate$content <- emacsInspect(object)
+  if(!(object %in% slimeConnection$inspectorHistory)) {
+    slimeConnection$inspectorHistory <- c(slimeConnection$inspectorHistory, object)
+  }
+  if(!is.null(slimeConnection$istate$previous)) {
+    slimeConnection$istate$previous$`next` <- slimeConnection$istate
+  }
+  istateToElisp(slimeConnection$istate)
+}
+
+valuePart <- function(istate, object, string) {
+  list(quote(`:value`),
+       if(is.null(string)) printToString(object) else string,
+       assignIndexInParts(object, istate))
+}
+
+preparePart <- function(istate, part) {
+  if(is.character(part)) {
+    list(part)
+  } else {
+    switch(as.character(part[[1]]),
+           `:newline` = list("\n"),
+           `:value` = valuePart(istate, part[[2]], part[[3]]),
+           `:line` = list(printToString(part[[2]]), ": ",
+             valuePart(istate, part[[3]], NULL), "\n"))
+  }
+}
+
+prepareRange <- function(istate, start, end) {
+  range <- istate$content[start+1:min(end+1, length(istate$content))]
+  ps <- NULL
+  for(part in range) {
+    ps <- c(ps, preparePart(istate, part))
+  }
+  list(ps, if(length(ps)<end-start) { start+length(ps) } else { end+1000 },
+       start, end)
+}
+
+assignIndexInParts <- function(object, istate) {
+  ret <- 1+length(istate$parts)
+  istate$parts <- c(istate$parts, list(object))
+  ret
+}
+
+istateToElisp <- function(istate) {
+  list(quote(`:title`), deparse(istate$object, control="all", nlines=1),
+       quote(`:id`), assignIndexInParts(istate$object, istate),
+       quote(`:content`), prepareRange(istate, 0, 500))
+}
+
+emacsInspect <- function(object) {
+  UseMethod("emacsInspect")
+}
+
+emacsInspect.default <- function(thing) {
+  c(list(paste("a ", class(thing)[[1]], sep=""), list(quote(`:newline`))))
+}
+
+emacsInspect.list <- function(list) {
+  c(list("a list", list(quote(`:newline`))),
+    mapply(function(name, value) { list(list(quote(`:line`), name, value)) },
+           names(list), list))
+}
+
+emacsInspect.numeric <- function(numeric) {
+  c(list("a numeric", list(quote(`:newline`))),
+    mapply(function(name, value) { list(list(quote(`:line`), name, value)) },
+           (1:length(numeric)), numeric))
+}
+
+`swank:quit-inspector` <- function(slimeConnection, sldbState) {
+  resetInspector(slimeConnection)
+  FALSE
+}
+
+`swank:inspector-nth-part` <- function(slimeConnection, sldbState, index) {
+  slimeConnection$istate$parts[[index]]
+}
+
+`swank:inspect-nth-part` <- function(slimeConnection, sldbState, index) {
+  object <- `swank:inspector-nth-part`(slimeConnection, sldbState, index)
+  inspectObject(slimeConnection, object)
+}
+
+`swank:inspector-pop` <- function(slimeConnection, sldbState) {
+  if(!is.null(slimeConnection$istate$previous)) {
+    slimeConnection$istate <- slimeConnection$istate$previous
+    istateToElisp(slimeConnection$istate)
+  } else {
+    FALSE
+  }
+}
+
+`swank:inspector-next` <- function(slimeConnection, sldbState) {
+  if(!is.null(slimeConnection$istate$`next`)) {
+    slimeConnection$istate <- slimeConnection$istate$`next`
+    istateToElisp(slimeConnection$istate)
+  } else {
+    FALSE
+  }
+}
+
+`swank:inspector-eval` <- function(slimeConnection, sldbState, string) {
+  expr <- parse(text=string)[[1]]
+  object <- slimeConnection$istate$object
+  if(inherits(object, "list")|inherits(object, "environment")) {
+    substituted <- substituteDirect(expr, object)
+    eval(substituted, envir=globalenv())
+  } else {
+    eval(expr, envir=globalenv())
+  }
+}
+
+`swank:inspect-current-condition` <- function(slimeConnection, sldbState) {
+  resetInspector(slimeConnection)
+  inspectObject(slimeConnection, sldbState$condition)
+}
+
+`swank:inspect-frame-var` <- function(slimeConnection, sldbState, frame, var) {
+  resetInspector(slimeConnection)
+  frame <- sldbState$frames[[1+frame]]
+  name <- ls(envir=frame)[[1+var]]
+  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)
+  TRUE
+}
+
+`swank:compile-file-for-emacs` <- function(slimeConnection, sldbState, filename, loadp, ...) {
+  times <- system.time(parse(filename))
+  list(quote(`:compilation-result`), list(), TRUE, times[3], substitute(loadp), filename)
+}