diff --git a/autoload/vebugger.vim b/autoload/vebugger.vim
index e1ec249..1cd80c1 100644
--- a/autoload/vebugger.vim
+++ b/autoload/vebugger.vim
@@ -1,199 +1,199 @@
 "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)
-	while 0<len(l:text)
-		let a:pipeObject.buffer.=l:text
-		let l:text=a:pipeObject.pipe.read(1000,0)
-	endwhile
+    "read
+    let l:text=a:pipeObject.pipe.read(1000,0)
+    while 0<len(l:text)
+        let a:pipeObject.buffer.=l:text
+        let l:text=a:pipeObject.pipe.read(1000,0)
+    endwhile
 
-	"parse
-	let l:lastNewline=strridx(a:pipeObject.buffer,"\n")
-	if 0<=l:lastNewline
-		let l:outLines=split(strpart(a:pipeObject.buffer,0,l:lastNewline),'\r\n\|\n\|\r')
-		let a:pipeObject.buffer=strpart(a:pipeObject.buffer,l:lastNewline+1)
-		return l:outLines
-	endif
+    "parse
+    let l:lastNewline=strridx(a:pipeObject.buffer,"\n")
+    if 0<=l:lastNewline
+        let l:outLines=split(strpart(a:pipeObject.buffer,0,l:lastNewline),'\r\n\|\n\|\r')
+        let a:pipeObject.buffer=strpart(a:pipeObject.buffer,l:lastNewline+1)
+        return l:outLines
+    endif
 
-	return []
+    return []
 endfunction
 
 let s:f_debugger={}
 
 "Terminate the debugger
 function! s:f_debugger.kill() dict
-	if self.shell.is_valid
-		call self.addLineToTerminal('','== DEBUGGER TERMINATED ==')
-	endif
-	let &updatetime=self.prevUpdateTime
-	call self.shell.kill(15)
-	if exists('s:debugger')
-		for l:closeHandler in s:debugger.closeHandlers
-			call l:closeHandler.handle(self)
-		endfor
-	endif
+    if self.shell.is_valid
+        call self.addLineToTerminal('','== DEBUGGER TERMINATED ==')
+    endif
+    let &updatetime=self.prevUpdateTime
+    call self.shell.kill(15)
+    if exists('s:debugger')
+        for l:closeHandler in s:debugger.closeHandlers
+            call l:closeHandler.handle(self)
+        endfor
+    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")
+    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)
-		let l:nl=s:readNewLinesFromPipe(self.pipes[l:k])
-		if 0<len(l:nl)
-			let l:newLines[l:k]=l:nl
-		endif
-	endfor
-	for l:k in keys(l:newLines)
-		for l:line in l:newLines[l:k]
-			call self.handleLine(l:k,l:line)
-		endfor
-	endfor
+    let l:newLines={}
+    for l:k in keys(self.pipes)
+        let l:nl=s:readNewLinesFromPipe(self.pipes[l:k])
+        if 0<len(l:nl)
+            let l:newLines[l:k]=l:nl
+        endif
+    endfor
+    for l:k in keys(l:newLines)
+        for l:line in l:newLines[l:k]
+            call self.handleLine(l:k,l:line)
+        endfor
+    endfor
 
-	let l:checkpid=self.shell.checkpid()
-	if 'exit'==l:checkpid[0]
-				\|| 'error'==l:checkpid[0]
-		call self.kill()
-	endif
-	call feedkeys("f\e") " Make sure the CursorHold event is refired even if the user does nothing
+    let l:checkpid=self.shell.checkpid()
+    if 'exit'==l:checkpid[0]
+                \|| 'error'==l:checkpid[0]
+        call self.kill()
+    endif
+    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)
+    call self.addLineToTerminal(a:pipeName,a:line)
 
-	let l:readResult=deepcopy(self.readResultTemplate,1)
+    let l:readResult=deepcopy(self.readResultTemplate,1)
 
-	for l:readHandler in self.readHandlers
-		call l:readHandler.handle(a:pipeName,a:line,l:readResult,self)
-	endfor
+    for l:readHandler in self.readHandlers
+        call l:readHandler.handle(a:pipeName,a:line,l:readResult,self)
+    endfor
 
-	for l:thinkHandler in self.thinkHandlers
-		call l:thinkHandler.handle(l:readResult,self)
-	endfor
+    for l:thinkHandler in self.thinkHandlers
+        call l:thinkHandler.handle(l:readResult,self)
+    endfor
 
-	call self.performWriteActions()
+    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)
-		if !empty(l:handlers)
-			for l:writeAction in items(self.writeActions[l:namespace])
-				if !empty(l:writeAction[1])
-					if has_key(l:handlers,l:writeAction[0])
-						call l:handlers[l:writeAction[0]].handle(l:writeAction[1],self)
-					endif
-				endif
-			endfor
-		endif
-	endfor
-	call self.generateWriteActionsFromTemplate()
+    for l:namespace in keys(self.writeActions)
+        let l:handlers=get(self.writeHandlers,l:namespace)
+        if !empty(l:handlers)
+            for l:writeAction in items(self.writeActions[l:namespace])
+                if !empty(l:writeAction[1])
+                    if has_key(l:handlers,l:writeAction[0])
+                        call l:handlers[l:writeAction[0]].handle(l:writeAction[1],self)
+                    endif
+                endif
+            endfor
+        endif
+    endfor
+    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)
-			return
-		endif
-	endif
-	new
-	setlocal buftype=nofile
-	setlocal bufhidden=wipe
-	let self.terminalBuffer=bufnr('')
-	silent file Vebugger:Ternimal
-	wincmd p
+    if has_key(self,'terminalBuffer')
+        if -1<bufwinnr(self.terminalBuffer)
+            return
+        endif
+    endif
+    new
+    setlocal buftype=nofile
+    setlocal bufhidden=wipe
+    let self.terminalBuffer=bufnr('')
+    silent file Vebugger:Ternimal
+    wincmd p
 endfunction
 
 "Close the terminal buffer
 function! s:f_debugger.closeTerminalBuffer() dict
-	if has_key(self,'terminalBuffer')
-		if -1<bufwinnr(self.terminalBuffer)
-			let l:bufwin=bufwinnr(self.terminalBuffer)
-			exe l:bufwin.'wincmd w'
-			wincmd c
-			wincmd p
-		endif
-	endif
+    if has_key(self,'terminalBuffer')
+        if -1<bufwinnr(self.terminalBuffer)
+            let l:bufwin=bufwinnr(self.terminalBuffer)
+            exe l:bufwin.'wincmd w'
+            wincmd c
+            wincmd p
+        endif
+    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)
-			return 1
-		endif
-	endif
-	return 0
+    if has_key(self,'terminalBuffer')
+        if -1<bufwinnr(self.terminalBuffer)
+            return 1
+        endif
+    endif
+    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()
-	else
-		call self.showTerminalBuffer()
-	endif
+    if self.isTerminalBufferOpen()
+        call self.closeTerminalBuffer()
+    else
+        call self.showTerminalBuffer()
+    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)
-		if -1<l:bufwin
-			exe l:bufwin.'wincmd w'
-			if has_key(self,'pipes')
-						\&&has_key(self.pipes,a:pipeName)
-						\&&has_key(self.pipes[a:pipeName],'annotation')
-				call append (line('$'),(self.pipes[a:pipeName].annotation).(a:line))
-			else
-				call append (line('$'),a:line)
-			endif
-			normal G
-			wincmd p
-		endif
-	endif
+    if has_key(self,'terminalBuffer')
+        let l:bufwin=bufwinnr(self.terminalBuffer)
+        if -1<l:bufwin
+            exe l:bufwin.'wincmd w'
+            if has_key(self,'pipes')
+                        \&&has_key(self.pipes,a:pipeName)
+                        \&&has_key(self.pipes[a:pipeName],'annotation')
+                call append (line('$'),(self.pipes[a:pipeName].annotation).(a:line))
+            else
+                call append (line('$'),a:line)
+            endif
+            normal G
+            wincmd p
+        endif
+    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)
-	elseif type(a:handler) == type(function('tr'))
-		call add(a:list,{'handle':a:handler})
-	endif
+    if type(a:handler) == type({})
+        call add(a:list,a:handler)
+    elseif type(a:handler) == type(function('tr'))
+        call add(a:list,{'handle':a: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]={}
-	endif
-	if type(a:handler) == type({})
-		let a:dict[a:namespace][a:name]=a:handler
-	elseif type(a:handler) == type(function('tr'))
-		let a:dict[a:namespace][a:name]={'handle':a:handler}
-	endif
+    if !has_key(a:dict,a:namespace)
+        let a:dict[a:namespace]={}
+    endif
+    if type(a:handler) == type({})
+        let a:dict[a:namespace][a:name]=a:handler
+    elseif type(a:handler) == type(function('tr'))
+        let a:dict[a:namespace][a:name]={'handle':a: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)
+    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)
+    call s:addHandler(self.thinkHandlers,a:handler)
 endfunction
 
 "Set a write handler. Write handlers get write action objects and convert them
@@ -201,147 +201,129 @@ endfunction
 "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)
+    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)
+    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)
+    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
+    let self.writeActions[a:namespace][a:name]=a:value
+endfunction
+
+"Set a write action and perform it
+function! s:f_debugger.setWriteActionAndPerform(namespace, name, value) dict
+    call self.setWriteAction(a:namespace, a:name, a:value)
+    call self.performWriteActions()
 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)
+    call add(self.writeActions[a:namespace][a:name],a:value)
+endfunction
+
+"Add a write action and perform it
+function! s:f_debugger.addWriteActionAndPerform(namespace, name, value) dict
+    call self.addWriteAction(a:namespace, a:name, a:value)
+    call self.performWriteActions()
 endfunction
 
 "Create a bare debugger object from a raw shell line
 function! vebugger#createDebugger(command)
 
-	let l:debugger=deepcopy(s:f_debugger)
+    let l:debugger=deepcopy(s:f_debugger)
 
-	let l:debugger.shell=vimproc#ptyopen(a:command,3)
+    let l:debugger.shell=vimproc#ptyopen(a:command,3)
 
-	let l:debugger.outBuffer=''
-	let l:debugger.errBuffer=''
+    let l:debugger.outBuffer=''
+    let l:debugger.errBuffer=''
 
-	let l:debugger.pipes={
-				\'out':{'pipe':(l:debugger.shell.stdout),'buffer':''},
-				\'err':{'pipe':(l:debugger.shell.stderr),'buffer':'','annotation':"err:\t\t"}}
+    let l:debugger.pipes={
+                \'out':{'pipe':(l:debugger.shell.stdout),'buffer':''},
+                \'err':{'pipe':(l:debugger.shell.stderr),'buffer':'','annotation':"err:\t\t"}}
 
-	let l:debugger.readResultTemplate={}
-	let l:debugger.state={}
-	let l:debugger.writeActionsTemplate={}
+    let l:debugger.readResultTemplate={}
+    let l:debugger.state={}
+    let l:debugger.writeActionsTemplate={}
 
-	let l:debugger.readHandlers=[]
-	let l:debugger.thinkHandlers=[]
-	let l:debugger.writeHandlers={}
-	let l:debugger.closeHandlers=[]
+    let l:debugger.readHandlers=[]
+    let l:debugger.thinkHandlers=[]
+    let l:debugger.writeHandlers={}
+    let l:debugger.closeHandlers=[]
 
-	let l:debugger.prevUpdateTime=&updatetime
+    let l:debugger.prevUpdateTime=&updatetime
 
-	set updatetime=500
-	return l:debugger
+    set updatetime=500
+    return l:debugger
 endfunction
 
 
 "Create a debugger and set it as the currently active debugger
 function! vebugger#startDebugger(command)
-	call vebugger#killDebugger()
+    call vebugger#killDebugger()
 
-	let s:debugger=vebugger#createDebugger(a:command)
+    let s:debugger=vebugger#createDebugger(a:command)
 
-	augroup vebugger_shell
-		autocmd!
-		autocmd CursorHold * call s:debugger.invokeReading()
-	augroup END
+    augroup vebugger_shell
+        autocmd!
+        autocmd CursorHold * call s:debugger.invokeReading()
+    augroup END
 
-	return s:debugger
+    return s:debugger
 endfunction
 
 "Terminate the currently active debugger
 function! vebugger#killDebugger()
-	augroup vebugger_shell
-		autocmd!
-	augroup END
-	if exists('s:debugger')
-		call s:debugger.closeTerminalBuffer()
-		call s:debugger.kill()
-		unlet s:debugger
-	endif
+    augroup vebugger_shell
+        autocmd!
+    augroup END
+    if exists('s:debugger')
+        call s:debugger.closeTerminalBuffer()
+        call s:debugger.kill()
+        unlet s:debugger
+    endif
+endfunction
+
+function! vebugger#userAction(action, ...)
+    if exists('s:debugger')
+        if has_key(s:debugger, a:action)
+            call call(s:debugger[a:action], a:000, s:debugger)
+        else
+            throw 'Current debugger does not support action '.a:action
+        endif
+    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
+    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
+    if exists('s:debugger')
+        call s:debugger.invokeReading()
+    endif
 endfunction
 
 "Fetch the currently active debugger object
 function! vebugger#getActiveDebugger()
-	if exists('s:debugger')
-		return s:debugger
-	else
-		return {}
-	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()
+    if exists('s:debugger')
+        return s:debugger
+    else
+        return {}
+    endif
 endfunction
diff --git a/autoload/vebugger/std.vim b/autoload/vebugger/std.vim
index f5e171d..d3e7364 100644
--- a/autoload/vebugger/std.vim
+++ b/autoload/vebugger/std.vim
@@ -2,74 +2,74 @@ let g:vebugger_breakpoints=[]
 
 "Initialize the std part of the debugger's state
 function! vebugger#std#setStandardState(debugger)
-	let a:debugger.state.std={
-				\'config':{
-				\	'externalFileStop_flowCommand':''},
-				\'location':{},
-				\'callstack':[],
-				\'evaluateExpressions':[]}
+    let a:debugger.state.std={
+                \'config':{
+                \   'externalFileStop_flowCommand':''},
+                \'location':{},
+                \'callstack':[],
+                \'evaluateExpressions':[]}
 endfunction
 
 "Initialize the std part of the debugger's read result template
 function! vebugger#std#setStandardReadResultTemplate(debugger)
-	let a:debugger.readResultTemplate.std={
-				\'programOutput':{},
-				\'location':{},
-				\'callstack':{},
-				\'evaluatedExpression':{},
-				\'programFinish':{},
-				\'exception':{}}
+    let a:debugger.readResultTemplate.std={
+                \'programOutput':{},
+                \'location':{},
+                \'callstack':{},
+                \'evaluatedExpression':{},
+                \'programFinish':{},
+                \'exception':{}}
 endfunction
 
 "Initialize the std part of the debugger's write actions template
 function! vebugger#std#setStandardWriteactionsTemplate(debugger)
-	let a:debugger.writeActionsTemplate.std={
-				\'flow':'',
-				\'breakpoints':[],
-				\'evaluateExpressions':[],
-				\'executeStatements':[],
-				\'removeAfterDisplayed':[],
-				\'closeDebugger':''}
+    let a:debugger.writeActionsTemplate.std={
+                \'flow':'',
+                \'breakpoints':[],
+                \'evaluateExpressions':[],
+                \'executeStatements':[],
+                \'removeAfterDisplayed':[],
+                \'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
+    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
+    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
+    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)
-	call vebugger#std#setStandardWriteactionsTemplate(a:debugger)
-	call vebugger#std#addStandardFunctions(a:debugger)
-	call vebugger#std#addStandardThinkHandlers(a:debugger)
-	call vebugger#std#addStandardCloseHandlers(a:debugger)
+    call vebugger#std#setStandardState(a:debugger)
+    call vebugger#std#setStandardReadResultTemplate(a:debugger)
+    call vebugger#std#setStandardWriteactionsTemplate(a:debugger)
+    call vebugger#std#addStandardFunctions(a:debugger)
+    call vebugger#std#addStandardThinkHandlers(a: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)
+    let l:debugger=vebugger#startDebugger(a:command)
 
-	call vebugger#std#standardInit(l:debugger)
+    call vebugger#std#standardInit(l:debugger)
 
-	return l:debugger
+    return l:debugger
 endfunction
 
 
@@ -78,69 +78,69 @@ endfunction
 "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)
-			return
-		endif
-	endif
-	let l:oldBuffer=bufnr('Vebugger:Shell')
-	if -1<l:oldBuffer
-		let a:debugger.shellBuffer=l:oldBuffer
-		call a:debugger.std_addLineToShellBuffer('')
-		call a:debugger.std_addLineToShellBuffer('==================')
-		call a:debugger.std_addLineToShellBuffer('')
-		return
-	endif
-	8 new
-	let b:debugger=a:debugger
-	autocmd BufDelete <buffer> if exists('b:debugger') | call b:debugger.kill() | endif
-	setlocal buftype=nofile
-	setlocal bufhidden=wipe
-	let a:debugger.shellBuffer=bufnr('')
-	silent file Vebugger:Shell
-	wincmd p
+    if has_key(a:debugger,'shellBuffer')
+        if -1<bufwinnr(a:debugger.shellBuffer)
+            return
+        endif
+    endif
+    let l:oldBuffer=bufnr('Vebugger:Shell')
+    if -1<l:oldBuffer
+        let a:debugger.shellBuffer=l:oldBuffer
+        call a:debugger.std_addLineToShellBuffer('')
+        call a:debugger.std_addLineToShellBuffer('==================')
+        call a:debugger.std_addLineToShellBuffer('')
+        return
+    endif
+    8 new
+    let b:debugger=a:debugger
+    autocmd BufDelete <buffer> if exists('b:debugger') | call b:debugger.kill() | endif
+    setlocal buftype=nofile
+    setlocal bufhidden=wipe
+    let a:debugger.shellBuffer=bufnr('')
+    silent file Vebugger:Shell
+    wincmd p
 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)
-		if -1<l:bufwin
-			exe l:bufwin.'wincmd w'
-			call append (line('$'),a:line)
-			normal G
-			wincmd p
-		endif
-	endif
+    if has_key(self,'shellBuffer')
+        let l:bufwin=bufwinnr(self.shellBuffer)
+        if -1<l:bufwin
+            exe l:bufwin.'wincmd w'
+            call append (line('$'),a:line)
+            normal G
+            wincmd p
+        endif
+    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',{
-					\'action':'add',
-					\'file':(l:breakpoint.file),
-					\'line':(l:breakpoint.line)})
-	endfor
+    for l:breakpoint in a:breakpoints
+        call self.addWriteAction('std','breakpoints',{
+                    \'action':'add',
+                    \'file':(l:breakpoint.file),
+                    \'line':(l:breakpoint.line)})
+    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)
-	endif
-	call self.addWriteAction('std','evaluateExpressions',{
-				\'expression':(a:expression)})
-	call self.performWriteActions()
+    if -1==index(self.state.std.evaluateExpressions,a:expression)
+        call add(self.state.std.evaluateExpressions,a:expression)
+    endif
+    call self.addWriteAction('std','evaluateExpressions',{
+                \'expression':(a:expression)})
+    call self.performWriteActions()
 endfunction
 
 "Execute a statement in the debugged program
 function! s:standardFunctions.execute(statement) dict
-	call self.addWriteAction('std','executeStatements',{
-				\'statement':(a:statement)})
-	call self.performWriteActions()
+    call self.addWriteAction('std','executeStatements',{
+                \'statement':(a:statement)})
+    call self.performWriteActions()
 endfunction
 
 
@@ -148,91 +148,91 @@ 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)
-		call a:debugger.std_addLineToShellBuffer(l:programOutput.line)
-	endif
+    let l:programOutput=a:readResult.std.programOutput
+    if !empty(l:programOutput)
+        call a:debugger.std_addLineToShellBuffer(l:programOutput.line)
+    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?
-			if 0!=stridx(tolower(fnamemodify(a:readResult.std.location.file,':p')),tolower(getcwd()))
-				call a:debugger.setWriteAction('std','flow',a:debugger.state.std.config.externalFileStop_flowCommand)
-				return
-			endif
-		endif
-		if a:debugger.state.std.location!=a:readResult.std.location
-			if has_key(a:debugger.state.std.location,'file')
-				exe 'sign unplace 1 file='.fnameescape(fnamemodify(a:debugger.state.std.location.file,':p'))
-			endif
-			let a:debugger.state.std.location=deepcopy(a:readResult.std.location)
-			if !bufexists(a:readResult.std.location.file)
-				exe get(g:, 'vebugger_view_source_cmd', 'new').' '.(a:readResult.std.location.file)
-			endif
-			call vebugger#std#updateMarksForFile(a:debugger.state,a:readResult.std.location.file)
-			exe 'sign jump 1 file='.fnameescape(fnamemodify(a:readResult.std.location.file,':p'))
-		endif
-	endif
+    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?
+            if 0!=stridx(tolower(fnamemodify(a:readResult.std.location.file,':p')),tolower(getcwd()))
+                call a:debugger.setWriteAction('std','flow',a:debugger.state.std.config.externalFileStop_flowCommand)
+                return
+            endif
+        endif
+        if a:debugger.state.std.location!=a:readResult.std.location
+            if has_key(a:debugger.state.std.location,'file')
+                exe 'sign unplace 1 file='.fnameescape(fnamemodify(a:debugger.state.std.location.file,':p'))
+            endif
+            let a:debugger.state.std.location=deepcopy(a:readResult.std.location)
+            if !bufexists(a:readResult.std.location.file)
+                exe get(g:, 'vebugger_view_source_cmd', 'new').' '.(a:readResult.std.location.file)
+            endif
+            call vebugger#std#updateMarksForFile(a:debugger.state,a:readResult.std.location.file)
+            exe 'sign jump 1 file='.fnameescape(fnamemodify(a:readResult.std.location.file,':p'))
+        endif
+    endif
 endfunction
 
 "Update the call stack
 function! s:standardThinkHandlers.updateCallStack(readResult,debugger) dict
-	let l:callstack=a:readResult.std.callstack
-	if !empty(l:callstack)
-		if get(l:callstack,'clearOld')
-			let a:debugger.state.std.callstack=[]
-		endif
-		let l:frame={'file':(l:callstack.file),'line':(l:callstack.line)}
-		if 'after'==get(l:callstack,'add')
-			call add(a:debugger.state.std.callstack,l:frame)
-		elseif 'before'==get(l:callstack,'add')
-			call insert(a:debugger.state.std.callstack,l:frame)
-		endif
-	endif
+    let l:callstack=a:readResult.std.callstack
+    if !empty(l:callstack)
+        if get(l:callstack,'clearOld')
+            let a:debugger.state.std.callstack=[]
+        endif
+        let l:frame={'file':(l:callstack.file),'line':(l:callstack.line)}
+        if 'after'==get(l:callstack,'add')
+            call add(a:debugger.state.std.callstack,l:frame)
+        elseif 'before'==get(l:callstack,'add')
+            call insert(a:debugger.state.std.callstack,l:frame)
+        endif
+    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)
-		if empty(get(l:evaluatedExpression,'expression'))
-			echo l:evaluatedExpression.value."\n"
-		else
-			let l:index=index(a:debugger.state.std.evaluateExpressions,l:evaluatedExpression.expression)
-			if 0<=l:index
-				call remove(a:debugger.state.std.evaluateExpressions,l:index)
-				echo l:evaluatedExpression.expression.': '.l:evaluatedExpression.value."\n"
-				let g:echo=l:evaluatedExpression.expression.': '.l:evaluatedExpression.value."\n"
-			endif
-		endif
-		call a:debugger.addWriteAction('std','removeAfterDisplayed',a:readResult)
-	endif
+    let l:evaluatedExpression=a:readResult.std.evaluatedExpression
+    if !empty(l:evaluatedExpression)
+        if empty(get(l:evaluatedExpression,'expression'))
+            echo l:evaluatedExpression.value."\n"
+        else
+            let l:index=index(a:debugger.state.std.evaluateExpressions,l:evaluatedExpression.expression)
+            if 0<=l:index
+                call remove(a:debugger.state.std.evaluateExpressions,l:index)
+                echo l:evaluatedExpression.expression.': '.l:evaluatedExpression.value."\n"
+                let g:echo=l:evaluatedExpression.expression.': '.l:evaluatedExpression.value."\n"
+            endif
+        endif
+        call a:debugger.addWriteAction('std','removeAfterDisplayed',a:readResult)
+    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
+    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
-		echo a:readResult.std.exception.message."\n"
-		echohl None
-	endif
+    if !empty(a:readResult.std.exception)
+        echohl WarningMsg
+        echo a:readResult.std.exception.message."\n"
+        echohl None
+    endif
 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
+    let a:debugger.state.std.location={}
+    sign unplace 1
 endfunction
 
 sign define vebugger_current text=->
@@ -240,83 +240,75 @@ 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)
-		exe 'sign unplace 1 file='.fnameescape(fnamemodify(l:filename,':p'))
-		exe 'sign unplace 2 file='.fnameescape(fnamemodify(l:filename,':p'))
+    let l:filename=fnamemodify(a:filename,":p")
+    if bufexists(l:filename)
+        exe 'sign unplace 1 file='.fnameescape(fnamemodify(l:filename,':p'))
+        exe 'sign unplace 2 file='.fnameescape(fnamemodify(l:filename,':p'))
 
-		for l:breakpoint in g:vebugger_breakpoints
-			if fnamemodify(l:breakpoint.file,':p')==fnamemodify(a:filename,':p')
-				exe 'sign place 2 name=vebugger_breakpoint line='.l:breakpoint.line.' file='.fnameescape(fnamemodify(l:breakpoint.file,':p'))
-			endif
-		endfor
+        for l:breakpoint in g:vebugger_breakpoints
+            if fnamemodify(l:breakpoint.file,':p')==fnamemodify(a:filename,':p')
+                exe 'sign place 2 name=vebugger_breakpoint line='.l:breakpoint.line.' file='.fnameescape(fnamemodify(l:breakpoint.file,':p'))
+            endif
+        endfor
 
-		if !empty(a:state)
-			if !empty(a:state.std.location)
-				if fnamemodify(a:state.std.location.file,':p')==fnamemodify(a:filename,':p')
-					exe 'sign place 1 name=vebugger_current line='.a:state.std.location.line.' file='.fnameescape(fnamemodify(l:filename,':p'))
-				endif
-			endif
-		endif
-	endif
+        if !empty(a:state)
+            if !empty(a:state.std.location)
+                if fnamemodify(a:state.std.location.file,':p')==fnamemodify(a:filename,':p')
+                    exe 'sign place 1 name=vebugger_current line='.a:state.std.location.line.' file='.fnameescape(fnamemodify(l:filename,':p'))
+                endif
+            endif
+        endif
+    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)
-				\? {}
-				\: l:debugger.state
-	for l:i in range(len(g:vebugger_breakpoints))
-		let l:breakpoint=g:vebugger_breakpoints[l:i]
-		if l:breakpoint.file==a:file && l:breakpoint.line==a:line
-			call remove(g:vebugger_breakpoints,l:i)
-			call vebugger#addWriteActionAndPerform('std','breakpoints',{
-						\'action':'remove',
-						\'file':(a:file),
-						\'line':(a:line)})
-			call vebugger#std#updateMarksForFile(l:debuggerState,a:file)
-			return
-		endif
-	endfor
-	call add(g:vebugger_breakpoints,{'file':(a:file),'line':(a:line)})
-	call vebugger#addWriteActionAndPerform('std','breakpoints',{
-				\'action':'add',
-				\'file':(a:file),
-				\'line':(a:line)})
-	call vebugger#std#updateMarksForFile(l:debuggerState,a:file)
+    let l:debugger=vebugger#getActiveDebugger()
+    let l:debuggerState=empty(l:debugger)
+                \? {}
+                \: l:debugger.state
+    for l:i in range(len(g:vebugger_breakpoints))
+        let l:breakpoint=g:vebugger_breakpoints[l:i]
+        if l:breakpoint.file==a:file && l:breakpoint.line==a:line
+            call remove(g:vebugger_breakpoints,l:i)
+            if !empty(l:debugger)
+                call l:debugger.addWriteActionAndPerform('std','breakpoints',{
+                            \'action':'remove',
+                            \'file':(a:file),
+                            \'line':(a:line)})
+            endif
+            call vebugger#std#updateMarksForFile(l:debuggerState,a:file)
+            return
+        endif
+    endfor
+    call add(g:vebugger_breakpoints,{'file':(a:file),'line':(a:line)})
+    if !empty(l:debugger)
+        call l:debugger.addWriteActionAndPerform('std','breakpoints',{
+                    \'action':'add',
+                    \'file':(a:file),
+                    \'line':(a:line)})
+    endif
+    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
-	let l:files=[]
-	for l:breakpoint in g:vebugger_breakpoints
-		if index(l:files,l:breakpoint.file)<0
-			call add(l:files,l:breakpoint.file)
-		endif
-		call vebugger#addWriteAction('std','breakpoints',extend({'action':'remove'},l:breakpoint))
-	endfor
-	call vebugger#performWriteActions()
-	let g:vebugger_breakpoints=[]
-	for l:file in l:files
-		call vebugger#std#updateMarksForFile(l:debuggerState,l:file)
-	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)
-		call l:debugger.std_eval(a: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)
-		call l:debugger.std_execute(a:statement)
-	endif
+    let l:debugger=vebugger#getActiveDebugger()
+    let l:debuggerState=empty(l:debugger) ? {} : l:debugger.state
+    let l:files=[]
+    for l:breakpoint in g:vebugger_breakpoints
+        if index(l:files,l:breakpoint.file)<0
+            call add(l:files,l:breakpoint.file)
+        endif
+        if !empty(l:debugger)
+            call l:debugger.addWriteAction('std','breakpoints',extend({'action':'remove'},l:breakpoint))
+        endif
+    endfor
+    if !empty(l:debugger)
+        call l:debugger.performWriteActions()
+    endif
+    let g:vebugger_breakpoints=[]
+    for l:file in l:files
+        call vebugger#std#updateMarksForFile(l:debuggerState,l:file)
+    endfor
 endfunction
diff --git a/plugin/vebugger.vim b/plugin/vebugger.vim
index 6f9449d..b78bcb5 100644
--- a/plugin/vebugger.vim
+++ b/plugin/vebugger.vim
@@ -1,25 +1,25 @@
 
 
-command! -nargs=1 VBGrawWrite call vebugger#writeLine(<q-args>)
+command! -nargs=1 VBGrawWrite call vebugger#userAction('writeLine', <q-args>)
 command! -nargs=0 VBGkill call vebugger#killDebugger()
 
-command! -nargs=0 VBGstepIn call vebugger#setWriteActionAndPerform('std','flow','stepin')
-command! -nargs=0 VBGstepOver call vebugger#setWriteActionAndPerform('std','flow','stepover')
-command! -nargs=0 VBGstepOut call vebugger#setWriteActionAndPerform('std','flow','stepout')
-command! -nargs=0 VBGcontinue call vebugger#setWriteActionAndPerform('std','flow','continue')
+command! -nargs=0 VBGstepIn call vebugger#userAction('setWriteActionAndPerform', 'std', 'flow', 'stepin')
+command! -nargs=0 VBGstepOver call vebugger#userAction('setWriteActionAndPerform', 'std', 'flow', 'stepover')
+command! -nargs=0 VBGstepOut call vebugger#userAction('setWriteActionAndPerform', 'std', 'flow', 'stepout')
+command! -nargs=0 VBGcontinue call vebugger#userAction('setWriteActionAndPerform', 'std', 'flow', 'continue')
 
-command! -nargs=0 VBGtoggleTerminalBuffer call vebugger#toggleTerminalBuffer()
+command! -nargs=0 VBGtoggleTerminalBuffer call vebugger#userAction('toggleTerminalBuffer')
 command! -nargs=+ -complete=file VBGtoggleBreakpoint call vebugger#std#toggleBreakpoint(<f-args>)
 command! -nargs=0 VBGtoggleBreakpointThisLine call vebugger#std#toggleBreakpoint(expand('%:~:.'),line('.'))
 command! -nargs=0 VBGclearBreakpints call vebugger#std#clearBreakpoints()
 
-command! -nargs=1 VBGeval call vebugger#std#eval(<q-args>)
-command! -nargs=0 VBGevalWordUnderCursor call vebugger#std#eval(expand('<cword>'))
-command! -nargs=1 VBGexecute call vebugger#std#execute(<q-args>)
+command! -nargs=1 VBGeval call vebugger#userAction('std_eval', <q-args>)
+command! -nargs=0 VBGevalWordUnderCursor call vebugger#userAction('std_eval', expand('<cword>'))
+command! -nargs=1 VBGexecute call vebugger#userAction('std_execute', <q-args>)
 
-command! -range -nargs=0 VBGevalSelectedText call vebugger#std#eval(vebugger#util#get_visual_selection())
-command! -range -nargs=0 VBGexecuteSelectedText call vebugger#std#execute(vebugger#util#get_visual_selection())
-command! -range -nargs=0 VBGrawWriteSelectedText call vebugger#writeLine(vebugger#util#get_visual_selection())
+command! -range -nargs=0 VBGevalSelectedText call vebugger#userAction('std_eval', vebugger#util#get_visual_selection())
+command! -range -nargs=0 VBGexecuteSelectedText call vebugger#userAction('std_execute', vebugger#util#get_visual_selection())
+command! -range -nargs=0 VBGrawWriteSelectedText call vebugger#userAction('writeLine', vebugger#util#get_visual_selection())
 
 command! -nargs=+ -complete=file VBGstartGDB call vebugger#gdb#start([<f-args>][0],{'args':[<f-args>][1:]})
 function! s:attachGDB(...)