Added documentation

autoload/vebugger.vim

@@ -1,3 +1,4 @@
+"Read and return all new lines from a Vebugger pipe object.
 function! s:readNewLinesFromPipe(pipeObject)
 	"read
 	let l:text=a:pipeObject.pipe.read(1000,0)
@@ -19,6 +20,7 @@ endfunction
 
 let s:f_debugger={}
 
+"Terminate the debugger
 function! s:f_debugger.kill() dict
 	if self.shell.is_valid
 		call self.addLineToTerminal('','== DEBUGGER TERMINATED ==')
@@ -32,10 +34,12 @@ function! s:f_debugger.kill() dict
 	endif
 endfunction
 
+"Write a line to the debugger's interactive shell
 function! s:f_debugger.writeLine(line) dict
 	call self.shell.stdin.write(a:line."\n")
 endfunction
 
+"Check for new lines from the debugger's interactive shell and handle them
 function! s:f_debugger.invokeReading() dict
 	let l:newLines={}
 	for l:k in keys(self.pipes)
@@ -58,6 +62,7 @@ function! s:f_debugger.invokeReading() dict
 	call feedkeys("f\e") " Make sure the CursorHold event is refired even if the user does nothing
 endfunction
 
+"Handle a single line from the debugger's interactive shell
 function! s:f_debugger.handleLine(pipeName,line) dict
 	call self.addLineToTerminal(a:pipeName,a:line)
 
@@ -74,6 +79,7 @@ function! s:f_debugger.handleLine(pipeName,line) dict
 	call self.performWriteActions()
 endfunction
 
+"Perform all write actions
 function! s:f_debugger.performWriteActions() dict
 	for l:namespace in keys(self.writeActions)
 		let l:handlers=get(self.writeHandlers,l:namespace)
@@ -90,6 +96,8 @@ function! s:f_debugger.performWriteActions() dict
 	call self.generateWriteActionsFromTemplate()
 endfunction
 
+"Show the terminal buffer that gets it's content from the debugger's
+"interactive shell
 function! s:f_debugger.showTerminalBuffer() dict
 	if has_key(self,'terminalBuffer')
 		if -1<bufwinnr(self.terminalBuffer)
@@ -104,6 +112,7 @@ function! s:f_debugger.showTerminalBuffer() dict
 	wincmd p
 endfunction
 
+"Close the terminal buffer
 function! s:f_debugger.closeTerminalBuffer() dict
 	if has_key(self,'terminalBuffer')
 		if -1<bufwinnr(self.terminalBuffer)
@@ -115,6 +124,7 @@ function! s:f_debugger.closeTerminalBuffer() dict
 	endif
 endfunction
 
+"Check if the terminal buffer associated with this debugger is currently open
 function! s:f_debugger.isTerminalBufferOpen() dict
 	if has_key(self,'terminalBuffer')
 		if -1<bufwinnr(self.terminalBuffer)
@@ -124,6 +134,7 @@ function! s:f_debugger.isTerminalBufferOpen() dict
 	return 0
 endfunction
 
+"Turn on and off the terminal buffer associated with this debugger
 function! s:f_debugger.toggleTerminalBuffer() dict
 	if self.isTerminalBufferOpen()
 		call self.closeTerminalBuffer()
@@ -132,6 +143,7 @@ function! s:f_debugger.toggleTerminalBuffer() dict
 	endif
 endfunction
 
+"Write a line to the terminal buffer. This function does not process the line
 function! s:f_debugger.addLineToTerminal(pipeName,line) dict
 	if has_key(self,'terminalBuffer')
 		let l:bufwin=bufwinnr(self.terminalBuffer)
@@ -150,6 +162,7 @@ function! s:f_debugger.addLineToTerminal(pipeName,line) dict
 	endif
 endfunction
 
+"Add an handler to a handler list
 function! s:addHandler(list,handler)
 	if type(a:handler) == type({})
 		call add(a:list,a:handler)
@@ -158,6 +171,7 @@ function! s:addHandler(list,handler)
 	endif
 endfunction
 
+"Set a named handler in a handler dictionary
 function! s:setHandler(dict,namespace,name,handler)
 	if !has_key(a:dict,a:namespace)
 		let a:dict[a:namespace]={}
@@ -169,34 +183,51 @@ function! s:setHandler(dict,namespace,name,handler)
 	endif
 endfunction
 
+"Add a read handler. Read handlers process output from the debugger's
+"interactive shell and modify read result objects with structured information
+"parsed from those lines
 function! s:f_debugger.addReadHandler(handler) dict
 	call s:addHandler(self.readHandlers,a:handler)
 endfunction
 
+"Add a think handler. Think handlers are debugger agnostic - they look at
+"read result objects and decide what to do with them.
 function! s:f_debugger.addThinkHandler(handler) dict
 	call s:addHandler(self.thinkHandlers,a:handler)
 endfunction
 
+"Set a write handler. Write handlers get write action objects and convert them
+"to debugger specific commands. A write action can only handle a write action
+"of the namespace and name it is registered for, to prevent the same write
+"action handled by multiple write handlers.
 function! s:f_debugger.setWriteHandler(namespace,name,handler) dict
 	call s:setHandler(self.writeHandlers,a:namespace,a:name,a:handler)
 endfunction
 
+"Add a close handler. Close handlers are called when the debugger is closed to
+"tidy things up.
 function! s:f_debugger.addCloseHandler(handler) dict
 	call s:addHandler(self.closeHandlers,a:handler)
 endfunction
 
+"Create an empty write action that follows the write actions template. That
+"action will later be filled by think handlers or from outside.
 function! s:f_debugger.generateWriteActionsFromTemplate() dict
 	let self.writeActions=deepcopy(self.writeActionsTemplate)
 endfunction
 
+"Set a write action of a specific namespace and name, for write actions that
+"do not support a list
 function! s:f_debugger.setWriteAction(namespace,name,value) dict
 	let self.writeActions[a:namespace][a:name]=a:value
 endfunction
 
+"Add a write action of a specific namespace and name, for write actions that supports a list
 function! s:f_debugger.addWriteAction(namespace,name,value) dict
 	call add(self.writeActions[a:namespace][a:name],a:value)
 endfunction
 
+"Create a bare debugger object from a raw shell line
 function! vebugger#createDebugger(command)
 
 	let l:debugger=deepcopy(s:f_debugger)
@@ -225,8 +256,8 @@ function! vebugger#createDebugger(command)
 	return l:debugger
 endfunction
 
-" all the functions here are currently just for testing:
 
+"Create a debugger and set it as the currently active debugger
 function! vebugger#startDebugger(command)
 	call vebugger#killDebugger()
 
@@ -240,6 +271,7 @@ function! vebugger#startDebugger(command)
 	return s:debugger
 endfunction
 
+"Terminate the currently active debugger
 function! vebugger#killDebugger()
 	augroup vebugger_shell
 		autocmd!
@@ -251,24 +283,28 @@ function! vebugger#killDebugger()
 	endif
 endfunction
 
+"Write a line to the currently active debugger
 function! vebugger#writeLine(line)
 	if exists('s:debugger')
 		call s:debugger.writeLine(a:line)
 	endif
 endfunction
 
+"Invoke reading for the currently active debugger
 function! vebugger#invokeReading()
 	if exists('s:debugger')
 		call s:debugger.invokeReading()
 	endif
 endfunction
 
+"Toggle the terminal buffer for the currently active debugger
 function! vebugger#toggleTerminalBuffer()
 	if exists('s:debugger')
 		call s:debugger.toggleTerminalBuffer()
 	endif
 endfunction
 
+"Fetch the currently active debugger object
 function! vebugger#getActiveDebugger()
 	if exists('s:debugger')
 		return s:debugger
@@ -277,29 +313,34 @@ function! vebugger#getActiveDebugger()
 	endif
 endfunction
 
+"Set a write action for the currently active debugger
 function! vebugger#setWriteAction(namespace,name,value)
 	if exists('s:debugger')
 		call s:debugger.setWriteAction(a:namespace,a:name,a:value)
 	endif
 endfunction
 
+"Add a write action to the currently active debugger
 function! vebugger#addWriteAction(namespace,name,value)
 	if exists('s:debugger')
 		call s:debugger.addWriteAction(a:namespace,a:name,a:value)
 	endif
 endfunction
 
+"Force performing all the write of the currently active debugger
 function! vebugger#performWriteActions()
 	if exists('s:debugger')
 		call s:debugger.performWriteActions()
 	endif
 endfunction
 
+"Set a write action for the currently active debugger and perform it
 function! vebugger#setWriteActionAndPerform(namespace,name,value)
 	call vebugger#setWriteAction(a:namespace,a:name,a:value)
 	call vebugger#performWriteActions()
 endfunction
 
+"Add a write action to the currently active debugger and perform it
 function! vebugger#addWriteActionAndPerform(namespace,name,value)
 	call vebugger#addWriteAction(a:namespace,a:name,a:value)
 	call vebugger#performWriteActions()

autoload/vebugger/std.vim

@@ -1,5 +1,6 @@
 let g:vebugger_breakpoints=[]
 
+"Initialize the std part of the debugger's state
 function! vebugger#std#setStandardState(debugger)
 	let a:debugger.state.std={
 				\'config':{
@@ -9,6 +10,7 @@ function! vebugger#std#setStandardState(debugger)
 				\'evaluateExpressions':[]}
 endfunction
 
+"Initialize the std part of the debugger's read result template
 function! vebugger#std#setStandardReadResultTemplate(debugger)
 	let a:debugger.readResultTemplate.std={
 				\'programOutput':{},
@@ -19,6 +21,7 @@ function! vebugger#std#setStandardReadResultTemplate(debugger)
 				\'exception':{}}
 endfunction
 
+"Initialize the std part of the debugger's write actions template
 function! vebugger#std#setStandardWriteactionsTemplate(debugger)
 	let a:debugger.writeActionsTemplate.std={
 				\'flow':'',
@@ -29,24 +32,28 @@ function! vebugger#std#setStandardWriteactionsTemplate(debugger)
 				\'closeDebugger':''}
 endfunction
 
+"Adds the std_ functions to the debugger object
 function! vebugger#std#addStandardFunctions(debugger)
 	for l:k in keys(s:standardFunctions)
 		let a:debugger['std_'.l:k]=s:standardFunctions[l:k]
 	endfor
 endfunction
 
+"Add the standard think handlers to the debugger
 function! vebugger#std#addStandardThinkHandlers(debugger)
 	for l:ThinkHandler in values(s:standardThinkHandlers)
 		call a:debugger.addThinkHandler(l:ThinkHandler)
 	endfor
 endfunction
 
+"Add the standard close handlers to the debugger
 function! vebugger#std#addStandardCloseHandlers(debugger)
 	for l:CloseHandler in values(s:standardCloseHandlers)
 		call a:debugger.addCloseHandler(l:CloseHandler)
 	endfor
 endfunction
 
+"Performs the standard initialization of the debugger object
 function! vebugger#std#standardInit(debugger)
 	call vebugger#std#setStandardState(a:debugger)
 	call vebugger#std#setStandardReadResultTemplate(a:debugger)
@@ -56,6 +63,7 @@ function! vebugger#std#standardInit(debugger)
 	call vebugger#std#addStandardCloseHandlers(a:debugger)
 endfunction
 
+"Start a debugger with the std settings
 function! vebugger#std#startDebugger(command)
 	let l:debugger=vebugger#startDebugger(a:command)
 
@@ -65,6 +73,10 @@ function! vebugger#std#startDebugger(command)
 endfunction
 
 
+"Opens the shell buffer for a debugger. The shell buffer displays the output
+"of the debugged program, and when it's closed the debugger gets terminated.
+"Shell buffers should not be used when attaching a debugger to a running
+"process.
 function! vebugger#std#openShellBuffer(debugger)
 	if has_key(a:debugger,'shellBuffer')
 		if -1<bufwinnr(a:debugger.shellBuffer)
@@ -90,6 +102,8 @@ function! vebugger#std#openShellBuffer(debugger)
 endfunction
 
 let s:standardFunctions={}
+
+"Write a line to the shell buffer
 function! s:standardFunctions.addLineToShellBuffer(line) dict
 	if has_key(self,'shellBuffer')
 		let l:bufwin=bufwinnr(self.shellBuffer)
@@ -102,6 +116,7 @@ function! s:standardFunctions.addLineToShellBuffer(line) dict
 	endif
 endfunction
 
+"Set the write actions to add all breakpoints registered in Vebugger
 function! s:standardFunctions.addAllBreakpointActions(breakpoints) dict
 	for l:breakpoint in a:breakpoints
 		call self.addWriteAction('std','breakpoints',{
@@ -111,6 +126,7 @@ function! s:standardFunctions.addAllBreakpointActions(breakpoints) dict
 	endfor
 endfunction
 
+"Make the debugger evaluate an expression
 function! s:standardFunctions.eval(expression) dict
 	if -1==index(self.state.std.evaluateExpressions,a:expression)
 		call add(self.state.std.evaluateExpressions,a:expression)
@@ -120,14 +136,17 @@ function! s:standardFunctions.eval(expression) dict
 	call self.performWriteActions()
 endfunction
 
-"Executes a statement in the debugged program
+"Execute a statement in the debugged program
 function! s:standardFunctions.execute(statement) dict
 	call self.addWriteAction('std','executeStatements',{
 				\'statement':(a:statement)})
 	call self.performWriteActions()
 endfunction
 
+
 let s:standardThinkHandlers={}
+
+"Update the shell buffer with program output
 function! s:standardThinkHandlers.addProgramOutputToShell(readResult,debugger) dict
 	let l:programOutput=a:readResult.std.programOutput
 	if !empty(l:programOutput)
@@ -135,6 +154,7 @@ function! s:standardThinkHandlers.addProgramOutputToShell(readResult,debugger) d
 	endif
 endfunction
 
+"Make Vim jump to the currently executed line
 function! s:standardThinkHandlers.moveToCurrentLine(readResult,debugger) dict
 	if !empty(a:readResult.std.location)
 		if !empty(a:debugger.state.std.config.externalFileStop_flowCommand) " Do we need to worry about stopping at external files?
@@ -157,6 +177,7 @@ function! s:standardThinkHandlers.moveToCurrentLine(readResult,debugger) dict
 	endif
 endfunction
 
+"Update the call stack
 function! s:standardThinkHandlers.updateCallStack(readResult,debugger) dict
 	let l:callstack=a:readResult.std.callstack
 	if !empty(l:callstack)
@@ -172,6 +193,7 @@ function! s:standardThinkHandlers.updateCallStack(readResult,debugger) dict
 	endif
 endfunction
 
+"Print an expression that it's evaluation was previously requested
 function! s:standardThinkHandlers.printEvaluatedExpression(readResult,debugger) dict
 	let l:evaluatedExpression=a:readResult.std.evaluatedExpression
 	if !empty(l:evaluatedExpression)
@@ -189,12 +211,15 @@ function! s:standardThinkHandlers.printEvaluatedExpression(readResult,debugger)
 	endif
 endfunction
 
+"Close the debugger when the program is finished but the debugger wasn't
+"closed automatically
 function! s:standardThinkHandlers.closeDebuggerWhenProgramFinishes(readResult,debugger) dict
 	if !empty(a:readResult.std.programFinish)
 		call a:debugger.setWriteAction('std','closeDebugger','close')
 	endif
 endfunction
 
+"Print an exception message
 function! s:standardThinkHandlers.printException(readResult,debugger) dict
 	if !empty(a:readResult.std.exception)
 		echohl WarningMsg
@@ -204,6 +229,7 @@ function! s:standardThinkHandlers.printException(readResult,debugger) dict
 endfunction
 
 let s:standardCloseHandlers={}
+"Remove the currently executed line when a debugger is closed
 function! s:standardCloseHandlers.removeCurrentMarker(debugger) dict
 	let a:debugger.state.std.location={}
 	sign unplace 1
@@ -211,6 +237,8 @@ endfunction
 
 sign define vebugger_current text=->
 sign define vebugger_breakpoint text=** linehl=ColorColumn
+
+"Update all the marks(currently executed line and breakpoints) for a file
 function! vebugger#std#updateMarksForFile(state,filename)
 	let l:filename=fnamemodify(a:filename,":p")
 	if bufexists(l:filename)
@@ -232,6 +260,7 @@ function! vebugger#std#updateMarksForFile(state,filename)
 	endif
 endfunction
 
+"Toggle a breakpoint on and off
 function! vebugger#std#toggleBreakpoint(file,line)
 	let l:debugger=vebugger#getActiveDebugger()
 	let l:debuggerState=empty(l:debugger)
@@ -257,6 +286,7 @@ function! vebugger#std#toggleBreakpoint(file,line)
 	call vebugger#std#updateMarksForFile(l:debuggerState,a:file)
 endfunction
 
+"Clear all breakpoints
 function! vebugger#std#clearBreakpoints()
 	let l:debugger=vebugger#getActiveDebugger()
 	let l:debuggerState=empty(l:debugger) ? {} : l:debugger.state
@@ -274,6 +304,7 @@ function! vebugger#std#clearBreakpoints()
 	endfor
 endfunction
 
+"Ask the active debugger to evaluate an expression
 function! vebugger#std#eval(expression)
 	let l:debugger=vebugger#getActiveDebugger()
 	if !empty(l:debugger) && !empty(l:debugger.std_eval)
@@ -281,6 +312,7 @@ function! vebugger#std#eval(expression)
 	endif
 endfunction
 
+"Ask the active debugger to execute a statement
 function! vebugger#std#execute(statement)
 	let l:debugger=vebugger#getActiveDebugger()
 	if !empty(l:debugger) && !empty(l:debugger.std_eval)

autoload/vebugger/util.vim

@@ -1,6 +1,7 @@
 
-"Shamefully stolen from http://stackoverflow.com/a/6271254/794380
+"Returns the visually selected text
 function! vebugger#util#get_visual_selection()
+	"Shamefully stolen from http://stackoverflow.com/a/6271254/794380
 	" Why is this not a built-in Vim script function?!
 	let [lnum1, col1] = getpos("'<")[1:2]
 	let [lnum2, col2] = getpos("'>")[1:2]
@@ -10,6 +11,8 @@ function! vebugger#util#get_visual_selection()
 	return join(lines, "\n")
 endfunction
 
+"Prompts the user with a filtered list of process, and returns the process id
+"the user selects
 function! vebugger#util#selectProcessOfFile(ofFile)
 	let l:fileName=fnamemodify(a:ofFile,':t')
 	let l:resultLines=split(vimproc#system('ps -o pid,user,comm,start,state,tt -C '.fnameescape(l:fileName)),'\r\n\|\n\|\r')
@@ -32,6 +35,8 @@ function! vebugger#util#selectProcessOfFile(ofFile)
 	return str2nr(matchlist(l:chosenLine,'\v^\s*\d+\)\s+(\d+)')[1])
 endfunction
 
+"Escape args(from a debugger's extra arguments) as a command line arguments
+"string
 function! vebugger#util#commandLineArgsForProgram(debuggerArgs)
 	if has_key(a:debuggerArgs,'args')
 		if type(a:debuggerArgs.args)==type([])
@@ -44,6 +49,7 @@ function! vebugger#util#commandLineArgsForProgram(debuggerArgs)
 	endif
 endfunction
 
+"Escape a single argument for the command line
 function! s:argEscape(arg)
 	if has('win32')
 		return shellescape(a:arg)

doc/vebugger.txt

@@ -0,0 +1,200 @@
+*vebugger.txt*
+
+
+Author:  Idan Arye <https://github.com/someboddy/>
+License: Same terms as Vim itself (see |license|)
+
+Version: 1.0.0
+
+INTRODUCTION                                                       *vebugger*
+
+Vebugger is yet another debugger frontend plugin for Vim, created because I
+wasn't happy with the other debugger plugins I found. Vebugger currently
+supports:
+* Tracking the currently executed command in the source code
+* Debugger flow commands - step-in, set-over, set-out and continue
+* Breakpoints management
+* Evaluating expressions in the current executed scope
+* Messing with the program's state(changing values, calling functions)
+
+Vebugger is built as a generic framework for building frontends for
+interactive shell debugger, and comes with implementations for:
+* GDB - doesn't need introdcution...
+* JDB - a Java debugger
+* PDB - a Python module for debugging Python scripts
+* RDebug - a Ruby command line option for debugging Ruby scripts
+Other implementations can be added with ease.
+
+Vebugger is built under the following assumptions:
+* While command line debuggers share enough in common to make the creation
+  of such a framework as Vebugger possible, the differences between them are
+  too great to be expressed with regular expression. To support them all at
+  least some code has to be written.
+* Unlike IDE users, Vim users tend to understand the tools the operate behind
+  the scenes. While Vebugger automates the common features, it allows you to
+  "open the hood" and interact with the debugger's shell directly so you could
+  utilize the full power of your debugger.
+* I have no intention to aim for the lowest common denominator. If one
+  debugger has a cool feature I want to support, I'll implement it even if the
+  other debuggers don't have it.
+
+
+CONFIGURATION                                        *vebugger-configuration*
+
+If you want to use the keymaps, you need to choose a leader for them by
+setting *g:vebugger_leader* in your vimrc.
+
+Example: >
+    let g:vebugger_leader='<Leader>d'
+<
+
+LAUNCHING DEBUGGERS                                      *vebugger-launching*
+
+A debugger's implementation is responsible for starting it. The standard is to
+have a "start" function that accepts two arguments: The file to launch(EXE
+file or main script file) and a dictionary of other arguments. There should
+also be a command for launching the debugger with more ease.
+
+
+LAUNCHING GDB                                                 *vebugger-gdb*
+
+GDB can be launched with *vebuger#gdb#start*
+>
+    call vebugger#gdb#start('a.out',{'args':['hello','world']})
+<
+
+The supported extra arguments are:
+* "args": Command line arguments for the debugged program
+* "pid": Process id to attach to
+You can't specify both "args" and "pid".
+
+GDB can also be launched with the *VBGstartGDB* command:
+>
+    VBGstartGDB a.out hello world
+<
+The *VBGattachGDB* command searches for processes launched from the EXE to
+attach to, and attaches to them:
+>
+   VBGattachGDB a.out
+<
+
+LAUNCHING JDB                                                 *vebugger-jdb*
+
+JDB is launched with *vebugger#jdb#start*
+>
+    call vebugger#jdb#start('Main',{
+        \'classpath':'classes',
+        \'srcpath':'src',
+        \'args':['hello','world']})
+<
+Unlike in the other debuggers, the first argument here is not the name of a
+file - it's the name of the class to run. The supported extra arguments are:
+* "args": Command line arguments for the debugged program
+* "classpath": Where to look for class files
+* "srcpath": Where to look for source files
+If you don't supply "classpath" and "srcpath", Vebugger will assume you are
+using the current directory for source files and class files.
+
+JDB does not have a command for starting it, since you usually want to supply
+"classpath" and "srcpath".
+
+
+LAUNCHING RDEBUG                                             *vebugger-rdebug*
+
+RDebug is launched with *vebugger#rdebug#start*
+>
+    call vebugger#rdebug#start('script.rb',{'args':['hello','world']})
+<
+The supported extra arguments are:
+* "args": Command line arguments for the debugged script
+
+RDebug can also be launched with the *VBGstartRDebug* command:
+>
+    VBGstartRDebug script.rb hello world
+<
+
+LAUNCHING PDB                                                  *vebugger-pdb*
+
+PDB is launched with *vebugger#pdb#start*
+>
+    call vebugger#pdb#start('script.py',{'args':['hello','world']})
+<
+The supported extra arguments are:
+* "args": Command line arguments for the debugged script
+
+PDB can also be launched with the *VBGstartPDB* command:
+>
+    VBGstartPDB script.py hello world
+<
+
+USING THE DEBUGGERS                        *vebugger-usage* *vebugger-commands*
+
+Once you have launched a debugger, you can use the following commands to
+interact with it:
+
+
+CONTROL THE EXECUTION OF THE PROGRAM              *vebugger-execution-control*
+
+*:VBGstepOver* Continue the execution, stopping at the next statement.
+*:VBGstepIn* Same as VBGstepOver but stepps into functions.
+*:VBGstepOut* Continue the execution until the end of the current function.
+*:VBGcontinue* Continue the execution.
+
+MANAGE BREAKPOINTS                                      *vebugger-breakpoints*
+
+*:VBGtoggleBreakpoint* Toggle a breakpoint. The file and line should be supplied as arguments.
+*:VBGtoggleBreakpointThisLine* Toggle a breakpoint for the current line.
+*:VBGclearBreakpints* Clear all breakpoints.
+
+EVALUATE EXPRESSIONS                                      *vebugger-evalutate*
+
+*:VBGeval* Evaluate and print the expression supplied as argument.
+*:VBGevalSelectedText* Evaluate and print the selected text.
+*:VBGevalWordUnderCursor* Evaluate the <cword> under the cursor
+
+EXECUTE STATEMENTS                                          *vebugger-execute*
+
+*:VBGexecute* Execute the statement supplied as argument.
+*:VBGexecuteSelectedText* Execute the selected text.
+
+TERMINATING THE DEBUGGER                                  *vebugger-terminate*
+
+*:VBGkill* Terminates the debugger
+
+OPENING THE HOOD                                      *vebugger-open-the-hood*
+
+You can open the hood and interact with the running debugger directly using
+the following commands:
+
+*:VBGtoggleTerminalBuffer* Opens a buffer that shows everything printed from
+the debugger interactive shell.
+*:VBGrawWrite* Sends a line supplied as argument to the debugger interactive shell.
+*:VBGrawWriteSelectedText* Sends the selected text to the debugger interactive
+shell.
+
+
+KEYMAPS                                                    *vebugger-keymaps*
+
+If you set|g:vebugger_leader| in your vimrc you'll get keymaps for the
+Vebugger commands. The keymaps all start with the leader you set, following
+with:
+
+i      |:VBGstepIn|
+o      |:VBGstepOver|
+O      |:VBGstepOut|
+c      |:VBGcontinue|
+
+b      |:VBGtoggleBreakpointThisLine|
+B      |:VBGclearBreakpints|
+
+e      |:VBGevalWordUnderCursor| in normal mode
+       |:VBGevalSelectedText| in select mode
+E      Prompt for an argument for |:VBGeval|
+
+x      |:VBGexecute| current line in normal mode.
+       |:VBGexecuteSelectedText| in select mode
+X      Prompt for an argument for |:VBGexecute|
+
+t      |:VBGtoggleTerminalBuffer|
+r      Select mode only - |:VBGrawWriteSelectedText|
+R      Prompt for an argument for |:VBGrawWrite|