The internal code of the edtdbg debugging tool, which will be discussed in Section 13.4, makes heavy use of string utilities. A typical example of such usage is the dgbsendeditcmd() function:
# send command to editor
dbgsendeditcmd <- function(cmd) {
syscmd <- paste("vim --remote-send ",cmd," --servername ",vimserver,sep="")
system(syscmd)
}What is going on here? The main point is that edtdbg sends remote commands to the Vim text editor. For instance, if you are running Vim with a server name of 168 and you want the cursor in Vim to move to line 12, you could type this into a terminal (shell) window:
vim --remote-send 12G --servername 168
The effect would be the same as if you had physically typed 12G at the Vim window. Since 12G is the Vim command to move the cursor to line 12, that’s what would occur. Consider this call:
paste("vim --remote-send ",cmd," --servername ",vimserver,sep="")Here, cmd is the string "12G", vimserver is 168, and paste() concatenates all the indicated strings. The argument sep="" says to use the empty string as separator in this concatenation—that is, no separation. Thus, paste() returns the following:
vim --remote-send 12G --servername 168
Another core element in the operation of edtdbg is that the program has arranged, via a call to R’s sink() function, to record to the file dbgsink most output from R’s debugger in your R window. (The edtdbg utility works in concert with that debugger.) That information includes the line numbers of your positions in your source file as you step through it using R’s debugger.
The line position information in the debugger output looks like this:
debug at cities.r#16: {So, there is code in edtdbg to determine the latest line in dbgsink that begins with “debug at.” That line is then placed, as a string, in a variable named debugline. The following code then extracts the line number (16 in the example) and the source filename/Vim buffer name (cities.r here):
linenumstart <- regexpr("#",debugline) + 1
buffname <- substr(debugline,10,linenumstart-2)
colon <- regexpr(":",debugline)
linenum <- substr(debugline,linenumstart,colon-1)The call to regexpr() determines where in debugline the # character is located (character 18 in this example). Adding 1 to that gives the position of the line number within debugline.
To get the buffer name, using the preceding example as a guide, we see that the name comes after debug at and ends just before the #. Since “debug at” contains nine characters, the buffer name will start at position 10—hence the 10 in the call,
substr(debugline,10,linenumstart-2)
The end of the buffer name field is at linenumstart-2, as it is just before the #, which precedes the start of the line number. The line number computation is then similar.
Another illustrative example of edtdbg’s internal code is its use of the strsplit() function. For example, at one point, it prints out a prompt to the user:
kbdin <- readline(prompt="enter number(s) of fns you wish to toggle dbg: ")
As you can see, the user’s response is stored in kbdin. It will consist of a set of numbers separated by spaces, such as this:
1 4 5
We need to extract the numbers from the string 1 4 5 into an integer vector. This is done first via strsplit(), which produces three strings: "1", "4", and "5". Then we call as.integer() to convert from characters to numbers:
tognums <- as.integer(strsplit(kbdin,split=" ")[[1]])
Note that the output of strsplit() is an R list, in this case consisting of one element, which is in turn the vector ("1","4","5"). This leads to the expression [[1]] in the example.