From 7335fe40dabb28ef5c4c95a0ebbcfda34ddd0ea7 Mon Sep 17 00:00:00 2001
From: 7AV <7AV@users.noreply.github.com>
Date: Sun, 16 Apr 2017 15:34:18 -0700
Subject: [PATCH] Decrypted WINDOWS warez

the ORIGINAL files for Equation Group's DANDERSPRITZ, FUZZBUNCH and NSA
0day exploits found in Shadow Broker's [Lost In Translation] archive.
---
 windows/fuzzbunch/__init__.py                 |    6 +
 windows/fuzzbunch/coli.py                     |  264 ++
 windows/fuzzbunch/command.py                  |  555 +++++
 windows/fuzzbunch/context.py                  |   75 +
 windows/fuzzbunch/daveplugin.py               |  528 ++++
 windows/fuzzbunch/deployablemanager.py        |  157 ++
 windows/fuzzbunch/edfexecution.py             |  268 ++
 windows/fuzzbunch/edfmeta.py                  |  276 +++
 windows/fuzzbunch/edfplugin.py                |  360 +++
 windows/fuzzbunch/env.py                      |   59 +
 windows/fuzzbunch/exception.py                |   82 +
 windows/fuzzbunch/exma.py                     |   74 +
 windows/fuzzbunch/figlet.py                   |  250 ++
 windows/fuzzbunch/fuzzbunch.py                |  995 ++++++++
 windows/fuzzbunch/iohandler.py                |  860 +++++++
 windows/fuzzbunch/log.py                      |  369 +++
 windows/fuzzbunch/plugin.py                   |  450 ++++
 windows/fuzzbunch/pluginfinder.py             |   93 +
 windows/fuzzbunch/pluginmanager.py            |  743 ++++++
 windows/fuzzbunch/pyreadline/__init__.py      |   31 +
 .../pyreadline/clipboard/__init__.py          |   73 +
 .../clipboard/ironpython_clipboard.py         |   28 +
 .../pyreadline/clipboard/win32_clipboard.py   |  105 +
 .../configuration/pyreadlineconfig.ini        |   85 +
 .../pyreadline/configuration/startup.py       |   16 +
 .../fuzzbunch/pyreadline/console/__init__.py  |   21 +
 windows/fuzzbunch/pyreadline/console/ansi.py  |  181 ++
 .../fuzzbunch/pyreadline/console/console.py   |  758 ++++++
 .../pyreadline/console/console_attributes.py  |   16 +
 .../pyreadline/console/consolebase.py         |   52 +
 windows/fuzzbunch/pyreadline/console/event.py |   25 +
 .../pyreadline/console/ironpython_console.py  |  428 ++++
 windows/fuzzbunch/pyreadline/error.py         |   14 +
 windows/fuzzbunch/pyreadline/get_doc.py       |   18 +
 .../fuzzbunch/pyreadline/keysyms/__init__.py  |   20 +
 .../fuzzbunch/pyreadline/keysyms/common.py    |  118 +
 .../pyreadline/keysyms/ironpython_keysyms.py  |  206 ++
 .../fuzzbunch/pyreadline/keysyms/keysyms.py   |  130 +
 .../pyreadline/keysyms/winconstants.py        |  171 ++
 .../pyreadline/lineeditor/__init__.py         |    0
 .../pyreadline/lineeditor/history.py          |  245 ++
 .../pyreadline/lineeditor/lineobj.py          |  790 ++++++
 .../pyreadline/lineeditor/wordmatcher.py      |  103 +
 windows/fuzzbunch/pyreadline/logger.py        |   45 +
 windows/fuzzbunch/pyreadline/logserver.py     |   60 +
 .../fuzzbunch/pyreadline/modes/__init__.py    |    5 +
 .../fuzzbunch/pyreadline/modes/basemode.py    |  457 ++++
 windows/fuzzbunch/pyreadline/modes/emacs.py   |  626 +++++
 .../fuzzbunch/pyreadline/modes/fuzzbunch.py   |   54 +
 .../fuzzbunch/pyreadline/modes/notemacs.py    |  601 +++++
 windows/fuzzbunch/pyreadline/modes/vi.py      | 1219 ++++++++++
 windows/fuzzbunch/pyreadline/release.py       |   74 +
 windows/fuzzbunch/pyreadline/rlmain.py        |  460 ++++
 windows/fuzzbunch/pyreadline/test/common.py   |   78 +
 .../fuzzbunch/pyreadline/test/emacs_test.py   |  396 +++
 .../pyreadline/test/lineeditor_test.py        |  390 +++
 windows/fuzzbunch/pyreadline/test/vi_test.py  | 2146 +++++++++++++++++
 windows/fuzzbunch/redirection.py              |  510 ++++
 windows/fuzzbunch/session.py                  |  316 +++
 windows/fuzzbunch/truantchild.py              |  962 ++++++++
 windows/fuzzbunch/util.py                     |  285 +++
 61 files changed, 18782 insertions(+)
 create mode 100644 windows/fuzzbunch/__init__.py
 create mode 100644 windows/fuzzbunch/coli.py
 create mode 100644 windows/fuzzbunch/command.py
 create mode 100644 windows/fuzzbunch/context.py
 create mode 100644 windows/fuzzbunch/daveplugin.py
 create mode 100644 windows/fuzzbunch/deployablemanager.py
 create mode 100644 windows/fuzzbunch/edfexecution.py
 create mode 100644 windows/fuzzbunch/edfmeta.py
 create mode 100644 windows/fuzzbunch/edfplugin.py
 create mode 100644 windows/fuzzbunch/env.py
 create mode 100644 windows/fuzzbunch/exception.py
 create mode 100644 windows/fuzzbunch/exma.py
 create mode 100644 windows/fuzzbunch/figlet.py
 create mode 100644 windows/fuzzbunch/fuzzbunch.py
 create mode 100644 windows/fuzzbunch/iohandler.py
 create mode 100644 windows/fuzzbunch/log.py
 create mode 100644 windows/fuzzbunch/plugin.py
 create mode 100644 windows/fuzzbunch/pluginfinder.py
 create mode 100644 windows/fuzzbunch/pluginmanager.py
 create mode 100644 windows/fuzzbunch/pyreadline/__init__.py
 create mode 100644 windows/fuzzbunch/pyreadline/clipboard/__init__.py
 create mode 100644 windows/fuzzbunch/pyreadline/clipboard/ironpython_clipboard.py
 create mode 100644 windows/fuzzbunch/pyreadline/clipboard/win32_clipboard.py
 create mode 100644 windows/fuzzbunch/pyreadline/configuration/pyreadlineconfig.ini
 create mode 100644 windows/fuzzbunch/pyreadline/configuration/startup.py
 create mode 100644 windows/fuzzbunch/pyreadline/console/__init__.py
 create mode 100644 windows/fuzzbunch/pyreadline/console/ansi.py
 create mode 100644 windows/fuzzbunch/pyreadline/console/console.py
 create mode 100644 windows/fuzzbunch/pyreadline/console/console_attributes.py
 create mode 100644 windows/fuzzbunch/pyreadline/console/consolebase.py
 create mode 100644 windows/fuzzbunch/pyreadline/console/event.py
 create mode 100644 windows/fuzzbunch/pyreadline/console/ironpython_console.py
 create mode 100644 windows/fuzzbunch/pyreadline/error.py
 create mode 100644 windows/fuzzbunch/pyreadline/get_doc.py
 create mode 100644 windows/fuzzbunch/pyreadline/keysyms/__init__.py
 create mode 100644 windows/fuzzbunch/pyreadline/keysyms/common.py
 create mode 100644 windows/fuzzbunch/pyreadline/keysyms/ironpython_keysyms.py
 create mode 100644 windows/fuzzbunch/pyreadline/keysyms/keysyms.py
 create mode 100644 windows/fuzzbunch/pyreadline/keysyms/winconstants.py
 create mode 100644 windows/fuzzbunch/pyreadline/lineeditor/__init__.py
 create mode 100644 windows/fuzzbunch/pyreadline/lineeditor/history.py
 create mode 100644 windows/fuzzbunch/pyreadline/lineeditor/lineobj.py
 create mode 100644 windows/fuzzbunch/pyreadline/lineeditor/wordmatcher.py
 create mode 100644 windows/fuzzbunch/pyreadline/logger.py
 create mode 100644 windows/fuzzbunch/pyreadline/logserver.py
 create mode 100644 windows/fuzzbunch/pyreadline/modes/__init__.py
 create mode 100644 windows/fuzzbunch/pyreadline/modes/basemode.py
 create mode 100644 windows/fuzzbunch/pyreadline/modes/emacs.py
 create mode 100644 windows/fuzzbunch/pyreadline/modes/fuzzbunch.py
 create mode 100644 windows/fuzzbunch/pyreadline/modes/notemacs.py
 create mode 100644 windows/fuzzbunch/pyreadline/modes/vi.py
 create mode 100644 windows/fuzzbunch/pyreadline/release.py
 create mode 100644 windows/fuzzbunch/pyreadline/rlmain.py
 create mode 100644 windows/fuzzbunch/pyreadline/test/common.py
 create mode 100644 windows/fuzzbunch/pyreadline/test/emacs_test.py
 create mode 100644 windows/fuzzbunch/pyreadline/test/lineeditor_test.py
 create mode 100644 windows/fuzzbunch/pyreadline/test/vi_test.py
 create mode 100644 windows/fuzzbunch/redirection.py
 create mode 100644 windows/fuzzbunch/session.py
 create mode 100644 windows/fuzzbunch/truantchild.py
 create mode 100644 windows/fuzzbunch/util.py

diff --git a/windows/fuzzbunch/__init__.py b/windows/fuzzbunch/__init__.py
new file mode 100644
index 0000000..308ba92
--- /dev/null
+++ b/windows/fuzzbunch/__init__.py
@@ -0,0 +1,6 @@
+
+__all__ = ['command' 'edeconfig', 'edeplugin', 'edfexecution',
+           'edfmeta', 'edfplugin', 'exception', 'exma', 'figlet',
+           'fuzzbunch', 'iohandler', 'plugin', 'pluginmanager',
+           'redirection', 'session', 'trch', 'truantchild', 'util',
+           'env']
diff --git a/windows/fuzzbunch/coli.py b/windows/fuzzbunch/coli.py
new file mode 100644
index 0000000..84fde5a
--- /dev/null
+++ b/windows/fuzzbunch/coli.py
@@ -0,0 +1,264 @@
+import sys
+import truantchild
+import exma
+from optparse import OptionParser
+import logging
+import ctypes
+
+EDF_CLEANUP_WAIT = 0
+
+#
+# @todo coli needs a logger that will duplicate output to stdout and the file
+#
+
+# ID - sha1 of Name-Maj.Min.Rev of the version number.  See EDF/noarch/EDF-CMake/generatePluginID.py
+class ExploitConfigError(ValueError):
+    pass
+
+def get_logger(logfile):
+    # configure the root logger
+    logger = logging.getLogger()
+    logger.setLevel(logging.DEBUG)
+    
+    if logfile is not None:
+        fh = logging.FileHandler(logfile, mode="w")
+        fh.setLevel(logging.DEBUG)
+        fhFormatter = logging.Formatter('[%(levelname)-8s] %(filename)-18s (line %(lineno)-4s) -- %(message)s')
+        fh.setFormatter(fhFormatter)
+        logger.addHandler(fh) 
+    
+    ch = logging.StreamHandler()
+    ch.setLevel(logging.INFO)
+    chFormatter = logging.Formatter("%(message)s")
+    ch.setFormatter(chFormatter)
+    logger.addHandler(ch)
+    return logger
+    
+    
+class CommandlineWrapper(object):
+    def __init__(self):
+        # This takes care of addWrapperInputs
+        self.__coli_parser = OptionParser()
+        self.__coli_parser.add_option("--InConfig",        dest="InConfig", help="The Input XML file" )
+        self.__coli_parser.add_option("--OutConfig",       dest="OutConfig", default=sys.stdout, 
+                                      help="Output XML file")
+        self.__coli_parser.add_option("--LogFile",         dest="LogFile",   default=None,       
+                                      help="Truantchild log file")
+        self.__coli_parser.add_option("--ValidateOnly",    dest="ValidateOnly", default=False, action="store_true", 
+                                      help="Valid params")
+        
+    def __hack_params_parseCommandLine(self, params, args, doHelp):
+        params = ctypes.pointer(params)
+        cArgs = len(args)
+        args = ctypes.pointer(args)
+        doHelp = ctypes.c_uint()
+        pass
+
+    def __call__(self, argv):
+        """Effectively "main" from Commandlinewrapper"""
+        logConfig = None
+        context = {}
+        rendezvous = None
+        try:
+            (opts, args) = self.__coli_parser.parse_args(argv)
+            if opts.InConfig is None:
+                raise ExploitConfigError("You must pass a valid --InConfig option")
+
+            # Read the input config and create a truanchild Config object
+            self.config = truantchild.Config([opts.InConfig])
+
+            # make sure the id from the binary matches the config
+            if self.getID() != self.config.id:
+                print "Mismatching configurations!!"
+                return 1
+
+            # XXX Add the bit about help, line 215
+
+            inputs = self.config._inputParams
+            outputs= self.config._outputParams
+            constants = None                # Fuzzbunch doesn't support these yet
+
+            #pytrch.Params_parseCommandLine( inputs.parameters, len(sys.argv), sys.argv, doHelp)
+
+            # Convert the options from Truanchild to easy-to-handle input for the plugin
+            iOptions = self.tc2List( inputs )
+            oOptions = self.tc2Dict( outputs )
+
+            # add the params from the wrapper
+            valid = self.validateParams(iOptions)
+            # XXX Print the invalid options
+            if opts.ValidateOnly is True:
+                return 0
+
+            (fhNo, logConfig) = self.processWrapperParams( opts )
+
+            # Setup all of the existing sockets
+            self.doRendezvousClient(inputs)        
+            retval = self.processParams(iOptions, constants, oOptions, context, logConfig)
+
+            try:
+                self.options2Tc( oOptions, outputs )
+            except Exception as e:
+                # If this fails, the plugin was not successful
+                print str(oOptions)
+                print "Failed: {0}".format(e)
+                return 1
+
+            # Add the output parameter for the rendezvous
+            (rendezvous, sock) = self.addWrapperOutputParams( outputs, self.config.namespaceUri, self.config.schemaVersion )
+            exma.writeParamsToEM( fhNo, self.config.getMarshalledInConfig() )
+        
+            # This sends us into a send/recv loop
+            self.doRendezvousServer( rendezvous, sock )
+            self.cleanup( EDF_CLEANUP_WAIT, context, logConfig )
+
+        except Exception as e:
+            print "Failed: {0}".format(e)
+            raise
+    
+    def __putConfig(self, config, outfile):
+        self.config.putMarshalledConfig( opts.OutConfig )
+    
+    def processWrapperParams(self, options):
+        """Setup so that we can do logging"""
+        fh = None
+        if options.LogFile is not None:
+            print "logging to file"
+            fh = exma.openEMForWriting( options.OutConfig )
+            logger = get_logger(options.LogFile)
+            #logging.basicConfig(filename=options.LogFile, filemode="w", format="%(message)s", level=logging.INFO)
+        else:
+            print "logging to stdout"
+            fh = exma.openEMForWriting( None )        # Will cause stdout to be used
+            logger = get_logger( None )
+            #logging.basicConfig(level=logging.INFO, stream=sys.stdout)
+        return (fh, logger)
+        
+    def tc2Dict(self, params):
+        """Convert Truantchild parameters into a dictionary for easy processing"""
+        d = {}
+        for k,v in params.getParameterList():
+            d[k] = v
+        return d 
+
+    def tc2List(self, inputs):
+        """Convert inputs to optparse style options for ease of processing in Python"""
+        args = []
+        for k,v in inputs.getParameterList():
+            args += ["--{0}".format(k), str(v)]
+        return args
+
+    def iterParams(self, params):
+        """A parameter iterator"""
+        for k,v in params.getParameterList():
+            yield k
+
+    def options2Tc( self, options, outputs ):
+        """Convert from optparse options back to Truantchild parameters after execution"""
+        # Need to match between the names of the outputs and the types in the config
+        for name, val in outputs.getParameterList():
+            if name in options.keys():
+                # set the value
+                outputs.set(name, options[name])
+
+    def __needRendezvous(self, params, checkForContract):
+        """Basically stolen from plugin::createsRendezvous"""
+        if checkForContract:
+            for name,val in params.getParameterList():
+                if "Socket" == params.findOption(name).getType():
+                    return True
+        return False
+
+    def __exma_bindRendezvous(self, outputs, namespaceUri, schemaVersion):
+        """bindRendezvous taken from exma.dll"""
+        rendezvous = ctypes.c_ushort()
+        sock = ctypes.c_uint()
+        ret = exma.bindRendezvous(ctypes.pointer(rendezvous), ctypes.pointer(sock))
+        return (rendezvous.value, sock.value)
+
+    def addWrapperOutputParams(self, outputs, namespaceUri, schemaVersion):
+        """Add output parameters after the script runs to do rendezvous"""
+        rendezvous = None
+        sock = None
+        if self.__needRendezvous(outputs, True):
+            (rendezvous, sock) = self.__exma_bindRendezvous( outputs, namespaceUri, schemaVersion)
+            outputs.addRendezvousParam( str(rendezvous) )  # addRendezvous needs a string
+        return (rendezvous, sock)
+
+    def __transformSocket(self, rendezvous, remoteSocket, localSocket, cache):
+        """Perform the rendezvous socket transfer between plugins"""
+        ls = ctypes.c_uint()
+        if remoteSocket is None:
+            localSocket = None
+            return
+        
+        # Look in the cache
+        for (l,r) in cache:
+            if remoteSocket == r:
+                localSocket = l
+                return
+
+        # Didn't find it in the cache, so add it
+        exma.recvSocket( ctypes.c_uint(rendezvous), ctypes.c_uint(remoteSocket), ctypes.pointer(ls) )
+        localSocket = ls.value
+        entry = (ls.value, remoteSocket )
+        cache.append(entry)
+
+    def doRendezvousClient(self, inputs):
+        """Connect all sockets to rendezvous server sockets"""
+        cache = []
+        rendezvousLocation = None
+        sock = ctypes.c_uint()
+        local = None
+        sockparams = []
+        for name,val in inputs.getParameterList():
+            if name == "Rendezvous" and inputs.hasValidValue("Rendezvous"): 
+                rendezvousLocation = inputs.get("Rendezvous")
+            elif "Socket" == inputs.findOption(name).getType():
+                sockets.append(inputs.findOption(name))
+                
+        if rendezvousLocation is not None and sockparam is not None:
+            exma.connectRendezvous( rendezvousLocation, ctypes.pointer(sock) )
+
+        for param in sockparams:
+            if param.getFormat() == "Scalar":
+                remote = param.getValue()
+                self.__transformSocket( sock.value, remote, local, cache)
+                param.setValue(local)
+            else:
+                socks = params.getvalue() # this is a list
+                for i in xrange(remotes):
+                    self.__transformSocket( sock, socks[i], local, cache )
+                    socks[i] = local
+                param.setValue(socks)
+        exma.disconnectRendezvous( sock )
+        # Now get rid of the rendezvous parameter
+                
+    def doRendezvousServer(self, rendezvous, sock):
+        """Setup the rendezvous server so the next plugin can talk 'through' us"""
+        if sock is not None:
+            r = ctypes.c_uint(sock)
+            if -1 == exma.sendSockets(r):
+                return -1
+            exma.closeRendezvous( ctypes.c_ushort(rendezvous), r)
+            sock = None
+        return 0
+
+    #
+    # These need to be implemented by the exploit
+    # 
+    def processParams(self, inputs, constants, outputs, context, logConfig):
+        """Process the input parameters and achieve the intended purpose"""
+        raise NotImplementedError("processParams must be implemented")
+
+    def getID(self):
+        """Return the plugin ID"""
+        raise NotImplementedError("getID must be implemented")
+
+    def cleanup(self, flags, context, logConfig):
+        """Cleanup any errant connections or data after the rendezvous is done"""
+        raise NotImplementedError("cleanup must be implemented")
+
+    def validateParams(self, inputs):
+        """Validate parameters to verify sane values"""
+        raise NotImplementedError("validateParams must be implemented")
diff --git a/windows/fuzzbunch/command.py b/windows/fuzzbunch/command.py
new file mode 100644
index 0000000..3135e58
--- /dev/null
+++ b/windows/fuzzbunch/command.py
@@ -0,0 +1,555 @@
+"""
+Derived command line processing handler class from the Python standard
+module 'cmd'.  Many methods overridden to support more FB like behavior.
+
+"""
+import string
+import subprocess
+import time
+
+from context   import CmdCtx
+import exception
+import iohandler
+import cmd
+
+__all__ = ["FbCmd"]
+
+PROMPT_PRE = 'fb'
+PROMPT_POST = '> '
+PROMPT_FMTSTR = " %s (%s) "
+
+IDENTCHARS = string.ascii_letters + string.digits + '_'
+
+INTERACTIVE    = 1
+NONINTERACTIVE = 2
+
+class FbCmd(cmd.Cmd):
+    """Reimplementation of the Python Cmd class to fit more inline with Fuzzbunch
+    needs and operation.  It effectively provides a base set of capabilities and
+    commands.  The commands are:
+    * changeprompt
+    * help
+    * history
+    * sleep
+    * echo
+    * shell
+    * quit
+    * python
+    * script
+
+    """
+
+    use_rawinput = 1
+    identchars = IDENTCHARS
+
+    # Create a CmdCtx for this class
+    defaultcontext = CmdCtx("Fuzzbunch", "Fuzzbunch")
+    shortcutKeys = {"?" : "help",
+                    "!" : "shell"}
+
+    helpKeys = {"?" : "help"}
+
+    def __init__(self, stdin=None, stdout=None, stderr=None, enablecolor=True):
+        # Set our I/O handlers
+        self.init_io(stdin=stdin, stdout=stdout, stderr=stdout, enablecolor=enablecolor)
+        self.runmode_interactive()      # default to interactive mode
+
+        self.promptpre   = PROMPT_PRE
+        self.completekey = 'tab'
+        self.cmdqueue    = []       # Holds a list of commands yet to be executed 
+        self.cmdhistory  = []       # Holds a list of commands already executed
+
+        self.setcontext(None)       # Set us to the default context
+        self.setprompt()
+        
+    """
+    I/O Handling
+
+    Changed so that we can handle raw I/O, which python cmd.py cannot.
+    """
+    def init_io(self, stdin=None, stdout=None, stderr=None, logfile=None, enablecolor=True):
+        self.io = iohandler.IOhandler(stdin, stdout, logfile, enablecolor=enablecolor)
+
+    def set_raw(self, mode=1):
+        if mode in (1,0):
+            self.io.raw_input = mode
+
+    def set_ionoprompt(self, mode=False):
+        if mode in (True,False):
+            self.io.noprompt = mode
+
+    """
+    Run Mode Handling
+
+    Added to enable scriptability
+    """
+    def runmode_interactive(self):
+        self.runmode = INTERACTIVE
+        self.set_raw()
+        self.scripting(False)
+
+    def runmode_noninteractive(self):
+        self.runmode = NONINTERACTIVE
+        self.set_raw(0)
+        self.scripting(True)
+
+    def scripting(self, mode=False):
+        if mode in (False,True):
+            self.scriptmode = mode
+            self.set_ionoprompt(mode)
+
+    def is_interactive(self):
+        if self.runmode == INTERACTIVE:
+            return True
+        else:
+            return False
+
+    def is_scripted(self):
+        return self.scriptmode
+
+    """
+    Context handling
+    
+    Added to enable us to change the prompt easily among different plug-in or 
+    base contexts.
+    """
+    def setprompt(self, prompt=None):
+        """Set the prompt for the current context.  Append the name of
+        the current plugin to the prompt
+        """
+        if prompt is None:
+            if self.getcontext().get_name() == self.defaultcontext.get_name():
+                context = " "
+            else:
+                context = PROMPT_FMTSTR % (self.getcontext().get_type(), 
+                                           self.getcontext().get_name())
+            prompt = self.promptpre + context + PROMPT_POST
+        self.prompt = prompt
+
+    def setcontext(self, new_context):
+        """Change contexts"""
+        if new_context is None:
+            new_context = self.defaultcontext
+        self.ctx = new_context
+
+    def getcontext(self):
+        """Retrieve the current plugin context"""
+        return self.ctx
+
+    """
+    Change prompt look
+
+    """
+    def help_changeprompt(self):
+        usage = ["changeprompt [new prompt]",
+                 "Change the command prompt string. Run with no",
+                 "args for default prompt."]
+        self.io.print_usage(usage)
+
+    def do_changeprompt(self, input):
+        """Change the command prompt"""
+        newprompt = input.strip()
+        if newprompt:
+            self.promptpre = newprompt
+        else:
+            self.promptpre = PROMPT_PRE
+        self.setprompt()
+
+    """
+    Command parsing and handling
+    
+    """
+    def cmdloop(self):
+        """Repeatedly issue a prompt, accept input, parse an initial prefix
+        off the received input, and dispatch to action methods, passing them
+        the remainder of the line as argument.
+        """
+        self.preloop()
+        self.io.pre_input(self.complete)
+
+        try:
+            stop = None
+            while not stop:
+                if self.cmdqueue:
+                    # First, clear out anything we have in the command queue
+                    line = self.cmdqueue.pop(0)
+                else:
+                    # Then, accept input
+                    line = self.io.get_input(self.prompt)
+                stop = self.runcmd(line)
+            self.postloop()
+        finally:
+            self.io.post_input()
+
+
+    def runcmdlist(self, cmdlist):
+        stop = None
+        while cmdlist and not stop:
+            stop = self.runcmd(cmdlist.pop(0))
+
+    def runcmdlist_noex(self, cmdlist):
+        stop = None
+        while cmdlist and not stop:
+            stop = self.runcmd_noex(cmdlist.pop(0))
+
+    def runcmd_noex(self, line):
+        line = self.precmd(line)
+        stop = self.onecmd(line)
+        return self.postcmd(stop, line)
+
+    def runcmd(self, line):
+        try:
+            stop = self.runcmd_noex(line)
+        except exception.CmdErr, err:
+            self.io.print_error(err.getErr())
+            stop = None
+        return stop
+
+
+    def register_shortcut(self, shortcutChar, expansion):
+        """Register a new shortcut key expansion.  If a shortcut key is reused
+        the old command will be deleted.
+        
+        """
+        if shortcutChar in self.shortcutKeys:
+            del self.shortcutKeys[shortcutChar]
+        self.shortcutKeys[shortcutChar] = expansion 
+
+    def precmd(self, line):
+        """Executed before each command. Append the line to history and then log
+        the line to the output.
+        
+        """
+        if len(line.strip()):
+            self.cmdhistory.append(line)
+        self.io.log(self.prompt + line)
+        return line
+
+    #def postcmd(self, stop, line):
+    #    """Executed after each command."""
+    #    return stop
+
+    #def preloop(self):
+    #    pass
+
+    #def postloop(self):
+    #    pass
+
+    def parseline(self, line):
+        """Parse the line into a command name and a string containing the
+        arguments.  Returns a tuple containing (command, args, line).
+        'command' and 'args' may be None if line couldn't be parsed.  Check for
+        registered special handlers.
+        """
+        line = line.strip()
+        if not line:
+            return None, None, line
+        
+        if line[-1:] in self.helpKeys:
+            line = self.helpKeys[line[-1:]] + " " + line[:-1]
+
+        if line[0] in self.shortcutKeys:
+            line = self.shortcutKeys[line[0]] + " " + line[1:]
+
+        i, n = 0, len(line)
+        while i < n and line[i] in self.identchars:
+            i = i+1
+        cmd, arg = line[:i], line[i:].strip()
+        return cmd, arg, line
+
+    def onecmd(self, line):
+        """Run a single command. Exceptions should be caught by the caller"""
+        cmd, arg, line = self.parseline(line)
+        if not line:
+            return self.emptyline()
+        if cmd is None:
+            return self.default(line)
+        self.lastcmd = line
+        if cmd == '':
+            return self.default(line)
+        else:
+            try:
+                # retrieve the command execution function, which will be 
+                # self.do_<command>
+                func = getattr(self, 'do_' + cmd.lower())
+            except AttributeError:
+                return self.default(line)
+            return func(arg)
+            
+    def emptyline(self):
+        """Called when an empty line is encountered"""
+        pass
+
+    def default(self, line):
+        """Called when command prefix is not recognized."""
+        cmd, arg, line = self.parseline(line)
+
+        # Check if the current context handles the cmd instead
+        try:
+            func = self.ctx.lookup_function(cmd)
+        except AttributeError:
+            self.io.print_error("Unknown syntax: %s" % line)
+        else:
+            func(arg)
+
+    
+    #def completedefault(self, *ignored):
+    #    return []
+
+    def completenames(self, text, *ignored):
+        """Return a list of command names for command completion."""
+        dotext = 'do_' + text
+        return [ a[3:] for a in self.ctx.get_names() if a.startswith(dotext) ] +\
+               [ a[3:] for a in self.get_names()     if a.startswith(dotext) ]
+
+    def get_compstate(self, text, arglist):
+        if text == "":
+            return len(arglist)
+        else:
+            return max(len(arglist) - 1, 0)
+
+    def complete(self, text, state):
+        """Return the next possible completion for 'text'."""
+        if state == 0:
+            try:
+                import readline
+            except ImportError:
+                import pyreadline as readline
+            origline = readline.get_line_buffer()
+            begidx = readline.get_begidx()
+            endidx = readline.get_endidx()
+            if begidx > 0:
+                cmd, args, foo = self.parseline(origline)
+                if cmd == '':
+                    compfunc = self.completedefault
+                else:
+                    try:
+                        compfunc = getattr(self, 'complete_' + cmd.lower())
+                    except AttributeError:
+                        try:
+                            compfunc = self.ctx.lookup_compfunction(cmd)
+                        except AttributeError:
+                            compfunc = self.completedefault
+            else:
+                compfunc = self.completenames
+            arglist = [item.strip() for item in origline.strip().split()]
+            comp_state = self.get_compstate(text, arglist)
+            self.completion_matches = compfunc(text, origline, arglist, comp_state, begidx, endidx)
+
+        try:
+            return self.completion_matches[state]
+        except IndexError:
+            return None
+
+    #def get_names(self):
+    #    names = []
+    #    classes = [self.__class__]
+    #    while classes:
+    #        aclass = classes.pop(0)
+    #        if aclass.__bases__:
+    #            classes = classes + list(aclass.__bases__)
+    #        names = names + dir(aclass)
+    #    return names
+
+    def complete_help(self, *args):
+        return self.completenames(*args)
+
+
+    """
+    Cmd: help
+
+    """
+    def get_help_lists(self, names, ctx):
+        do_cmds = list(set([name for name in names if name.startswith('do_')]))
+        do_cmds.sort()
+        return [(name[3:], str(getattr(ctx, name).__doc__)) for name in do_cmds]
+
+    def get_shortcut_help(self):
+        """Shortcut help"""
+        return [(key, "Shortcut for %s" % val) for key,val in self.shortcutKeys.items()]
+
+    def do_help(self, input):
+        """Print out help"""
+        args = input.strip().split()
+        if len(args) > 0:
+            arg = args[0]
+            try:
+                func = self.ctx.lookup_helpfunction(arg)
+                func()
+            except AttributeError:
+                pass
+            try:
+                func = getattr(self, 'help_' + arg.lower())
+                func()
+            except AttributeError:
+                pass
+        else:
+            cmds = self.get_shortcut_help() + self.get_help_lists(self.get_names(), self)
+            cmdlist = {'title'    : "Core Commands",
+                       'commands' : cmds}
+            self.io.print_cmd_list(cmdlist)
+
+            if self.ctx.get_name() != self.defaultcontext.get_name():
+                cmds = self.get_help_lists(self.ctx.get_names(), self.ctx)
+                cmdlist = {'title'    : "%s Commands" %self.ctx.get_type(),
+                           'commands' : cmds}
+                self.io.print_cmd_list(cmdlist)
+
+
+    """
+    Cmd: history
+
+    """
+    def help_history(self):
+        usage = ["history [index]",
+                "Rerun a previous command. Omit index to print history"]
+        self.io.print_usage(usage)
+
+    def do_history(self, arg):
+        """Run a previous command."""
+        # keep the history cmds out of the history to reduce noise
+        self.cmdhistory.pop()
+        if len(arg) == 0:
+            history = {'items' : enumerate(self.cmdhistory)}
+            self.io.print_history(history)
+        else:
+            try:
+                index = int(arg)
+            except ValueError:
+                self.io.print_error("Bad history index")
+                return
+
+            try:
+                self.cmdqueue.append(self.cmdhistory[index])
+            except IndexError:
+                maxIndex = len(self.cmdhistory) - 1
+                self.io.print_error("History index out of range [0 : %d]" % maxIndex)
+
+
+    """
+    Cmd: sleep
+
+    """
+    def help_sleep(self):
+        usage = ["sleep [N seconds]",
+                 "Sleep for N seconds"]
+        self.io.print_usage(usage)
+
+    def do_sleep(self, count):
+        """Sleep for n seconds"""
+        try:
+            count = int(count)
+        except ValueError:
+            self.io.print_error("Invalid delay")
+            return 
+        self.io.print_msg("Sleeping for %d seconds" % count)
+        try:
+            time.sleep(count)
+        except KeyboardInterrupt:
+            self.io.print_error("User Interrupt")
+
+    """
+    Cmd: echo
+
+    """
+    def help_echo(self):
+        usage = ["echo [msg]",
+                 "echo the given message"]
+        self.io.print_usage(usage)
+
+    def do_echo(self, msg):
+        """Echo a message"""
+        self.io.print_msg(msg.strip())
+
+    """
+    Cmd: shell
+
+    """
+    def help_shell(self):
+        usage = ["shell [command [args]]",
+                 "Runs command with args in OS shell"]
+        self.io.print_usage(usage)
+
+    def do_shell(self, arg):
+        """Execute a shell command"""
+        try:
+            retcode = subprocess.call(arg, shell=True)
+            del retcode
+        except OSError, e:
+            self.io.print_error("Execution failed: " + e.message)
+        except KeyboardInterrupt:
+            self.io.print_warning("Execution aborted by user: Ctrl-c")
+
+
+    """
+    Cmd: EOF, quit
+
+    """
+    def help_eof(self):
+        usage = ["eof",
+                 "Quits program (CTRL-D)"]
+        self.io.print_usage(usage)
+
+    def do_eof(self, arg):
+        """Quit program (CTRL-D)"""
+        return self.do_quit(arg)
+
+    def help_quit(self):
+        usage = ["quit",
+                 "Quits program (CTRL-D)"]
+        self.io.print_usage(usage)
+    def do_quit(self, arg):
+        """Quit program"""
+        return True
+
+    """
+    Cmd: Python
+
+    """
+    def help_python(self):
+        usage = ["python",
+                 "Enters the interactive python interpreter. Exit the",
+                 "interpreter to return back to Fuzzbunch."]
+        self.io.print_usage(usage)
+
+    def do_python(self, arg):
+        """Drop to an interactive Python interpreter"""
+        raise exception.Interpreter
+
+    """
+    Scripting Support
+
+    """
+    def help_script(self):
+        usage = ["script [scriptfile]",
+                 "Run the given scriptfile"]
+        self.io.print_usage(usage)
+
+    def do_script(self, input):
+        """Run a script"""
+        inputList = input.strip().split()
+
+        if len(inputList) == 0:
+            self.help_script()
+        else:
+            try:
+                self.scripting(True)
+                try:
+                    script = [ line.strip() 
+                               for line in open(inputList[0]).readlines()
+                               if not line.startswith('#') ]
+                except IOError:
+                    raise exception.CmdErr, "Couldn't read script file"
+                self.runcmdlist_noex(script)
+            except exception.CmdErr, err:
+                self.io.print_error(err.getErr())
+                self.io.print_error("Aborting script")
+            finally:
+                self.scripting(False)
+
+
+if __name__ == "__main__":
+    fb = FbCmd()
+    fb.cmdloop()
+
+
diff --git a/windows/fuzzbunch/context.py b/windows/fuzzbunch/context.py
new file mode 100644
index 0000000..65069c8
--- /dev/null
+++ b/windows/fuzzbunch/context.py
@@ -0,0 +1,75 @@
+"""
+Base command context class used to extend the cmd class.  A context provides
+it's own set of do_cmds but is largely managed by the cmd class.
+
+The CmdCtx class by itself is largely useless.  It should be used as base class
+to derive any desired context from.
+
+Contexts can be standalone or can be plugin managers.  
+"""
+
+__all__ = ["CmdCtx"]
+
+class CmdCtx:
+    """Cmd context class that can be used to dynamically extend the Cmd
+    class to handle additional commands.  This defines the interface
+    for derived classes.
+    """
+    def __init__(self, name, type):
+        # Metadata abou the Command Context, including name and type
+        self.set_name(name)
+        self.set_type(type)
+
+    def get_name(self):
+        """Get the name of the context"""
+        return self.name
+
+    def get_type(self):
+        """Get the type of the context"""
+        return self.type
+
+    def set_name(self, name):
+        """Set the name of the context"""
+        self.name = name
+
+    def set_type(self, type):
+        """Set the type of the context"""
+        self.type = type
+
+    def print_info(self):
+        """Print context info"""
+        return
+
+    def lookup_function(self, name):
+        return getattr(self, 'do_' + name.lower())
+
+    def lookup_compfunction(self, name):
+        return getattr(self, 'complete_' + name.lower())
+
+    def lookup_helpfunction(self, name):
+        return getattr(self, 'help_' + name.lower())
+
+    def get_names(self):
+        names = []
+        classes = [self.__class__]
+        while classes:
+            aclass = classes.pop(0)
+            if aclass.__bases__:
+                classes = classes + list(aclass.__bases__)
+            names = names + dir(aclass)
+        return names
+
+    def set_active_plugin(self, unused):
+        """Set the active plugin"""
+        pass
+
+    def get_active_name(self):
+        """Get the name of the active plugin"""
+        return self.get_name()
+
+    def get_plugins(self):
+        """Return a list of all plugins"""
+        return []
+
+
+
diff --git a/windows/fuzzbunch/daveplugin.py b/windows/fuzzbunch/daveplugin.py
new file mode 100644
index 0000000..efb6b4b
--- /dev/null
+++ b/windows/fuzzbunch/daveplugin.py
@@ -0,0 +1,528 @@
+import hashlib, os, threading
+import xml.parsers.expat as expat
+
+import exception, util, truantchild
+import edfmeta, edfexecution
+#from plugin import Plugin
+from edfplugin import EDFPlugin
+from pytrch import TrchError
+
+from redirection  import LocalRedirection, RemoteRedirection
+
+__all__ = ["DAVEPlugin"]
+
+class DAVEPlugin(EDFPlugin):
+    def __init__(self, files, io):
+        # DAVE plugins are *currently* supported only on Win32 (that's a
+        # restriction based on delivery mechanisms, not the DAVE spec itself)
+        import sys
+        if sys.platform != "win32":
+            raise EnvironmentError("DAVEPlugins are supported only on Windows for this version of Fuzzbunch!")
+        
+        try:
+            EDFPlugin.__init__(self, files, io)
+            self.metaconfig = files[2]
+            self.initTouches()
+            self.initConsoleMode()
+            self.initRedirection()
+        except TrchError:
+            # There was an error parsing the plug-in XML
+            raise
+        except IndexError:
+            # We didn't get the right number of files
+            raise
+        self.procs = []
+        self.package_arches = edfmeta.parse_forward(self.metaconfig)
+        if not self.package_arches:
+            raise EnvironmentError("A DAVEPlugin is missing required 'package' information in its .fb file!")
+            
+    def getMetaHash(self):
+        return "%s %s %s" % (hashlib.sha1(open(self.metaconfig, 'rb').read()).hexdigest(),
+                                      os.lstat(self.metaconfig).st_size,
+                                      os.path.basename(self.metaconfig))
+ 
+
+    def canDeploy(self):
+        return True
+ 
+    def killPlugin(self):
+        """Helper function for forceful termination of the plugin executable,
+        primarily used for testing
+        """
+        for p in self.procs:
+            p.kill()
+        self.procs = []
+
+
+    def write_interpreted_xml_file(self, inConfFile, globalvars={}):
+        """Rewrite the inconfig, substituting variables"""
+        tmpFile = open(inConfFile, "w");
+
+        # Note: Truantchild has been used to this point to store parameters, so 
+        # the inconfig here represents all of the prompted data
+        configdata = self.getMarshalledInConfig()
+        configlines = configdata.split("\n")
+        newlines = []
+        for line in configlines:
+            newlines.append(util.variable_replace(line, globalvars))
+        newconfig = "\n".join(newlines)
+        tmpFile.write(newconfig)
+        tmpFile.close()
+        return inConfFile
+
+    """
+    Plugin validation routine
+
+    """
+    def validate(self, dirs, globalvars={}):
+        baseDir, logDir = dirs
+        timestamp = util.formattime()
+        exeBaseName = os.path.basename(self.executable)
+
+        logName = "%s-%s.log" % (exeBaseName, timestamp)
+        logFile = os.path.join(logDir, logName)
+        try:
+            os.remove(logFile)
+        except:
+            pass
+
+        inConfName = "%s-%s-InConfig.validate.xml" % (exeBaseName, timestamp)
+        inConfFile = os.path.join(logDir, inConfName)
+        self.write_interpreted_xml_file(inConfFile, globalvars=globalvars)
+
+        if edfexecution.validate_plugin(self.executable, inConfFile, self.io) == 0:
+            return True
+        else:
+            return False
+    
+    def marshal_params(self, logDir, archOs, output_filename=None, globalvars={}):
+        import sys, subprocess, platform
+        
+        # Find/compute various paths and filename components we'll need later
+        storageDir = globalvars['FbStorage']
+        timestamp = util.formattime()
+        exeBaseName = os.path.basename(self.executable)
+        
+        # Get our own packaging options (for reference)
+        arch_map = self.package_arches
+        
+        # Figure out which piece to use for marshaling
+        host_archOs = "%s-%s" % (platform.machine(), platform.system())
+        proxy = arch_map[host_archOs][0]
+        core = arch_map[archOs][1]
+        
+        # Non supported!
+        if proxy is None:
+            return (None, None)
+        
+        # Get files/paths set up for marshaling
+        if output_filename is None:
+            output_filename = os.path.join(logDir, "%s-%s-Marshal.bin" % (exeBaseName, timestamp))
+        output_path = os.path.dirname(output_filename)
+        try:
+            os.makedirs(output_path)
+        except os.error:
+            assert os.path.isdir(output_path), "Output path '%s' could not be found/created!" % output_path
+        xml_config_name = os.path.join(logDir, "%s-%s-InConfig.marshal.xml" % (exeBaseName, timestamp))
+        self.write_interpreted_xml_file(xml_config_name, globalvars=globalvars)
+        
+        # Fire off the DANE config utility to actually create the package.  Note that this is strictly
+        # Win32[/64] for now...
+        # (This stuff should be abtracted away form cross-platformness and to avoid hard-coded paths.)
+        proxy_dll = os.path.join(os.path.dirname(self.executable), proxy)
+        assert os.path.isfile(proxy_dll), "Required file '%s' doesn't exist!" % proxy_dll
+        self.io.print_msg("\tUsing '%s' to handle parameter marshaling" % proxy_dll)
+        self.io.print_msg("\tMarshaling the contents of '%s'" % xml_config_name)
+
+        config_exe = os.path.join(storageDir, 'dvmarshal.exe')
+        assert os.path.isfile(config_exe), "Required program '%s' doesn't exist!" % config_exe
+        subprocess.check_call([config_exe, proxy_dll, xml_config_name, output_filename])
+        
+        core_dll = os.path.join(os.path.dirname(self.executable), core)
+        return (core_dll, output_filename)
+    
+    def build_package(self, logDir, archOs, listenPort=None, output_filename=None, globalvars={}):
+        import sys, subprocess, platform
+        
+        # Find/compute various paths and filename components we'll need later
+        storageDir = globalvars['FbStorage']
+        timestamp = util.formattime()
+        exeBaseName = os.path.basename(self.executable)
+        
+        # Get our own packaging options (for reference)
+        arch_map = self.package_arches
+        
+        # Figure out which architecture/OS to use for each piece
+        host_archOs = "%s-%s" % (platform.machine(), platform.system())
+        proxy = arch_map[host_archOs][0]
+        core = arch_map[archOs][1]
+        
+        if (proxy is None) or (core is None):
+            # Not supported!
+            return None
+        
+        if output_filename is None:
+            output_filename = os.path.join(logDir, "%s-%s-Package.dll" % (exeBaseName, timestamp))
+        
+        output_path = os.path.dirname(output_filename)
+        try:
+            os.makedirs(output_path)
+        except os.error:
+            assert os.path.isdir(output_path), "Output path '%s' could not be found/created!" % output_path
+        
+        xml_config_name = os.path.join(logDir, "%s-%s-InConfig.package.xml" % (exeBaseName, timestamp))
+        self.write_interpreted_xml_file(xml_config_name, globalvars=globalvars)
+        
+        # Fire off the DANE config utility to actually create the package.  Note that this is strictly
+        # Win32[/64] for now...
+        # (This stuff should be abtracted away for cross-platformness and to avoid hard-coded paths.)
+        baseArch = archOs.split('-')[0]
+
+        dane_dll = os.path.join(storageDir, 'dane_%s.dll' % baseArch)
+        assert os.path.isfile(dane_dll), "Required file '%s' doesn't exist!" % dane_dll
+        self.io.print_msg("\tUsing '%s' as the output template" % dane_dll)
+        
+        proxy_dll = os.path.join(os.path.dirname(self.executable), proxy)
+        assert os.path.isfile(proxy_dll), "Required file '%s' doesn't exist!" % proxy_dll
+        self.io.print_msg("\tUsing '%s' to handle parameter marshaling" % proxy_dll)
+        
+        core_dll = os.path.join(os.path.dirname(self.executable), core)
+        assert os.path.isfile(core_dll), "Required file '%s' doesn't exist!" % core_dll
+        self.io.print_msg("\tUsing '%s' as the input payload" % core_dll)
+
+        config_exe = os.path.join(storageDir, 'danecfg.exe')
+        assert os.path.isfile(config_exe), "Required program '%s' doesn't exist!" % config_exe
+        subprocess.check_call([config_exe, dane_dll, proxy_dll, core_dll, xml_config_name, output_filename])
+        
+        if listenPort:
+            # Pack in the listen-port as a particular binary resource
+            import ctypes, struct
+            RT_RCDATA = 10
+            ID_PORTNUM = 101
+            LANG_ID = 0x0000
+            
+            BeginUpdateResource = ctypes.windll.kernel32.BeginUpdateResourceA
+            UpdateResource      = ctypes.windll.kernel32.UpdateResourceA
+            EndUpdateResource   = ctypes.windll.kernel32.EndUpdateResourceA
+            
+            rblob = struct.pack("<H", listenPort)
+            handle = BeginUpdateResource(output_filename, False)
+            if handle is None:
+                raise ctypes.WinError()
+            if not UpdateResource(handle, RT_RCDATA, ID_PORTNUM, LANG_ID, rblob, len(rblob)):
+                raise ctypes.WinError()
+            if not EndUpdateResource(handle, False):
+                raise ctypes.WinError()
+        
+        return output_filename
+    
+    """
+    Plugin execution routine
+
+    """
+    def execute(self, session, consolemode, interactive, scripted, globalvars={}, runMode='', archOs='x86-Windows', listenPort=0):
+        self.lastsession = session
+        baseDir, logDir = session.get_dirs()
+        waitmode, newconsole = self.get_runflags(consolemode, interactive, scripted)
+        timestamp = util.formattime()
+
+        # Save history
+        session.history = self.getParameters()
+
+        # Prompt for run mode
+        if runMode in ("DANE", "DAVE"):
+           
+            # TODO: prompt operator to verify remote callback tunnel exists for localhost comms
+            
+            if runMode == "DANE":
+                # Build package
+                packagePath = self.build_package(logDir, archOs, listenPort, globalvars=globalvars)
+                
+                # Print package info
+                self.io.print_success("DANE Package: %s" % packagePath)
+            # elif runMode == "DAVE":
+                # # Marshal params (and get core module name)
+                # modulePath, inputPath = self.marshal_params(logDir, archOs, globalvars=globalvars)
+                
+                # # Build up DAVE commandline
+                # dvcmds = 'daringveteran -module "%s" -input "%s" -run %s' % (
+                    # modulePath,
+                    # inputPath,
+                    # 'interactive' if (listenPort) else 'batch')
+                # if listenPort:
+                    # dvcmds += " -homeport %d" % listenPort
+                
+                # # Print core module and marshaled data info
+                # self.io.print_success('DAVE Pastable:\n\t' + dvcmds)
+            else:
+                raise NotImplementedError("No such option '%s'; what happened??" % (runMode))
+            
+            # Set "DaveProxyPort" hidden parameter in current config
+            if listenPort:
+                #self.set("DaveProxyPort", str(listenPort))
+                self.io.print_msg("Proxy listening on localhost:%d" % listenPort)
+            else:
+                # Bail right now--gracefully...
+                return newconsole, None
+        elif runMode == 'FB':
+            # Make sure the proxy port is zeroed
+            self.set("DaveProxyPort", "0")
+        else:
+            raise NotImplementedError("No such option '%s'; what happened??" % (runMode))
+        
+        exeBaseName = os.path.basename(self.executable)
+
+        logName = "%s-%s.log" % (exeBaseName, timestamp)
+        logFile = os.path.join(logDir, logName)
+        try:
+            os.remove(logFile)
+        except:
+            pass
+
+        # Touch the logfile
+        tmpFile = open(logFile, "w")
+        tmpFile.close()
+
+        # Create InConfig and write to the logdir
+        inConfName = "%s-%s-InConfig.xml" % (exeBaseName, timestamp)
+        inConfFile = os.path.join(logDir, inConfName)
+        self.write_interpreted_xml_file(inConfFile, globalvars=globalvars)
+
+        # Create the pipe that we will use for the --OutConfig parameter
+        pipeName = edfexecution.generate_pipename()
+        pipe = edfexecution.create_pipe(pipeName)
+
+        cwd = os.getcwd() 
+        os.chdir(logDir)
+        try:
+            #
+            # This is the sneaky bit for the output.  We call launch_plugin, 
+            # which does two things.  First, it passes stdin,stdout, and stderr
+            # to the call to subprocess.Popen so that output is duplicated to
+            # the console.  Second, it passes --OutConfig a pipe so that, when we
+            # later call write_outconfig, this contains only the data we want
+            #
+            proc = edfexecution.launch_plugin(self.executable, inConfFile, 
+                                      pipeName, logFile, self.io, newconsole)
+            self.procs.append(proc)
+        except KeyboardInterrupt:
+            self.io.print_error("Stopping plugin")
+            try:
+                self.procs.remove(proc)
+                proc.kill()
+            except:
+                pass
+            # Create the output param for the contract
+            session.contract = [util.oParam("Status", "Failed", "String", "Scalar"), 
+                                util.oParam("ReturnCode", "User Abort", "String", "Scalar")]
+            session.mark_fail()
+            raise exception.CmdErr, "Canceled by User"
+            
+        os.chdir(cwd)
+
+        try:
+            # Wait for the spawned process to connect to our named pipe
+            pipe = edfexecution.connect_pipe(pipe, pipeName)
+        except edfexecution.PipeError, err:
+            self.io.print_error(str(err))
+            pipe = None
+
+        if pipe == None:
+            try:
+                # Try to kill the process
+                self.procs.remove(proc)
+                proc.kill()
+            except:
+                pass
+            try:
+                # See if the process has terminated
+                proc.poll()
+            except:
+                pass
+            # Create the output param for the contract
+            session.contract = [util.oParam("Status", "Failed", "String", "Scalar"),
+                                util.oParam("ReturnCode", str(proc.returncode), "String", "Scalar")]
+            session.mark_fail()
+            raise exception.CmdErr, "Error Connecting Pipe to Plugin"
+
+        # Create OutConfig file name
+        outConfName = "%s-%s-OutConfig.xml" % (exeBaseName, timestamp)
+        outConfFile = os.path.join(logDir, outConfName)
+
+        if waitmode:
+            # Wait for the plugin to finish.  So, we don't have overlapping 
+            # output or problems waiting for the outconfig
+            self.get_outconfig(pipe, session, outConfFile, proc)
+        else:
+            # Creates a new thread to read output config from the executed plugin.  
+            pluginThread = threading.Thread(None, 
+                                  self.get_outconfig,
+                                  None,
+                                  (pipe, session, outConfFile, proc))
+            pluginThread.start()
+        return newconsole, logFile 
+
+    """
+    Output XML handling
+
+    """
+    def get_outconfig(self, pipe, session, outConfName, proc):
+        try:
+            # Read from the named pipe we passed to launch_plugin and 
+            # write to file
+            edfexecution.write_outconfig(outConfName, pipe)
+        except KeyboardInterrupt:
+            self.io.print_error("Canceled by User")
+            self.io.print_error("Stopping plugin")
+            try:
+                proc.kill()
+            except:
+                pass
+        finally:
+            # XXX - Remove_pipe too?
+            edfexecution.close_pipe(pipe)
+        try:
+            #name   = self.getName()
+            params = self.read_outxml(outConfName)
+            params.append(util.oParam("Status", "Success", "String", "Scalar"))
+            if len(params) > 1:
+                session.mark_ready()
+            else:
+                session.mark_used()
+        except (ValueError, TrchError, AttributeError) as e:
+            # We get here if the following conditions happen:
+            #  Argument errors to any calls
+            #  Plug-in failed and didn't actually write an outconfig
+            #  Output created an invalid XML configuration
+            #self.io.print_warning("Output XML error: It's either empty or does not parse: %s" % (e))
+            self.io.print_warning("Plugin failed")
+            proc.wait()
+            params = [util.oParam("Status", "Failed", "String", "Scalar"),
+                      util.oParam("ReturnCode", str(proc.returncode), "String", "Scalar")]
+            session.mark_fail()
+        session.contract = params
+
+    def read_outxml(self, filename):
+        try:
+            return truantchild.Config((filename, self.executable))._outputParams.getParameterListExt()
+        except:
+            pass
+
+    """
+    Session info description generation
+
+    """
+    def getSessionDescription(self):
+        descr = [""]
+        if self.redirection:
+            redir = self.getRedirection()
+            descr = []
+            for l in redir['local']:
+                try:
+                    descr.append( self.get(l.listenaddr) )
+                except exception.CmdErr:
+                    # The tunnel is invalid because the parameter is not in scope.  Ignore the tunnel
+                    pass
+        return " ".join(descr)
+
+    """
+    Rendezvous
+
+    """
+    def doRendezvous(self, value):
+        self._trch_addrendezvousparam(value)
+
+    """
+    Run Mode
+
+    """
+    def initConsoleMode(self):
+        if self.metaconfig:
+            try:
+                mode = edfmeta.parse_consolemode(self.metaconfig)
+                self.consolemode = util.convert_consolemode(mode)
+            except expat.ExpatError:
+                # Pass here because we printed something while parsing the
+                # invalid file, but we want execution to continue
+               pass
+        else:
+            EDFPlugin.initConsoleMode(self)
+
+    def get_runflags(self, mode, interactive, scripted):
+        """
+        
+        Return the following boolean flags:
+
+            newconsole - the plugin should execute in a new console
+            waitmode   - Execution should wait for the plugin to finish
+                         executing
+        """
+        if interactive:
+            if not mode:
+                # Use the plugin's settings
+                mode = self.getConsoleMode()
+        else:
+            # Non-interactive mode must reuse the console
+            mode = util.CONSOLE_REUSE
+
+        if mode == util.CONSOLE_REUSE:
+            # Reusing implies no new console
+            newconsole = False
+        else:
+            newconsole = True
+
+        waitmode = True
+        # If non-scripted, interactive sessions that launch new consoles don't
+        # need to wait for plugins to finish.  All other permutations do.
+        if interactive and not scripted and newconsole:
+            waitmode = False
+        return (waitmode,newconsole)
+
+    """
+    Redirection
+
+    """
+    def initRedirection(self):
+        redir = None
+        try:
+            redir = edfmeta.parse_redirection(self.xmlInConfig)
+        except expat.ExpatError:
+            self.io.print_error("Error parsing redirection information")
+
+        # XXX - What should we do if we fail to parse redirection?
+        counter = 1
+        for r in redir['remote']:
+            if 'name' not in r:
+                r['name'] = 'remote-tunnel-%d' % counter
+                counter += 1
+        counter = 1
+        for r in redir['local']:
+            if 'name' not in r:
+                r['name'] = 'local-tunnel-%d' % counter
+                counter += 1
+
+        self.redirection = {
+                'remote' : [RemoteRedirection(**r) for r in redir['remote']],
+                'local'  : [LocalRedirection(**l)  for l in redir['local']]
+                }
+
+    """
+    Touches
+
+    """
+    def initTouches(self):
+        if self.metaconfig:
+            try:
+                self.touchlist = edfmeta.parse_touchlist(self.metaconfig)
+            except exception.PluginMetaErr:
+                import os.path
+                (p,f) = os.path.split(self.metaconfig)
+                n = f.split('-')[0]
+                self.io.pre_input(None)
+                self.io.print_warning("Error in %s meta (.fb) file - touches not loaded " % (str(n)))
+                self.io.post_input()
+                EDFPlugin.initTouches(self)
+            except IndexError:
+                EDFPlugin.initTouches(self)
+        else:
+            EDFPlugin.initTouches(self)
diff --git a/windows/fuzzbunch/deployablemanager.py b/windows/fuzzbunch/deployablemanager.py
new file mode 100644
index 0000000..42505ac
--- /dev/null
+++ b/windows/fuzzbunch/deployablemanager.py
@@ -0,0 +1,157 @@
+"""
+    EDF Plugin Manager
+
+"""
+from command   import CmdCtx
+from iohandler import truncate
+import exception
+import util
+import traceback
+from pluginmanager import PluginManager
+
+MAX_PARAM_ECHO_LEN = 60
+
+EDF_PLUGIN_INFO = """
+    Name: %s
+ Version: %s
+    Type: %s
+"""
+
+__all__ = ["DeployableManager"]
+
+class DeployableManager(PluginManager):
+    def __init__(self, type, fb):
+        PluginManager.__init__(self, type, fb)
+    def exe_print_params(self, plugin, redirid):
+        args = {'title'   : plugin.getName(),
+                'session' : self.fb.redirection.get_session(redirid),
+                'vars'    : plugin.getParameters(hidden=True)}
+        self.io.print_exe_set_names(args)
+        
+    def do_execute(self, input):
+        """Execute the current plugin"""
+        session = None
+        self.io.newline()
+        inputList = input.strip().split()
+        if len(inputList) > 0:
+            consolemode = inputList[0].lower()
+            consolemode = util.convert_consolemode(consolemode)
+        else:
+            consolemode = 0
+
+        plugin = self.get_active_plugin()
+        self.io.print_warning("Preparing to Execute %s" % plugin.name)
+        if plugin.validate(self.session.get_dirs(), globalvars=self.fb.fbglobalvars) and plugin.isValid():
+            # XXX - Get the description before redirection.
+            # This really should be fixed to not care about order
+            runMode = 'FB'
+            plugin_desc = plugin.getSessionDescription()
+            
+            modes = [
+                ("DANE", "Forward deployment via DARINGNEOPHYTE"),
+                #("DAVE", "Forward deployment via DARINGVETERAN"),
+                ("FB", "Traditional deployment from within FUZZBUNCH"),
+            ]
+            self.io.print_prompt_param({
+                "name": "Mode",
+                "description": "Delivery mechanism",
+                "type": "Choice",
+                "attribs": modes
+            }, "0")
+            runMode = self.io.prompt_user("Mode", params=modes, default="0", gvars=self.fb.fbglobalvars)
+            self.io.print_success("Run Mode: %s" % (runMode))
+            self.io.newline()
+
+            listenPort = 0
+            if runMode in ("DANE", "DAVE"):
+                pairs = sorted((k, k) for k in plugin.package_arches.iterkeys())
+                self.io.print_prompt_param({
+                    "name": "ArchOs",
+                    "description": "Architecture/OS of REDIRECTOR",
+                    "required": "YES",
+                    "valid": "YES",
+                    "type": "Choice",
+                    "attribs": pairs
+                }, "0")
+                archOs = self.io.prompt_user("ArchOS", "0", pairs, gvars=self.fb.fbglobalvars)
+                # Prompt for proxy port
+                listenPort = int(self.io.prompt_user("Linkup TCP port (0=none)?", default="0", gvars=self.fb.fbglobalvars))
+                if listenPort:
+                    plugin.set("DaveProxyPort", str(listenPort))
+                    self.io.print_success("set DaveProxyPort ==> %d" % (listenPort))
+                # TODO: prompt operator to verify remote callback tunnel exists for localhost comms
+            else:
+                archOs = 'x86-Windows'
+            
+            if runMode == "FB":
+                if not self.io.prompt_yn("This will execute locally like traditional Fuzzbunch plugins. Are you sure? (y/n)"):
+                    raise exception.CmdErr("User abort")
+                redirid = self.fb.redirection.pre_exec(plugin)
+            else:
+                redirid = ''
+            
+            newwindow = False
+            
+            try:
+                # Last chance to quit, print execution info and prompt
+                if redirid:
+                    self.fb.redirection.print_session(redirid)
+                    #self.fb.do_redirect("")
+                    self.io.print_warning("Verify Redirection Tunnels Exist")
+                    self.io.prompt_confirm_redir()
+                self.exe_print_params(plugin, redirid)
+                self.io.prompt_continue()
+                self.io.print_msg("Executing Plugin")
+                if self.fb.log:
+                    try:
+                        self.fb.log[plugin.getName()] = self.fb.log.launch_from_command('execute', plugin.getName(), plugin.getConfigVersion()).start()
+                    except:
+                        pass
+                # Generate a new session and execute
+                session = self.session.add_item(plugin.getName(),
+                                                plugin_desc)
+                newwindow, logfile = plugin.execute(session, 
+                                                    consolemode, 
+                                                    self.fb.is_interactive(),
+                                                    self.fb.is_scripted(),
+                                                    globalvars=self.fb.fbglobalvars,
+                                                    runMode=runMode,
+                                                    archOs=archOs, 
+                                                    listenPort=listenPort)
+            except Exception as e:
+                self.io.print_error("Error running plugin: {0}".format(e))
+                newwindow = False
+                session = None
+            finally:
+                self.fb.redirection.post_exec(plugin, redirid)
+                if self.fb.log and plugin.name in self.fb.log:
+                    try:
+                        try: session
+                        except: pass
+                        else:
+                            if 'Project' in self.fb.fbglobalvars: self.fb.log[plugin.name].set(project_name=self.fb.fbglobalvars['Project'])
+                            self.fb.log[plugin.name].queue(**dict([(k,v) for k,v in session.history.params.values()]+[(v[0],v[1]) for v in session.contract.params.values()]))
+                            if session.is_failed(): parent = self.fb.log[plugin.name].failed_exploit()
+                            else: parent = self.fb.log[plugin.name].successful_exploit()
+                            self.fb.log[plugin.name].file_from_path(logfile, parent)
+                    except:
+                        if self.fb.log: self.fb.log.notify_of_error('Recording use of ' + str(plugin.name))
+
+            if runMode in ('DANE', 'DAVE'):
+                return
+                        
+            if newwindow:
+                self.io.print_warning("Plugin Spawned in New Console - Running Detached")
+            else:
+                if session and not session.is_failed():
+                    self.io.print_success("%s Succeeded" % plugin.name)
+                    if plugin.createsRendezvous():
+                        self.io.newline()
+                        self.io.print_warning("Connection to Target Established")
+                        self.io.print_warning("Waiting For Next Stage")
+                else:
+                    raise exception.CmdErr, "%s Failed" % plugin.name
+        else:
+            #self.do_validate()
+            raise exception.CmdErr, "Execution Aborted"
+        self.io.newline()
diff --git a/windows/fuzzbunch/edfexecution.py b/windows/fuzzbunch/edfexecution.py
new file mode 100644
index 0000000..b550c29
--- /dev/null
+++ b/windows/fuzzbunch/edfexecution.py
@@ -0,0 +1,268 @@
+"""
+
+Platform dependent plugin execution helper functions.
+
+"""
+
+import os
+import sys
+import uuid
+
+
+__all__ = ["generate_pipename",
+           "create_pipe",
+           "validate_plugin",
+           "launch_plugin",
+           "connect_pipe",
+           "write_outconfig",
+           "close_pipe",
+           "PipeError"]
+
+
+CONNECT_TIMEOUT_SECS = 45
+
+class PipeError(Exception):
+    pass
+
+mswindows = (sys.platform == "win32")
+
+if mswindows:
+    import win32pipe
+    import win32file
+    import pywintypes
+    import win32event
+    import subprocess
+
+    ERROR_PIPE_CONNECTED = 535
+    ERROR_IO_PENDING = 997
+
+    PIPE_PREFIX = "\\\\.\\pipe\\fb-pipe"
+
+else:
+    import signal
+    import subprocess
+
+    PIPE_PREFIX = "/tmp/fb-pipe-"
+
+
+#
+# Cross platform functions
+#
+def generate_pipename():
+    return PIPE_PREFIX + str(uuid.uuid4())
+
+#
+# MS Windows
+#
+if mswindows:
+
+    def create_pipe(pipeName):
+        # XXX - We should validate here and return None on fail
+        pipe = win32pipe.CreateNamedPipe(pipeName,
+                                         win32pipe.PIPE_ACCESS_INBOUND | win32file.FILE_FLAG_OVERLAPPED,
+                                         0x0,
+                                         1,
+                                         1024,
+                                         1024,
+                                         0,
+                                         None)
+        return pipe
+
+    def validate_plugin(binName, inName, io):
+        cmdLine = []
+        if binName.endswith(".py"):
+            cmdLine.append("python.exe")
+        cmdLine.append("\"%s\"" % binName)
+        cmdLine.append("--InConfig \"%s\"" % inName)
+        cmdLine.append("--ValidateOnly true")
+        try:
+            retcode = subprocess.call(" ".join(cmdLine),
+                                    stdout=io.stdout, 
+                                    stderr=io.stdout,
+                                    stdin=io.stdin,
+                                    env=os.environ)
+        except OSError, e:
+            io.print_error("Failed to execute: %s" % str(e))
+            retcode = 1
+
+        return retcode
+
+    def launch_plugin(binName, inName, pipeName, logFile, io, newconsole):
+        """Execute the process with the passed in parameters.  Note that the
+        output parameter is not a file name, but rather a named pipe!"""
+        if newconsole:
+            cmdLine = []
+            cmdLine.append("start \"%s\" cmd /T:9F /K " % binName)
+            if binName.endswith(".py"):
+                cmdLine.append("\"python.exe \"%s\"" % binName)
+            else:
+                cmdLine.append("\"\"%s\"" % binName)
+            cmdLine.append("--InConfig \"%s\"" % inName)
+            cmdLine.append("--OutConfig \"%s\"" % pipeName)
+            cmdLine.append("--LogFile \"%s\"\"" % logFile)
+            p = subprocess.Popen(" ".join(cmdLine), shell=True, env=os.environ)
+        else:
+            cmdLine = []
+            if binName.endswith(".py"):
+                cmdLine.append("python.exe")
+            cmdLine.append("\"%s\"" %  binName)
+            cmdLine.append("--InConfig \"%s\"" % inName)
+            cmdLine.append("--OutConfig \"%s\"" % pipeName)
+            cmdLine.append("--LogFile \"%s\"" % logFile)
+            p = subprocess.Popen(" ".join(cmdLine), 
+                             shell=False, 
+                             stdout=io.stdout, 
+                             stderr=io.stderr,
+                             stdin=io.stdin,
+                             env=os.environ)
+        return p
+            
+
+    def connect_pipe(pipe, pipeName):
+        overLap = pywintypes.OVERLAPPED()
+        overLap.hEvent = win32event.CreateEvent(None, 1, 0, None)
+        if overLap.hEvent == 0:
+            raise PipeError('Could not create hEvent')
+
+        try:
+            # Wait for a pipe client connection
+            ret = win32pipe.ConnectNamedPipe(pipe, overLap)
+            if not ret in (0, ERROR_PIPE_CONNECTED):
+                if ret == ERROR_IO_PENDING:
+                    ret = win32event.WaitForSingleObject(overLap.hEvent, 
+                                                         1000 * CONNECT_TIMEOUT_SECS)
+                    if ret != win32event.WAIT_OBJECT_0:
+                        # Timeout error
+                        raise PipeError('Timeout error')
+                else:
+                    # API error
+                    raise PipeError('API error')
+
+                ret = win32pipe.GetOverlappedResult(pipe, overLap, True)
+            if not ret in (0, ERROR_PIPE_CONNECTED):
+                # API Error
+                raise PipeError('API error 2')
+        except PipeError:
+            # Named pipe exception
+            win32file.CancelIo(pipe)
+            pipe.close()
+            raise
+        except BaseException, err:
+            win32file.CancelIo(pipe)
+            pipe.close()
+            pipe = None
+            raise PipeError('BaseException : ' + str(err))
+
+        return pipe 
+
+
+    def write_outconfig(fileName, pipe):
+        tmpFile = open(fileName, "w")
+        while 1:
+            try:
+                (ret, line) = win32file.ReadFile(pipe, 4096, None)
+                if ret != 0 or line == "":
+                    break
+                else:
+                    tmpFile.write(line)
+            except:
+                break
+        tmpFile.close()
+
+
+    def close_pipe(pipe):
+        win32file.CancelIo(pipe)
+        pipe.close()
+
+#
+# Linux
+#
+else:
+    def SIGALRM_handler(sigNum, frame):
+        return
+
+    def create_pipe(pipename):
+        os.mkfifo(pipename, 0666)
+        return None
+
+    def launch_plugin(binName, inName, pipeName, logFile, io, newconsole):
+        """Execute the process with the passed in parameters.  Note that the
+        output parameter is not a file name, but rather a named pipe!"""
+        if newconsole:
+            cmdLine = []
+            cmdLine.append("/usr/bin/xterm -hold -T \"%s\" -e " % binName)
+            cmdLine.append("\"%s\"" % binName)
+            cmdLine.append("--InConfig \"%s\"" % inName)        # Contains the input parameters
+            cmdLine.append("--OutConfig \"%s\"" % pipeName)
+            cmdLine.append("--LogFile \"%s\"" % logFile)
+            p = subprocess.Popen(" ".join(cmdLine), shell=True, env=os.environ)
+        else:
+            cmdLine = []
+            if binName.endswith(".py"):
+                cmdLine.append("/usr/bin/python2.6")
+            cmdLine.append("\"%s\"" % binName)
+            cmdLine.append("--InConfig \"%s\"" % inName)        # Contains the input parameters
+            cmdLine.append("--OutConfig \"%s\"" % pipeName)
+            cmdLine.append("--LogFile \"%s\"" % logFile)
+            p = subprocess.Popen(" ".join(cmdLine), shell=True, 
+                                 stdout=io.stdout, 
+                                 stderr=io.stderr, 
+                                 stdin=io.stdin,
+                                 env=os.environ)
+        return p
+
+    def validate_plugin(binName, inName, io):
+        cmdLine = []
+        if binName.endswith(".py"):
+            cmdLine.append("/usr/bin/python2.6")
+        cmdLine.append("\"%s\"" % binName)
+        cmdLine.append("--InConfig \"%s\"" % inName)
+        cmdLine.append("--ValidateOnly true")
+        try:
+            retcode = subprocess.call(" ".join(cmdLine),
+                                    stdout=io.stdout, 
+                                    stderr=io.stdout, 
+                                    stdin=io.stdin,
+                                    shell=True,
+                                    env=os.environ)
+        except OSError, e:
+            io.print_error("Failed to execute: %s" % str(e))
+            retcode = 1
+        return retcode
+
+    def connect_pipe(pipe, pipeName):
+        """
+        """
+        oldHandler = signal.getsignal(signal.SIGALRM)
+        try:
+            signal.signal(signal.SIGALRM, SIGALRM_handler)
+            signal.alarm(CONNECT_TIMEOUT_SECS + 1)
+            retval = os.open(pipeName, os.O_RDONLY)
+            signal.alarm(0)
+        except OSError:
+            # Alarm Timeout
+            retval = None
+        except BaseException:
+            # Keyboard interrupt
+            retval = None
+
+        # cancel the alarm and restore prev handler
+        signal.signal(signal.SIGALRM, oldHandler)
+
+        return retval
+
+
+    def write_outconfig(fileName, pipe):
+        tmpFile = open(fileName, "w")
+        while 1:
+            line = os.read(pipe, 4096)
+            if len(line) == 0:
+                break
+            else:
+                tmpFile.write(line)
+        tmpFile.close()
+
+    def close_pipe(pipe):
+        os.close(pipe)
+
+
diff --git a/windows/fuzzbunch/edfmeta.py b/windows/fuzzbunch/edfmeta.py
new file mode 100644
index 0000000..b88a59d
--- /dev/null
+++ b/windows/fuzzbunch/edfmeta.py
@@ -0,0 +1,276 @@
+"""
+
+XML Parsing routines outside of what TRCH handles.
+
+This is primarily meant to deal with the .fb files
+
+
+NOTE: Values pulled from XML are 'unicode' by default. The rest of FB prefers
+'str' types.
+
+"""
+from xml.etree import ElementTree
+import xml.dom.minidom
+import util
+import xml.parsers.expat as expat
+import exception
+import re
+
+
+__all__ = ['parse_consolemode',
+           'parse_touchlist',
+           'parse_redirection',
+           'parse_iparamorder',
+           'get_elements']
+
+
+def get_elements(xmlDoc, tag):
+    try:
+        elements = xmlDoc.getElementsByTagName(tag)
+        if len(elements) == 0:
+            elements = xmlDoc.getElementsByTagName("t:"+tag)
+        return elements
+    except:
+        return []
+
+def parse_consolemode(xmlFile):
+    """
+    Console mode
+
+    INPUT
+    -----
+
+    The consolemode is in a plugin's meta file. The consolemode is optional and
+    only used to override the default.
+
+        <t:consolemode value="desired_mode" />
+
+    Valid consolemodes are found in the plugin manager.
+
+    OUTPUT
+    ------
+
+    A Python string.  The value of the 'value' attribute is returned as a
+    string.
+
+    """
+    
+    try:
+        xmlDocument = xml.dom.minidom.parse(xmlFile)
+        elem = get_elements(xmlDocument, "consolemode")[0]          # Fix to Bug #574
+        #elem = xmlDocument.getElementsByTagName("t:consolemode")[0]
+        return str(elem.getAttribute("value"))
+    except IndexError:
+        return ""
+    return ""
+    
+def parse_touchlist(xmlFile):
+    """
+    Touch lists
+
+
+    INPUT
+    -----
+
+    Touch lists are in a plugin's meta file.  Touch lists are optional.
+
+        <t:touchlist>
+            <t:plugin name="TouchPluginName"
+                      displayname="How to display in fb"
+                      description="Descr for fb">
+
+                <t:iparam name="Param1" value="val" />
+                <t:oparam name="Param1" value="ParamFoo" />
+            </t:plugin>
+        </t:touchlist>
+
+
+    plugin - any number of plugin sections. One for each touch.
+    iparam - Parameters that should be autoset when running the touch
+    ivparam - Parameters that should be autoset based on parent plugins vars 
+    oparam - Parameter map of touch output to host plugin
+
+
+    OUTPUT
+    ------
+
+    Python list of dictionaries
+
+        touchlist = [touch1, touch2, ..., touchN]
+
+        Each touch is a dictionary composed of the plugin attributes.  A parameters
+        key has a dictionary of autoset parameters.
+
+        Example:
+
+        touch1 = {
+                  'name'        : 'SSLTouch',
+                  'displayname' : 'Check for SSL',
+                  'description' : 'Checks the target for SSL',
+                  'parameters'  : {'TargetPort' : 443}
+                 }
+    """
+    try:
+        xmlDocument = xml.dom.minidom.parse(xmlFile)
+        tlist = get_elements(xmlDocument, "touchlist")[0]       # Fix to bug #574
+    except expat.ExpatError:
+        # The XML failed to parse correctly
+        import os.path
+        (p, f) = os.path.split(xmlFile)
+        raise exception.PluginMetaErr("Error parsing '%s' XML.  Touches not configured" % (f))
+        return []
+    except IndexError:
+        # We didn't successfully get anything from "t:touchlist" Don't print here because some
+        # things actually don't specify touches
+        #return []
+        raise
+
+    touchlist = []
+
+    for plugin in get_elements(tlist, "plugin"):        # Fix for bug #574 
+        touch = {"name"        : str(plugin.getAttribute("name")),
+                 "displayname" : str(plugin.getAttribute("displayname")),
+                 "description" : str(plugin.getAttribute("description")),
+                 "postmsg"     : str(plugin.getAttribute("postmessage")),
+                 "iparams"     : util.iDict(), 
+                 "ivparams"    : util.iDict(),
+                 "oparams"     : util.iDict()}
+        for p in get_elements(plugin, "iparam"):   # Fix for bug #574    #plugin.getElementsByTagName("t:iparam"):
+            touch["iparams"][str(p.getAttribute("name"))] = str(p.getAttribute("value"))
+        for p in get_elements(plugin, "ivparam"):  # Fix for bug #574    #plugin.getElementsByTagName("t:ivparam"):
+            touch["ivparams"][str(p.getAttribute("name"))] = str(p.getAttribute("value"))
+        for p in get_elements(plugin, "oparam"):   # Fix for bug #574    #plugin.getElementsByTagName("t:oparam"):
+            touch["oparams"][str(p.getAttribute("name"))] = str(p.getAttribute("value"))
+
+        touchlist.append(touch)
+    return touchlist
+
+
+def parse_redirection(xmlFile):
+    """
+    Redirection
+
+
+    INPUT
+    -----
+
+    Redirection sections are in a plugin's standard XML file.  See the truantchild
+    schema for details.
+
+
+    OUTPUT
+    ------
+
+    Python dictionary of lists of dictionaries
+
+        There are 2 types of redirection, remote and local.  Each section can have
+        multiple channels. Each channel is represented as a dictionary.
+        
+        redir = {
+                 'local' : 
+                    [ { ..local params..}, ... ],
+                 'remote' :
+                    [ { ..remote params..}, ... ]
+                }
+    """
+    def nsstrip(tag):
+        for x in ('{tc0}', '{urn:trch}', 't:'):
+            if tag.startswith(x):
+                return tag.split(x)[1]
+        else:
+            return tag
+
+    def get_redirection(config):
+        for child in config:
+            tag = nsstrip(child.tag)
+            if tag == 'redirection':
+                return child
+        return None
+
+    def get_remote_redir(node):
+        if not node:
+            return []
+        return [child for child in node
+                      if nsstrip(child.tag) == 'remote']
+
+    def get_local_redir(node):
+        if not node:
+            return []
+        return [child for child in node
+                      if nsstrip(child.tag) == 'local']
+
+    xmldoc = ElementTree.parse(xmlFile)
+    config = xmldoc.getroot()
+    redir = get_redirection(config)         # Redirection section of the plug-in XML
+
+    remote = get_remote_redir(redir)        # remote tags in the plug-in redirection section
+    local = get_local_redir(redir)          # local tags in the plug-in redirection section
+
+    redirection = { 'remote' : [x.attrib for x in remote],
+                    'local'  : [x.attrib for x in local] }
+    
+    # Insert a fix for XPath identifiers in redirection sections.
+    # These shouldn't be here, but this fixes everything for now...
+    for tunnel in redirection['remote'] + redirection['local']:
+        for k,v in tunnel.items():
+            if v.lower() == '//identifier':
+                tunnel[k] = 'TargetIp'
+            elif re.match(r'//service\[name=.*\]/port', v.lower()):
+                tunnel[k] = 'TargetPort'
+
+    return redirection
+
+
+def parse_iparamorder(xmlFile):
+    """
+    Input Parameter Order
+
+    INPUT
+    -----
+
+    Plugin's standard XML file.
+
+    OUTPUT
+    ------
+
+    List of parameter names in display order
+    """
+
+    xmlDocument = xml.dom.minidom.parse(xmlFile)
+
+    try:
+        #iparams = xmlDocument.getElementsByTagName("t:inputparameters")[0]
+        iparams = get_elements(xmlDocument, "inputparameters")[0]       # Fix to bug #574
+    except IndexError:
+        return []
+
+    order = []
+    #for param in (iparams.getElementsByTagName("t:parameter") + 
+    #              iparams.getElementsByTagName("t:paramchoice")):
+    # Fix for bug #574
+    for param in (get_elements(iparams, "parameter") +
+                  get_elements(iparams, "paramchoice")):
+        order.append(str(param.getAttribute("name")))
+
+    return order
+
+def parse_forward(xmlFile):
+    """
+    Forward-deployment (i.e., DARINGVETERAN/DARINGNEOPHYTE) DLL Configuration
+    
+    INPUT
+    -----
+    Path to plugin's standard FB file.
+    
+    OUTPUT
+    ------
+    Dictionary mapping archOs tag (e.g., "x86-Windows") to a tuple containing
+    plugin proxy and core DLLs.  Note that either element may be None!
+    """
+    xmldoc = ElementTree.parse(xmlFile)
+    arches = {}
+    for arch in xmldoc.findall("package/arch"):
+        proxy = getattr(arch.find('base'), 'text', None)
+        core = getattr(arch.find('core'), 'text', None)
+        arches[arch.get('name')] = (proxy, core)
+    return arches
diff --git a/windows/fuzzbunch/edfplugin.py b/windows/fuzzbunch/edfplugin.py
new file mode 100644
index 0000000..92e390c
--- /dev/null
+++ b/windows/fuzzbunch/edfplugin.py
@@ -0,0 +1,360 @@
+import hashlib
+import os
+import threading
+
+import edfexecution
+import exception
+from plugin       import Plugin
+from redirection  import LocalRedirection, RemoteRedirection
+import util
+
+import truantchild
+from pytrch import TrchError
+
+import edfmeta
+import xml.parsers.expat as expat
+
+
+__all__ = ["EDFPlugin"]
+
+class EDFPlugin(Plugin):
+    def __init__(self, files, io):
+        try:
+            Plugin.__init__(self, files, io)
+            self.metaconfig = files[2]
+            self.initTouches()
+            self.initRedirection()
+            self.initConsoleMode()
+        except TrchError:
+            # There was an error parsing the plug-in XML
+            raise
+        except IndexError:
+            # We didn't get the right number of files
+            raise
+        self.procs = []
+            
+    def getMetaHash(self):
+        return "%s %s %s" % (hashlib.sha1(open(self.metaconfig, 'rb').read()).hexdigest(),
+                                      os.lstat(self.metaconfig).st_size,
+                                      os.path.basename(self.metaconfig))
+ 
+
+    def killPlugin(self):
+        """Helper function for forceful termination of the plugin executable,
+        primarily used for testing
+        """
+        for p in self.procs:
+            p.kill()
+        self.procs = []
+
+
+    def write_interpreted_xml_file(self, inConfFile, globalvars={}):
+        """Rewrite the inconfig, substituting variables"""
+        tmpFile = open(inConfFile, "w");
+
+        # Note: Truantchild has been used to this point to store parameters, so 
+        # the inconfig here represents all of the prompted data
+        configdata = self.getMarshalledInConfig()
+        configlines = configdata.split("\n")
+        newlines = []
+        for line in configlines:
+            newlines.append(util.variable_replace(line, globalvars))
+        newconfig = "\n".join(newlines)
+        tmpFile.write(newconfig)
+        tmpFile.close()
+        return inConfFile
+
+    """
+    Plugin validation routine
+
+    """
+    def validate(self, dirs, globalvars={}):
+        baseDir, logDir = dirs
+        timestamp = util.formattime()
+        exeBaseName = os.path.basename(self.executable)
+
+        logName = "%s-%s.log" % (exeBaseName, timestamp)
+        logFile = os.path.join(logDir, logName)
+        try:
+            os.remove(logFile)
+        except:
+            pass
+
+        inConfName = "%s-%s-InConfig.validate.xml" % (exeBaseName, timestamp)
+        inConfFile = os.path.join(logDir, inConfName)
+        self.write_interpreted_xml_file(inConfFile, globalvars=globalvars)
+
+        if edfexecution.validate_plugin(self.executable, inConfFile, self.io) == 0:
+            return True
+        else:
+            return False
+    
+    """
+    Plugin execution routine
+
+    """
+    def execute(self, session, consolemode, interactive, scripted, globalvars={}, runMode=''):
+        self.lastsession = session
+        baseDir, logDir = session.get_dirs()
+        waitmode, newconsole = self.get_runflags(consolemode, interactive, scripted)
+
+        # save history
+        session.history = self.getParameters()
+
+        timestamp = util.formattime()
+        exeBaseName = os.path.basename(self.executable)
+
+        logName = "%s-%s.log" % (exeBaseName, timestamp)
+        logFile = os.path.join(logDir, logName)
+        try:
+            os.remove(logFile)
+        except:
+            pass
+
+        # Touch the logfile
+        tmpFile = open(logFile, "w")
+        tmpFile.close()
+
+        # Create InConfig and write to the logdir
+        inConfName = "%s-%s-InConfig.xml" % (exeBaseName, timestamp)
+        inConfFile = os.path.join(logDir, inConfName)
+        self.write_interpreted_xml_file(inConfFile, globalvars=globalvars)
+
+        # Create the pipe that we will use for the --OutConfig parameter
+        pipeName = edfexecution.generate_pipename()
+        pipe = edfexecution.create_pipe(pipeName)
+
+        cwd = os.getcwd() 
+        os.chdir(logDir)
+        try:
+            #
+            # This is the sneaky bit for the output.  We call launch_plugin, 
+            # which does two things.  First, it passes stdin,stdout, and stderr
+            # to the call to subprocess.Popen so that output is duplicated to
+            # the console.  Second, it passes --OutConfig a pipe so that, when we
+            # later call write_outconfig, this contains only the data we want
+            #
+            proc = edfexecution.launch_plugin(self.executable, inConfFile, 
+                                      pipeName, logFile, self.io, newconsole)
+            self.procs.append(proc)
+        except KeyboardInterrupt:
+            self.io.print_error("Stopping plugin")
+            try:
+                self.procs.remove(proc)
+                proc.kill()
+            except:
+                pass
+            # Create the output param for the contract
+            session.contract = [util.oParam("Status", "Failed", "String", "Scalar"), 
+                                util.oParam("ReturnCode", "User Abort", "String", "Scalar")]
+            session.mark_fail()
+            raise exception.CmdErr, "Canceled by User"
+            
+        os.chdir(cwd)
+
+        try:
+            # Wait for the spawned process to connect to our named pipe
+            pipe = edfexecution.connect_pipe(pipe, pipeName)
+        except edfexecution.PipeError, err:
+            self.io.print_error(str(err))
+            pipe = None
+
+        if pipe == None:
+            try:
+                # Try to kill the process
+                self.procs.remove(proc)
+                proc.kill()
+            except:
+                pass
+            try:
+                # See if the process has terminated
+                proc.poll()
+            except:
+                pass
+            # Create the output param for the contract
+            session.contract = [util.oParam("Status", "Failed", "String", "Scalar"),
+                                util.oParam("ReturnCode", str(proc.returncode), "String", "Scalar")]
+            session.mark_fail()
+            raise exception.CmdErr, "Error Connecting Pipe to Plugin"
+
+        # Create OutConfig file name
+        outConfName = "%s-%s-OutConfig.xml" % (exeBaseName, timestamp)
+        outConfFile = os.path.join(logDir, outConfName)
+
+        if waitmode:
+            # Wait for the plugin to finish.  So, we don't have overlapping 
+            # output or problems waiting for the outconfig
+            self.get_outconfig(pipe, session, outConfFile, proc)
+        else:
+            # Creates a new thread to read output config from the executed plugin.  
+            pluginThread = threading.Thread(None, 
+                                  self.get_outconfig,
+                                  None,
+                                  (pipe, session, outConfFile, proc))
+            pluginThread.start()
+        return newconsole, logFile 
+
+    """
+    Output XML handling
+
+    """
+    def get_outconfig(self, pipe, session, outConfName, proc):
+        try:
+            # Read from the named pipe we passed to launch_plugin and 
+            # write to file
+            edfexecution.write_outconfig(outConfName, pipe)
+        except KeyboardInterrupt:
+            self.io.print_error("Canceled by User")
+            self.io.print_error("Stopping plugin")
+            try:
+                proc.kill()
+            except:
+                pass
+        finally:
+            # XXX - Remove_pipe too?
+            edfexecution.close_pipe(pipe)
+        try:
+            #name   = self.getName()
+            params = self.read_outxml(outConfName)
+            params.append(util.oParam("Status", "Success", "String", "Scalar"))
+            if len(params) > 1:
+                session.mark_ready()
+            else:
+                session.mark_used()
+        except (ValueError, TrchError, AttributeError) as e:
+            # We get here if the following conditions happen:
+            #  Argument errors to any calls
+            #  Plug-in failed and didn't actually write an outconfig
+            #  Output created an invalid XML configuration
+            #self.io.print_warning("Output XML error: It's either empty or does not parse: %s" % (e))
+            self.io.print_warning("Plugin failed")
+            proc.wait()
+            params = [util.oParam("Status", "Failed", "String", "Scalar"),
+                      util.oParam("ReturnCode", str(proc.returncode), "String", "Scalar")]
+            session.mark_fail()
+        session.contract = params
+
+    def read_outxml(self, filename):
+        try:
+            return truantchild.Config((filename, self.executable))._outputParams.getParameterListExt()
+        except:
+            pass
+
+    """
+    Session info description generation
+
+    """
+    def getSessionDescription(self):
+        descr = [""]
+        if self.redirection:
+            redir = self.getRedirection()
+            descr = []
+            for l in redir['local']:
+                try:
+                    descr.append( self.get(l.listenaddr) )
+                except exception.CmdErr:
+                    # The tunnel is invalid because the parameter is not in scope.  Ignore the tunnel
+                    pass
+        return " ".join(descr)
+
+    """
+    Rendezvous
+
+    """
+    def doRendezvous(self, value):
+        self._trch_addrendezvousparam(value)
+
+    """
+    Run Mode
+
+    """
+    def initConsoleMode(self):
+        if self.metaconfig:
+            try:
+                mode = edfmeta.parse_consolemode(self.metaconfig)
+                self.consolemode = util.convert_consolemode(mode)
+            except expat.ExpatError:
+                # Pass here because we printed something while parsing the
+                # invalid file, but we want execution to continue
+               pass
+        else:
+            Plugin.initConsoleMode(self)
+
+    def get_runflags(self, mode, interactive, scripted):
+        """
+        
+        Return the following boolean flags:
+
+            newconsole - the plugin should execute in a new console
+            waitmode   - Execution should wait for the plugin to finish
+                         executing
+        """
+        if interactive:
+            if not mode:
+                # Use the plugin's settings
+                mode = self.getConsoleMode()
+        else:
+            # Non-interactive mode must reuse the console
+            mode = util.CONSOLE_REUSE
+
+        if mode == util.CONSOLE_REUSE:
+            # Reusing implies no new console
+            newconsole = False
+        else:
+            newconsole = True
+
+        waitmode = True
+        # If non-scripted, interactive sessions that launch new consoles don't
+        # need to wait for plugins to finish.  All other permutations do.
+        if interactive and not scripted and newconsole:
+            waitmode = False
+        return (waitmode,newconsole)
+
+    """
+    Redirection
+
+    """
+    def initRedirection(self):
+        redir = None
+        try:
+            redir = edfmeta.parse_redirection(self.xmlInConfig)
+        except expat.ExpatError:
+            self.io.print_error("Error parsing redirection information")
+
+        # XXX - What should we do if we fail to parse redirection?
+        counter = 1
+        for r in redir['remote']:
+            if 'name' not in r:
+                r['name'] = 'remote-tunnel-%d' % counter
+                counter += 1
+        counter = 1
+        for r in redir['local']:
+            if 'name' not in r:
+                r['name'] = 'local-tunnel-%d' % counter
+                counter += 1
+
+        self.redirection = {
+                'remote' : [RemoteRedirection(**r) for r in redir['remote']],
+                'local'  : [LocalRedirection(**l)  for l in redir['local']]
+                }
+
+    """
+    Touches
+
+    """
+    def initTouches(self):
+        if self.metaconfig:
+            try:
+                self.touchlist = edfmeta.parse_touchlist(self.metaconfig)
+            except exception.PluginMetaErr:
+                import os.path
+                (p,f) = os.path.split(self.metaconfig)
+                n = f.split('-')[0]
+                self.io.pre_input(None)
+                self.io.print_warning("Error in %s meta (.fb) file - touches not loaded " % (str(n)))
+                self.io.post_input()
+                Plugin.initTouches(self)
+            except IndexError:
+                Plugin.initTouches(self)
+        else:
+            Plugin.initTouches(self)
diff --git a/windows/fuzzbunch/env.py b/windows/fuzzbunch/env.py
new file mode 100644
index 0000000..f067dfa
--- /dev/null
+++ b/windows/fuzzbunch/env.py
@@ -0,0 +1,59 @@
+"""
+Support routines for intelligently determining Fuzzbunch's operating environment
+and setting some global variables
+"""
+
+import sys
+import os
+
+__all__ = ['setup_core_paths', 'setup_lib_paths']
+
+SUPPORTED_ARCH = {
+    'win32':            'x86-Windows',
+    'linux2-i686':      'i686-Linux',
+    'linux2-x86_64':    'x86_64-Linux',
+    'solaris':          'sparc-SunOS'
+}
+
+try:
+    platform = sys.platform
+    if sys.platform == 'linux2':
+        platform = sys.platform + "-" + os.uname()[4]
+    arch = SUPPORTED_ARCH[platform]
+except KeyError:
+    print "You are running on an unsuported architecture!"
+    sys.exit(-1)
+
+"""
+Set up core paths
+
+"""
+def setup_core_paths( fbdir ):
+    global FB_FILE
+    global FB_DIR
+    global EDFLIB_DIR
+    FB_FILE = os.path.realpath(fbdir)
+    FB_DIR  = os.path.dirname(FB_FILE)
+    EDFLIB_DIR = os.path.join(FB_DIR, "lib", arch)
+    os.environ['PATH'] = EDFLIB_DIR + os.pathsep + os.environ['PATH']   # The EDF libs should always come FIRST in the system PATH...
+    os.environ['FBDIR'] = FB_DIR
+    sys.path.append(os.path.join(FB_DIR, 'fuzzbunch'))
+    sys.path.append(EDFLIB_DIR)
+    return (FB_FILE, FB_DIR, EDFLIB_DIR)
+
+def setup_lib_paths(fbdir, libdir):
+    """This is a little bit of a hack, but it should work. If we detect that the EDFLIB_DIR is 
+    not in LD_LIBRARY_PATH, restart after adding it.  
+    """
+    try:
+        libpath = os.environ['LD_LIBRARY_PATH']
+    except KeyError:
+        libpath = ""
+    if not (sys.platform == "win32") and (libdir not in libpath):
+        # To get the Fuzzbunch environment setup properly, we need to modify LD_LIBRARY_PATH.
+        # To do that, we need to rerun Fuzzbunch so that it picks up the new LD_LIBRARY_PATH
+        os.environ['LD_LIBRARY_PATH'] = "%s:%s" % (libdir,libpath)
+        #path = os.path.abspath(fbdir)
+        #args = ['"' + path + '"'] + sys.argv[1:]
+        #os.execvpe( 'python', ['python']+sys.argv, os.environ)
+ 
diff --git a/windows/fuzzbunch/exception.py b/windows/fuzzbunch/exception.py
new file mode 100644
index 0000000..abf0b22
--- /dev/null
+++ b/windows/fuzzbunch/exception.py
@@ -0,0 +1,82 @@
+"""
+Exception handling classes.
+"""
+import sys
+
+__all__ = [
+            "CmdErr", 
+            "PromptErr", 
+            "PromptHelp", 
+            "Interpreter", 
+            "PluginXmlErr", 
+            "PluginMetaErr",
+            "exceptionwrapped"]
+
+class CmdErr(Exception):
+    """CmdErr covers command error conditions."""
+    def __init__(self, error):
+        self.error = str(error)
+        self.prefix = "Error:"
+
+    def getErr(self):
+        return "%s %s" % (self.prefix, self.error)
+
+class PromptErr(CmdErr):
+    """PromptErr covers prompt error conditions."""
+    def __init__(self, error):
+        CmdErr.__init__(self, error)
+        self.prefix = "Prompt Error:"
+
+class PromptHelp(CmdErr):
+    """PromptHelp covers prompt help conditions."""
+    def __init__(self, error):
+        CmdErr.__init__(self, error)
+        self.prefix = "Prompt Help:"
+
+class Interpreter(Exception):
+    """Interpreter covers dropping control to the
+       python interactive prompt. 
+    """
+    def __init__(self):
+        self.prefix = "Dropping to Interpreter"
+
+    def getErr(self):
+        return "%s" % self.prefix
+
+class PluginXmlErr(CmdErr):
+    """Pluginfinder error when trying to load
+       EDF plugins
+    """
+    def __init__(self, error):
+        CmdErr.__init__(self, error)
+        self.prefix = "Loader Error:"
+
+class PluginMetaErr(CmdErr):
+    def __init__(self, error):
+        CmdErr.__init__(self, error)
+        self.prefix = "Touch XML Error:"
+
+def exceptionwrapped(fn):
+    """This is a decorator meant to be a catch-all wrapper for exceptions, 
+    providing the user with instructions as to what to do in the event of an 
+    unrecoverable failure.
+    """
+    def wrap(*args, **kwargs):
+        try:
+            ret = fn(*args, **kwargs)
+            return ret
+        except SystemExit:
+            return None
+        except:
+            import traceback
+            stacktrace = traceback.format_exc()
+            print >>sys.stderr, "==============================================================="
+            print >>sys.stderr, "="
+            print >>sys.stderr, "= Encountered an unhandled error.  Please provide the following"
+            print >>sys.stderr, "= information to the developer"
+            print >>sys.stderr, "= "
+            print >>sys.stderr, "==============================================================="
+            print >>sys.stderr, "%s" % (stacktrace) 
+            return None
+    wrap.__doc__ = fn.__doc__
+    return wrap
diff --git a/windows/fuzzbunch/exma.py b/windows/fuzzbunch/exma.py
new file mode 100644
index 0000000..ccb84ed
--- /dev/null
+++ b/windows/fuzzbunch/exma.py
@@ -0,0 +1,74 @@
+"""
+Python Ctypes wrapper for EXPLOITMANAGER.  No additional levels of abstraction
+added.  Interface using ctypes types and variables.
+
+Notes: Incomplete. Only import/export XML file functions have been defined
+"""
+
+#from ctypes import *
+import ctypes
+import sys
+
+mswindows = (sys.platform == "win32")
+
+_libraries = {}
+
+if mswindows:
+    _libraries['exma.dll'] = ctypes.CDLL('exma-1.dll')
+else:
+    _libraries['exma.dll'] = ctypes.CDLL('libexma.so.1')
+
+
+STRING = ctypes.c_char_p
+SOCKET = ctypes.c_uint 
+
+getDefaultEMFile = _libraries['exma.dll'].getDefaultEMFile
+getDefaultEMFile.restyp   = STRING
+getDefaultEMFile.argtypes = []
+
+readParamsFromEM = _libraries['exma.dll'].readParamsFromEM
+readParamsFromEM.restype  = STRING
+readParamsFromEM.argtypes = [STRING]
+
+writeParamsToEM = _libraries['exma.dll'].writeParamsToEM
+writeParamsToEM.restype  = ctypes.c_int
+writeParamsToEM.argtypes = [STRING, STRING]
+
+bindRendezvous = _libraries['exma.dll'].bindRendezvous
+bindRendezvous.restype  = ctypes.c_int
+bindRendezvous.argtypes = [ctypes.POINTER(ctypes.c_ushort), ctypes.POINTER(SOCKET)]
+
+sendSockets = _libraries['exma.dll'].sendSockets
+sendSockets.restype  = ctypes.c_int
+sendSockets.argtypes = [SOCKET]
+
+closeRendezvous = _libraries['exma.dll'].closeRendezvous
+closeRendezvous.restype  = ctypes.c_int
+closeRendezvous.argtypes = [ctypes.c_ushort, SOCKET]
+
+connectRendezvous = _libraries['exma.dll'].connectRendezvous
+connectRendezvous.restype  = ctypes.c_int
+connectRendezvous.argtypes = [ctypes.c_ushort, ctypes.POINTER(SOCKET)]
+
+recvSocket = _libraries['exma.dll'].recvSocket
+recvSocket.restype  = ctypes.c_int
+recvSocket.argtypes = [SOCKET, SOCKET, ctypes.POINTER(SOCKET)]
+
+disconnectRendezvous = _libraries['exma.dll'].disconnectRendezvous
+disconnectRendezvous.restype  = ctypes.c_int
+disconnectRendezvous.argtypes = [SOCKET]
+
+writeParamsToEM = _libraries['exma.dll'].writeParamsToEM
+writeParamsToEM.restype = ctypes.c_int
+writeParamsToEM.argtypes = [ctypes.c_int, STRING]
+
+openEMForWriting = _libraries['exma.dll'].openEMForWriting
+openEMForWriting.restype = ctypes.c_int
+openEMForWriting.argtypes = [STRING]
+
+
+__all__ = ['getDefaultEMFile', 'readParamsFromEM', 'writeParamsToEM',
+           'bindRendezvous', 'sendSockets', 'closeRendezvous',
+           'connectRendezvous', 'recvSocket', 'disconnectRendezvous',
+		   'writeParamsToEM', 'openEMForWriting']
+
diff --git a/windows/fuzzbunch/figlet.py b/windows/fuzzbunch/figlet.py
new file mode 100644
index 0000000..4a24473
--- /dev/null
+++ b/windows/fuzzbunch/figlet.py
@@ -0,0 +1,250 @@
+"""
+Port of the C figlet driver to Python.  Ugly, gross, not fully working, but
+does what I need to display a simple banner with a hand selected set of fonts.
+"""
+import sys
+import os
+import random
+
+__all__ = ['newbanner']
+
+def newbanner(fontdir, msg):
+    """
+    Returns msg converted to a random ascii art font from the given
+    fontdir.
+    """
+    try:
+        font = get_randfont(fontdir)
+        if not font:
+            return "", ""
+        f = Fig(font)
+        f.addline(msg)
+    except:
+        return "", ""
+
+    return f.getline(),font
+
+def get_randfont(fontdir):
+    fonts = get_fontdirlist(fontdir)
+    if not fonts:
+        return None
+    index = random.randint(0, len(fonts) - 1)
+    return fonts[index]
+
+def get_fontdirlist(fontdir='fonts'):
+    fonts = [fontdir + os.path.sep + item 
+             for item in os.listdir(fontdir) 
+             if item.endswith(".flf")]
+    return fonts
+
+class Fig:
+    hdr = {}
+    def __init__(self, fontfile=None):
+        if fontfile:
+            self.init_fonts(fontfile)
+        self.clearline()
+
+
+    """
+    Font File parsing
+    """
+    def init_fonts(self, fontfile=None):
+        if fontfile:
+            self.fontfile = fontfile
+        file = open(self.fontfile)
+        self.parse_header(file.readline().split())
+        self.parse_comments(file)
+        self.parse_chars(file)
+        file.close()
+
+    def parse_header(self, header):
+        self.hdr['signature']    = header[0][:-1]
+        self.hdr['hardblank']    = header[0][-1]
+        self.hdr['height']       = int(header[1])
+        self.hdr['baseline']     = header[2]
+        self.hdr['maxlength']    = int(header[3])
+        self.hdr['oldlayout']    = header[4]
+        self.hdr['commentlines'] = int(header[5])
+        try:
+            self.hdr['printdir']     = header[6]
+            self.hdr['fulllayout']   = header[7]
+            self.hdr['codetagcount'] = header[8]
+        except:
+            self.hdr['printdir']     = ""
+            self.hdr['fulllayout']   = ""
+            self.hdr['codetagcount'] = ""
+        if self.hdr['signature'] != "flf2a":
+            self.hdr = {}
+            return False
+        return True
+
+    def parse_comments(self, file):
+        for i in range(0, self.hdr['commentlines']):
+            line = file.readline()
+            del line
+
+    def parse_chars(self, file):    
+        self.chars = {}
+        for c in range(32,127):
+            self.chars[chr(c)] = []
+            for i in range(0, self.hdr['height']):
+                self.chars[chr(c)].append(list(file.readline().rstrip("@#\r\n")))
+
+    def getletter(self, c):
+        self.previouscharwidth = self.currcharwidth
+        self.currcharwidth = len(self.chars[c][0])
+        return self.chars[c]
+
+    def len_letter(self, letter):
+        return len(letter[0])
+
+    """
+    Input Handling
+    """
+    def smushmem(self, ch1, ch2):
+        special = "|/\\[]{}()<>"
+        if ch1 == ' ':
+            return ch2
+        if ch2 == ' ':
+            return ch1
+        if self.previouscharwidth < 2 or self.currcharwidth < 2:
+            return '\0'
+        if ch1 == self.hdr['hardblank'] or ch2 == self.hdr['hardblank']:
+            return '\0'
+        if ch1 == ch2:
+            return ch1
+        if ch1 == '_' and ch2 in special:
+            return ch2
+        if ch2 == '_' and ch1 in special:
+            return ch1
+        if ch1 == "|" and ch2 in special[1:]:
+            return ch2
+        if ch2 == "|" and ch1 in special[1:]:
+            return ch1
+        if ch1 in "/\\" and ch2 in special[3:]:
+            return ch2
+        if ch2 in "/\\" and ch1 in special[3:]:
+            return ch1
+        if ch1 in "[]" and ch2 in special[5:]:
+            return ch2
+        if ch2 in "[]" and ch1 in special[5:]:
+            return ch1
+        if ch1 in "{}" and ch2 in special[7:]:
+            return ch2
+        if ch2 in "{}" and ch1 in special[7:]:
+            return ch1
+        if ch1 in "()" and ch2 in special[9:]:
+            return ch2
+        if ch2 in "()" and ch1 in special[9:]:
+            return ch1
+        if ch1 == '[' and ch2 == ']':
+            return '|'
+        if ch1 == ']' and ch2 == '[':
+            return '|'
+        if ch1 == '{' and ch2 == '}':
+            return '|'
+        if ch1 == '}' and ch2 == '{':
+            return '|'
+        if ch1 == '(' and ch2 == ')':
+            return '|'
+        if ch1 == ')' and ch2 == '(':
+            return '|'
+
+        return '\0'
+
+    def get_smushamount(self, l):
+        max_smush = self.currcharwidth
+        for row in range(0, self.hdr['height']):
+            linebd = len(self.line[row])
+            ch1 = ' '
+            while linebd > 0 and ch1 == ' ':
+                try:
+                    ch1 = self.line[row][linebd]
+                except IndexError:
+                    ch1 = ' '
+                if ch1 != ' ':
+                    break
+                linebd = linebd - 1
+
+            try:
+                charbd = 0
+                ch2 = ' '
+                while ch2 == ' ':
+                    ch2 = l[row][charbd]
+                    if ch2 != ' ':
+                        break
+                    charbd = charbd + 1
+            except IndexError:
+                ch2 = None
+
+            amt = charbd + self.outlinelen - 1 - linebd
+            if ch1 == None or ch1 == ' ':
+                amt = amt + 1
+            elif ch2 != None:
+                if self.smushmem(ch1, ch2) != '\0':
+                    amt = amt + 1
+            if amt < max_smush:
+                max_smush = amt
+        return max_smush                
+
+    def addchar(self, c):
+        letter = self.getletter(c)
+        smush_amount = self.get_smushamount(letter)
+        for row in range(0, self.hdr['height']):
+            for k in range(0, smush_amount):
+                if self.outlinelen - smush_amount + k >= 0:
+                    ch1 = self.line[row][self.outlinelen-smush_amount+k]
+                    ch2 = letter[row][k]
+                    self.line[row][self.outlinelen-smush_amount+k] = self.smushmem(ch1, ch2)
+            self.line[row] += letter[row][smush_amount:]
+        self.outlinelen = len(self.line[0])
+
+    def addline(self, line):
+        for c in line: self.addchar(c)
+
+    """
+    Output handling
+
+    """
+    def clearline(self):
+        self.line = []
+        for i in range(0,self.hdr['height']):
+            self.line.append([])
+        self.previouscharwidth = 0
+        self.currcharwidth = 0
+        self.outlinelen = 0
+            
+
+    def getstring(self, i):
+        return ''.join(self.line[i]).replace(self.hdr['hardblank'], ' ')
+
+    def getline(self):
+        lines = []
+        for i in range(0, self.hdr['height']):
+            lines.append(self.getstring(i))
+        self.clearline()
+        return '\n'.join(lines)
+
+    def putstring(self, i):
+        print ''.join(self.line[i]).replace(self.hdr['hardblank'], ' ')
+
+    def printline(self):
+        for i in range(0, self.hdr['height']):
+            self.putstring(i)
+        self.clearline()
+        
+
+if __name__ == "__main__":
+    if len(sys.argv) < 3:
+        print "usage: %s [phrase] [fontdir]" % sys.argv[0]
+        sys.exit(-1)
+
+    fontdir = sys.argv[2]
+    fonts = get_fontdirlist(fontdir)
+    index = random.randint(0, len(fonts) - 1)
+    for font in fonts:
+        print "FONT: ", font
+        f = Fig(font)
+        f.addline(sys.argv[1])
+        f.printline()
+
diff --git a/windows/fuzzbunch/fuzzbunch.py b/windows/fuzzbunch/fuzzbunch.py
new file mode 100644
index 0000000..49d92d4
--- /dev/null
+++ b/windows/fuzzbunch/fuzzbunch.py
@@ -0,0 +1,995 @@
+"""
+Fuzzbunch command shell.  
+
+- Implements (or inherits from FbCmd class) all core fuzzbunch commands.
+- Support for Modules (plugin managers)
+
+Modules add additional commands and operate in their own context
+
+"""
+import os
+from command     import FbCmd
+import exception
+import redirection
+import session
+import util
+import figlet
+import edfmeta
+from log import log
+__all__ = ['Fuzzbunch']
+
+GVAR_CHAR = '$'
+class Fuzzbunch(FbCmd):
+    """
+    Fuzzbunch, in and of itself, is an execution environment.  It provides a set of
+    commands and contexts to interact with.
+
+    The Fuzzbunch class is really an extension of the FbCmd class, which allows it to add
+    additional, context-specific commands to the general command line handling.  The base
+    set of commands it adds to the FbCmd class are:
+    * autorun
+    * banner
+    * back
+    * enter
+    * exit
+    * mark
+    * redirect
+    * retarget
+    * session
+    * setg
+    * show
+    * standardop
+    * toolpaste
+    * unsetg
+    * use
+
+    For information regarding these commands, please run Fuzzbunch and type 'help <cmd>' at
+    the command prompt.
+
+    """
+    def __init__(self, 
+                 configfile,
+                 base_dir, 
+                 log_dir, 
+                 stdin=None,
+                 stdout=None,
+                 stderr=None):
+        """@brief   Initialize the Fuzzbunch object
+
+        @param      configfile      The main Fuzzbunch configuration file (an XML file)
+        @param      base_dir        
+        @param      log_dir         Location for Fuzzbunch log files
+        @param      stdin           
+        @param      stdout          
+        @param      stderr          
+        """
+
+        # Initialize the command interpreter, which creates a CmdCtx
+        self.configvars = {}                    # Stores global config info (not setg globals)
+        self.readconfig(configfile)             # Read in variables set for Fuzzbunch
+
+        # Fix bug #2910 - Color breaks in some terminals that don't support ansi encoding.  Added
+        # option to disable color
+        enablecolor = eval(self.configvars['globals']['Color'])
+        FbCmd.__init__(self, stdin=stdin, stdout=stdout, stderr=stderr, enablecolor=enablecolor )
+
+        # Set the info function to Fuzzbunch's print_info function
+        self.defaultcontext.print_info = self.print_info
+        self.preconfig()
+
+        self.fbglobalvars   = util.iDict()      # Our Fuzzbunch global variables
+        self.pluginmanagers = util.iDict()      # A list of PluginManagers, each
+                                                # of which contains a list of Plugins.
+
+        # Create our Session manager, which has a list of the plugins we've run
+        self.session  = session.Session(self.name)
+        self.session.set_dirs(base_dir, log_dir)
+
+        # Set the logdir from the Fuzzbunch.xml file, which will be overridden
+        # later when retarget is executed
+        self.default_logdir = os.path.normpath(log_dir)
+        self.set_logdir(log_dir)
+
+        # Create a Redirection object to keep track of the status of redirection, and to
+        # perform transforms on the parameters prior to and after executing plugins
+        self.redirection = redirection.RedirectionManager(self.io)
+
+        self.fontdir = os.path.join(base_dir, "fonts")
+        self.storage = os.path.join(base_dir, "storage")
+        self.setbanner()
+        self.postconfig()
+        self.pwnies = False
+
+        self.conv_tools = util.iDict([('MultiLine', self.toolpaste_ep),
+                                 ('MD5',       self.toolpaste_md5),
+                                 ('SHA1',      self.toolpaste_sha1),
+                                 ('Base64',    self.toolpaste_base64),
+                               ])
+
+        self.log = log(self.name, self.version, dict(debugging=True, enabled=True, verbose=False))
+
+    def precmd(self, line):
+        """Intercept user cmd line to global replacement"""
+        newline = util.variable_replace(line, self.fbglobalvars)
+        return FbCmd.precmd(self, newline)
+
+    def print_info(self, *ignore):
+        self.do_banner("")
+
+    """
+    Log directory handling
+
+    """
+    def get_logdir(self):
+        """Retrieve the current log directory"""
+        (base_dir, log_dir) = self.session.get_dirs()
+        return log_dir
+
+    def get_basedir(self):
+        """Retrieve the current base directory"""
+        (base_dir, log_dir) = self.session.get_dirs()
+        return base_dir
+
+    def set_logdir(self, log_dir=None):
+        """Set the current log directory and create a new log file"""
+        if not log_dir:
+            log_dir = os.path.normpath(self.default_logdir)
+
+        base_dir = self.get_basedir()
+        self.session.set_dirs(base_dir, log_dir)
+
+        logname = "fuzzbunch-%s.log" % util.formattime()
+        self.io.setlogfile(os.path.join(log_dir, logname))
+
+
+    """
+    Banners
+
+    """
+    def getstats(self):
+        """ Return stats in the form of tuple(count, type)"""
+        return [ (len(list(m.get_plugins())), m.get_type())
+                 for m in self.get_manager_list() ]
+
+    def setbanner(self):
+        """Set the Fuzzbunch banner (seen when starting fuzzbunch)"""
+        self.banner, font = figlet.newbanner(self.fontdir, self.bannerstr)
+        #self.io.write("FONT: %s" % font)
+
+    def printbanner(self):
+        """Print the currently configured banner"""
+        banner = {'banner'  : self.banner,
+                  'version' : self.version,
+                  'stats'   : self.getstats()}
+        self.io.print_banner(banner)
+
+    """
+    CMD: Banner
+    
+    """
+    def help_banner(self):
+        usage = ["banner",
+                 "Print the startup banner"]
+        self.io.print_usage(usage)
+
+    def do_banner(self, line):
+        """Print the startup banner"""
+        line = line.strip().split()
+        if line:
+            savedbanner = self.bannerstr
+            self.bannerstr = " ".join(line)
+        self.setbanner()
+        self.printbanner()
+        if line:
+            self.bannerstr = savedbanner
+
+    """
+    Console Handlers
+    """
+    def do_resizeconsole(self, line):
+        try:
+            import readline
+            readline.GetOutputFile().size(width=90,height=65)
+        except:
+            pass
+
+
+    """
+    Config File
+
+    """
+
+    def readconfig(self, file):
+        """Parse the Fuzzbunch.xml file to setup the Fuzzbunch initial environment"""
+        try:
+            import xml.dom.minidom
+            xmlDoc = xml.dom.minidom.parse(file)
+
+            config  = edfmeta.get_elements(xmlDoc, "config")[0]
+            redir   = edfmeta.get_elements(config, "redirection")[0]
+            runmode = edfmeta.get_elements(config, "runmode")[0]
+            banner  = edfmeta.get_elements(config, "banner")[0]
+            scripts = edfmeta.get_elements(config, "autorun")[0]
+            
+            automode = str(scripts.getAttribute("value"))
+            if automode.lower() == "on":
+                automode = True
+            else:
+                automode = False
+            autorun = {} 
+            # 'scripts' contains auto-run scripts.  Get them and set up autorun commands
+            for cat in edfmeta.get_elements(scripts, "category"):
+                autorun[str(cat.getAttribute("name"))] = []
+                for command in edfmeta.get_elements(cat, "command"):
+                    autorun[str(cat.getAttribute("name"))].append((command.getAttribute("value"),
+                                                                   command.getAttribute("msg")))
+
+            params = {"name"    : str(config.getAttribute("name")),
+                      "version" : str(config.getAttribute("version")),
+                      "banner"  : str(banner.getAttribute("value")),
+                      "globals" : {},
+                      "redirection" : {"value" : str(redir.getAttribute("value"))},
+                      "runmode" : str(runmode.getAttribute("value")),
+                      "automode" : automode,
+                      "autorun"  : autorun
+                     }
+            for param in edfmeta.get_elements(config, "parameter"):
+                key = str(param.getAttribute("name"))
+                params['globals'][key] = str(param.getAttribute("default"))
+        except:
+            self.configfile = None
+            params = {}
+        self.configfile = file
+        self.configvars = params
+
+    def preconfig(self):
+        try:
+            self.name      = self.configvars['name']
+            self.bannerstr = self.configvars['banner']
+            self.version   = self.configvars['version']
+        except:
+            self.name = "Fuzzbunch"
+            self.bannerstr = "FUZZBUNCH"
+            self.version   = "2.0"
+        # Override the default context's name and type
+        self.defaultcontext.set_name(self.name)
+        self.defaultcontext.set_type(self.name)
+
+    def postconfig(self):
+        try:
+            if self.configvars['redirection']['value'].lower() == "off":
+                self.redirection.off()
+            else:
+                self.redirection.on()
+        except:
+            pass
+
+        fntab = {"interactive"    : self.runmode_interactive,
+                 "noninteractive" : self.runmode_noninteractive,
+                 "scripted"       : lambda: (self.runmode_interactive(),
+                                             self.scripting(True))}
+        try:
+            fntab[self.configvars['runmode'].lower()]()
+        except:
+            pass
+
+        try:
+            self.cmdqueue.append("echo Initializing %s v%s" % (self.name,self.version))
+            self.cmdqueue.append("echo Adding Global Variables")
+            for item in self.configvars['globals'].items():
+                self.cmdqueue.append("setg %s %s" % item)
+        except:
+            pass
+         
+        try:
+            self.autorunvars = self.configvars['autorun']
+            self.autorun     = self.configvars['automode']
+            self.cmdqueue.append("autorun")
+        except:
+            pass
+        if "LogDir" not in self.configvars['globals']:
+            self.cmdqueue.append("setg LogDir %s" % self.default_logdir)
+        self.cmdqueue.append("setg FbStorage %s" % self.storage)
+
+    """
+    Plugin manager handling
+
+    """
+
+    def register_manager(self, type, typeConstructor):
+        """Register a manager with Fuzzbunch.  Initially these are PluginManager objects"""
+        if type in self.pluginmanagers:
+            raise exception.CmdErr, "'%s' already registered" % type
+        self.pluginmanagers[type] = typeConstructor(type, self)
+        return self.pluginmanagers[type]
+
+    def unregister_manager(self, type):
+        try:
+            del self.pluginmanagers[type]
+        except KeyError:
+            raise exception.CmdErr, "'%s' not a registered manager type" % type
+
+    def get_manager_types(self):
+        return self.pluginmanagers.keys()
+
+    def get_manager_counts(self):
+        return [ len(list(x.get_plugins())) for x in self.get_manager_list() ]
+
+    def get_active_plugin_names(self):
+        return [ (x.get_type(), x.get_active_name()) for x in self.get_manager_list() ]
+
+    def get_manager(self, type):
+        try:
+            return self.pluginmanagers[type]
+        except KeyError:
+            raise exception.CmdErr, "'%s' not a registered manager type" % type
+
+    def get_manager_list(self):
+        for manager in self.pluginmanagers.values():
+            yield manager
+        return 
+
+
+    """
+    CMD: Quit
+
+    """
+    def do_quit(self, arg):
+        """Quit fuzzbunch"""
+        try:
+            opencontracts = [ item.name
+                              for item in self.session.get_itemlist()
+                              if item.value.has_opencontract() ]
+            if opencontracts:
+                self.io.print_opensessions({'sessions' : opencontracts})
+
+                line = self.io.get_input("Really quit [n] ? ")
+                if line.lower() not in ("yes", "y", "q", "quit"):
+                    return 
+            if self.log: self.log.close()
+            return True
+        except:
+            pass
+
+        return True
+
+    """
+    Context handling user commands
+
+    """
+        
+
+    """
+    CMD: Info
+    
+    """
+    def help_info(self):
+        usage = ["info",
+                 "Print information about the current context"]
+        self.io.print_usage(usage)
+
+    def do_info(self, *ignore):
+        """Print information about the current context"""
+        self.getcontext().print_info()
+
+    """
+    CMD: Back
+    
+    """
+    def help_back(self):
+        usage = ["back",
+                 "Leave the context current plugin back to the default"]
+        self.io.print_usage(usage)
+
+    def do_back(self, *ignore):
+        """Leave the current context back to the default"""
+        self.setcontext(None)
+        self.setprompt()
+
+    """
+    CMD: Exit
+    
+    """
+    def help_exit(self):
+        usage = ["exit",
+                 "Leave the context current plugin back to the default"]
+        self.io.print_usage(usage)
+
+    def do_exit(self, arg):
+        """Alias for back"""
+        return self.do_back(arg)
+
+    """
+    CMD: Autorun
+
+    """
+    def complete_autorun(self, text, line, arglist, state, begidx, endidx):
+        """Command completion routine for autorun"""
+        if state == 1:
+            return [item for item in ("on","off") if item.lower().startswith(text.lower())]
+        return [""]
+
+    def help_autorun(self):
+        usage = ["autorun [mode]",
+                 "Enable (on) or disable (off) autorun features"]
+        self.io.print_usage(usage)
+    
+    def do_autorun(self, input):
+        """Set autorun mode"""
+        argc, argv = util.parseinput(input, 1)
+
+        if argc == 0:
+            self.io.print_autoruncmds(self.autorun, self.autorunvars)
+        else:
+            if argv[0].lower() in ("on", "enabled", "yes"):
+                self.autorun = True
+                self.io.print_msg("Autorun is ON")
+            elif argv[0].lower() in ("off", "disabled", "no"):
+                self.autorun = False
+                self.io.print_msg("Autorun is OFF")
+
+    """
+    CMD: Enter
+    
+    """
+    def complete_enter(self, text, line, arglist, state, begidx, endidx):
+        """Command completion routine for enter."""
+        if state == 1:
+            return [item 
+                    for item in self.get_manager_types()
+                    if item.upper().startswith(text.upper())]
+        return [""]
+
+    def help_enter(self):
+        usage = ["enter [type]",
+                 "Enter the context of the given plugin type"]
+        self.io.print_usage(usage)
+                 
+    def do_enter(self, input):
+        """Enter the context of a plugin"""
+        argc, argv = util.parseinput(input, 1)
+
+        if argc == 0:
+            self.io.print_module_types({'modules' : self.get_active_plugin_names()})
+        else:
+            manager = self.get_manager(argv[0])
+            if manager is None:
+                raise exception.CmdErr, "No plugin type for %s" % argv[0]
+
+            if manager.get_active_name() is "None":
+                raise exception.CmdErr, "No active plugin for %s" % argv[0]
+            
+            self.setcontext(manager)
+            self.setprompt()
+
+    """
+    CMD: Use
+    
+    """
+    def complete_use(self, text, line, arglist, state, begidx, endidx):
+        """Command completion routine for use."""
+        typeList = self.get_manager_types()
+
+        if state == 1:
+            pluginlist = []
+            for manager in self.get_manager_list():
+                pluginlist += manager.get_plugin_names()
+            return [item 
+                    for item in sorted(pluginlist) 
+                    if item.upper().startswith(text.upper())]
+        else:
+            return []
+
+    def help_use(self):
+        usage = ["use [name]",
+                 "Set the active plugin and enter the context of"
+                 "the plugin"]
+        self.io.print_usage(usage)
+
+    def do_use(self, input):
+        """Activate a plugin for use and enter context"""
+        argc, argv = util.parseinput(input, 2)
+        if argc == 0:
+            for manager in self.get_manager_list():
+                plugins = [ (plugin.getName(), plugin.getVersion())
+                            for plugin in manager.get_plugins() ]
+                args = {'module'  : manager.get_name(),
+                        'plugins' : plugins}
+                self.io.print_module_lists(args)
+        elif argc == 1:
+            for manager in self.get_manager_list():
+                if argv[0].lower() in [x.lower() for x in manager.get_plugin_names()]:
+                    manager.set_active_plugin(argv[0])
+                    plugin = manager.get_active_plugin()
+                    self.io.newline()
+                    self.io.print_warning("Entering Plugin Context :: %s" % plugin.getName())
+                    self.io.print_msg("Applying Global Variables")
+                    try:
+                        plugin.setParameters(self.fbglobalvars)
+                    except:
+                        pass
+                    self.io.newline()
+                    self.do_enter(manager.get_type())
+                    # At this point, grab anything that is setup to execute 
+                    # automatically according to the Fuzzbunch.xml file and
+                    # execute it.  This is where 'apply' will get run when you
+                    # enter a context
+                    if self.autorun: 
+                        for auto,msg in self.autorunvars.get(manager.get_type(), []):
+                            if msg:
+                                self.runcmd_noex("echo %s" % msg)
+                            self.runcmd_noex(auto)
+                    break
+            else:
+                raise exception.CmdErr, "Plugin %s not found!" % argv[0]
+
+    """
+    CMD: Show
+    
+    """
+    def complete_show(self, text, line, arglist, state, begidx, endidx):
+        """Command completion routine for show."""
+        typeList = self.get_manager_types()
+        if state == 1:
+            return [item
+                    for item in sorted(typeList)
+                    if item.upper().startswith(text.upper())]
+        elif state == 2:
+            if arglist[1] not in typeList:
+                return [""]
+            else:
+                pluginList = self.get_manager(arglist[1]).get_plugin_names()
+                return [item
+                        for item in pluginList
+                        if item.upper().startswith(text.upper())]
+        else:
+            return []
+
+    def help_show(self):
+        usage = ["show [type] [name]",
+                 "Show information about the types and specific plugins"]
+        self.io.print_usage(usage)
+   
+    def do_show(self, input):
+        """Show plugin info"""
+        argc, argv = util.parseinput(input, 2)
+
+        if argc == 0:
+            self.io.print_module_types({'modules' : self.get_active_plugin_names()})
+        elif argc == 1:
+            plugins = [ (plugin.getName(), plugin.getVersion()) 
+                  for plugin in self.get_manager(argv[0]).get_plugins() ]
+            args = {'module'  : argv[0],
+                    'plugins' : plugins}
+            self.io.print_module_lists(args)
+        elif argc == 2:
+            self.get_manager(argv[0]).print_info(argv[1])
+
+
+    """
+    Contract handling user commands
+
+    """
+
+    """
+    CMD: Session
+    
+    """
+    def complete_session(self, text, line, arglist, state, begidx, endidx):
+        """Command completion for session command."""
+        itemList = [str(i) 
+                    for i,item in enumerate(sorted(self.session.get_itemlist()))]
+        if state == 1:
+            return [i for i in itemList if i.startswith(text)]
+        return [""]
+
+    def help_session(self):
+        usage = ["session [index]",
+                 "Show inheritable plugin settings from session"]
+        self.io.print_usage(usage)
+
+    def do_session(self, input):
+        """Show session items"""
+        argc, argv = util.parseinput(input, 1)
+
+        if argc == 0:
+            items = [ (item.value.get_longname(), item.value.get_status())
+                      for item in self.session.get_itemlist() ]
+            self.io.print_session_items({'items' : items})
+        else:
+            try:
+                index = int(argv[0])
+            except ValueError: 
+                raise exception.CmdErr, "Invalid index"
+
+            item = self.session.get_item(index)
+            args = {'name'   : item.get_name(),
+                    'status' : item.get_status(),
+                    'info'   : item.get_info()}
+            self.io.print_session_item(args)
+
+    """
+    CMD: Mark
+    
+    """
+    def complete_mark(self, text, line, arglist, state, begidx, endidx):
+        """Command completion for mark command."""
+        itemList = [str(i) 
+                    for i,item in enumerate(sorted(self.session.get_itemlist()))]
+        if state == 1:
+            return [i for i in itemList if i.startswith(text)]
+        elif state == 2:
+            if arglist[1] not in itemList:
+                return [""]
+            else:
+                markingList = ["READY", "RUNNING", "FAIL", "USED"]
+                return [item for item in markingList if item.startswith(text.upper())]
+        return [""]
+
+    def help_mark(self):
+        usage = ["mark [index] [value]",
+                 "Mark a session item with a new status",
+                 "Valid markings:",
+                 "  READY    Plugin settings are ready to be used",
+                 "  RUNNING  Plugin is not finished executing",
+                 "  FAIL     Plugin failed to complete successfully",
+                 "  USED     Plugin settings have been used"]
+        self.io.print_usage(usage)
+
+    def do_mark(self, input):
+        """Mark a session item"""
+        argc, argv = util.parseinput(input, 2)
+
+        if argc == 0:
+            return self.do_session(input)
+        elif argc == 1:
+            return self.help_mark()
+        elif argc == 2:
+            try:
+                index = int(argv[0])
+                value = argv[1]
+            except (IndexError, ValueError): 
+                raise exception.CmdErr, "Invalid index"
+
+            item = self.session.get_item(index)
+            item.set_status(value)
+            self.io.print_success("Item marked as %s" % value)
+
+    """
+    Redirection support
+    
+    """
+
+    """
+    CMD: Redirect
+    
+    """
+    def complete_redirect(self, text, line, arglist, state, begidx, endidx):
+        """Command completion routine for redirect"""
+        if state == 1:
+            return [item for item in ("on","off")
+                         if item.lower().startswith(text.lower())]
+        return [""]
+
+    def help_redirect(self):
+        usage = ["redirect [on|off]",
+                 "Turn redirection on or off.  If no arguments, then",
+                 "displays the known redirection state."]
+        self.io.print_usage(usage)
+
+    def do_redirect(self, input):
+        """Configure redirection"""
+        argc, argv = util.parseinput(input, 2)
+        self.io.newline()
+        if argc == 0:
+            # No arguments on command line.  Print the status of redirection
+            if self.redirection.is_active():
+                self.io.print_success("Redirection ON")
+            else:
+                self.io.print_warning("Redirection OFF")
+        elif argc == 1:
+            # Set redirection to on or off
+            if argv[0].lower() in ("off", "no"):
+                self.redirection.off()
+                self.io.print_warning("Redirection OFF")
+            elif argv[0].lower() in ("on", "yes"):
+                self.redirection.on()
+                self.io.print_success("Redirection ON")
+            else:
+                raise exception.CmdErr, "Invalid input"
+            
+
+    """
+    Global variable support
+
+    """
+
+    """
+    CMD: Setg
+    
+    """
+    def complete_setg(self, text, line, arglist, state, begidx, endidx):
+        if state == 1:
+            return [item[0] 
+                    for item in sorted(self.fbglobalvars.items()) 
+                    if item[0].upper().startswith(text.upper())]
+        return [""]
+
+    def help_setg(self):
+        usage = ["setg [variable name] [value]",
+                 "Set a global variable to value.  If the variable",
+                 "does not already exist then it will be created.",
+                 "  L:value  - Input ascii string to widechar",
+                 "  H:value  - Input hex string"]
+        self.io.print_usage(usage)
+
+    @util.charconvert
+    def do_setg(self, input):
+        """Set a global variable"""
+        readonly_globals = ["logdir", "tmpdir"]
+        argc, argv = util.parseinput(input, 2)
+        if argc in (0,1):
+            args = {'title' : "Global Variables",
+                    'vars'  : self.fbglobalvars.items()}
+            self.io.print_set_names(args)
+        elif argc > 1:
+            inputList = input.strip().split()
+            value = " ".join(inputList[1:])
+            self.fbglobalvars[inputList[0]] = value
+            self.io.print_success("Set %s => %s" % (inputList[0], value))
+            if inputList[0].lower() == "logdir":
+                self.set_logdir(value)
+                self.fbglobalvars["TmpDir"] = value
+            elif inputList[0].lower() == "tmpdir":
+                raise exception.CmdErr, "TmpDir is readonly and set with LogDir"
+            elif inputList[0].lower() == "color":
+                # Supports fix for bug #2910
+                self.io.setcolormode( value.lower() == "true" )
+
+    """
+    CMD: unsetg
+    """
+    def complete_unsetg(self, text, line, begidx, endidx):
+        paramlist = self.fbglobalvars.items()
+        if begidx == 7:
+            return [item[0] 
+                    for item in sorted(paramlist) 
+                    if item[0].upper().startswith(text.upper())]
+        return [""]
+
+    def help_unsetg(self):
+        usage = ["unsetg [variable name]",
+                 "Unset a global variable."]
+        self.io.print_usage(usage)
+
+    def do_unsetg(self, input):
+        """Unset a global variable"""
+        argc, argv = util.parseinput(input, 2)
+        if argc == 0:
+            args = {'title' : "Global Variables",
+                    'vars'  : self.fbglobalvars.items()}
+            self.io.print_set_names(args)
+        else:
+            try:
+                del self.fbglobalvars[argv[0]]
+            except KeyError:
+                raise exception.CmdErr, "Invalid input"
+            self.io.print_success("Unset %s" % argv[0])
+
+    """
+    CMD: Toolpaste
+    """
+    def complete_toolpaste(self, text, line, arglist, state, begidx, endidx):
+        if state == 1:
+            return [item 
+                    for item in sorted(self.conv_tools.keys()) 
+                    if item.upper().startswith(text.upper())]
+        return [""]
+
+    def toolpaste_base64(self, paramname):
+        import base64
+        input = self.io.get_input_line('Base64 > ')
+        if input:
+            input = base64.b64encode(input)
+            self.do_setg("%s %s" %(paramname, input))
+        else:
+            raise exception.CmdErr, "Invalid input"
+
+    def toolpaste_sha1(self, paramname):
+        import hashlib
+        input = self.io.get_input_line('SHA1 > ')
+        if input:
+            input = hashlib.sha1(input).hexdigest()
+            self.do_setg("%s h:%s" %(paramname, input))
+        else:
+            raise exception.CmdErr, "Invalid input"
+
+    def toolpaste_md5(self, paramname):
+        import hashlib
+        input = self.io.get_input_line('MD5 > ')
+        if input:
+            input = hashlib.md5(input).hexdigest()
+            self.do_setg("%s h:%s" %(paramname, input))
+        else:
+            raise exception.CmdErr, "Invalid input"
+
+    def toolpaste_ep(self, paramname):
+        input = self.io.get_input_lines('MultiLine > ')
+        self.do_setg("%s h:%s" %(paramname, input))
+
+    def help_toolpaste(self):
+        usage = ["toolpaste [operation type] [variable name]",
+                "Transforms pasted input and exports as global variable",
+                "Types:",
+                "  MultiLine  Multiline hex input from EP",
+                "  MD5        MD5Sum of input",
+                "  SHA1       SHA1 of input",
+                "  Base64     Base64 of input"]
+        self.io.print_usage(usage)
+
+    def do_toolpaste(self, input):
+        """Paste and convert data from external tool output"""
+        argc, argv = util.parseinput(input, 2)
+        if argc in (0,1):
+            self.help_toolpaste()
+        elif argc == 2:
+            try:
+                self.conv_tools[argv[0]](argv[1])
+            except KeyError:
+                raise exception.CmdErr, "Invalid input"
+
+
+    """
+    Targetting support
+
+    """
+    """
+    CMD: Retarget
+    
+    """
+    def help_retarget(self):
+        usage = ["retarget",
+                 "Retarget the current session"]
+        self.io.print_usage(usage)
+
+    def getip_prompt(self, prompt, default):
+        done = False
+        while not done:
+            try:
+                targetvar = self.io.prompt_user("Default " + prompt, default, gvars=self.fbglobalvars)
+                targetvar = util.validateip(targetvar)
+                if not targetvar:
+                    raise exception.CmdErr, "Invalid " + prompt
+            except exception.PromptErr, err:
+                raise exception.PromptErr, err.error
+            except exception.PromptHelp, err:
+                pass
+            except exception.CmdErr, err:
+                self.io.print_error(err.getErr())
+            else:
+                done = True
+        return targetvar
+
+    def _get_projectlist(self, d):
+        """Gets a list of directories, which should be coverterms"""
+        dirlist = []
+        try:
+            os.makedirs(d)
+        except:
+            if not os.path.exists(d):
+                raise
+        map(lambda x: os.path.isdir(os.path.join(d, x)) and dirlist.append(x), os.listdir(d))
+        return dirlist
+        
+    def _prompt_for_project(self, projects):
+        try:
+            vals = [(str(i), v) for i,v in enumerate(projects)]
+            vals.append( tuple([str(len(vals)), "Create a New Project"]) )
+            widths = self.io.get_column_max_width(vals)
+            widths[0] = max(6, widths[0])
+            widths[1] = max(len("Project"), widths[1])
+            self.io.print_table(widths, [("Index", "Project")], vals)
+            c = self.io.prompt_user("Project", "0", gvars=self.fbglobalvars)
+            if int(c)+1 < len(vals):
+                try:
+                    return projects[int(c)].lower()
+                except IndexError:
+                    self.io.print_error("Invalid choice")
+                    return None
+            elif int(c)+1 == len(vals):
+                return self.io.prompt_user("New Project Name", None, gvars=self.fbglobalvars).lower()
+            else: 
+                self.io.print_error("Invalid choice")
+                return None
+        except KeyboardInterrupt:
+            raise
+        except:
+            return None
+        
+    def _prompt_for_logging(self, target, oldproject):
+        try:
+            if oldproject is None:
+                oldproject = ''
+            base_logdir = self.get_logdir()
+            base_logdir = ''.join(base_logdir[:base_logdir.find(oldproject)])
+            if len(base_logdir) == 0:
+                base_logdir = self.get_logdir()
+            
+            # Request #1699: Change to include compatible logging structure
+            self.io.newline()
+            log_dir = self.io.prompt_user("Base Log directory", base_logdir, gvars=self.fbglobalvars)
+            log_dir = os.path.abspath(log_dir)
+
+            # Get the list of projects
+            self.io.print_msg("Checking %s for projects" % (log_dir))
+            projects = self._get_projectlist(log_dir)
+            
+            # Give the user the choice to use an existing project or create a new one            
+            project = None
+            while project is None:
+                project = self._prompt_for_project(projects)
+            
+            log_dir = os.path.join(log_dir, project, 'z'+target.replace(":", "_"))  # To support IPv6 address in log files
+            if not self.io.prompt_yn("Set target log directory to '%s'?" % (log_dir)):
+                log_dir = self.io.prompt_user("Target log directory?", log_dir, gvars=self.fbglobalvars)
+            try:
+                os.makedirs(log_dir)            # Fix from 3.2.0 - Don't reinvent the wheel
+            except:
+                if not os.path.exists(log_dir):
+                    raise
+            self.set_logdir(log_dir)
+            return (project, log_dir)
+        except OSError:
+            self.io.print_warning("Access Denied to '%s'! Choose a different log directory." %(log_dir))
+            return (None, None)
+       
+
+    def do_retarget(self, *ignore):
+        """Set basic target info"""
+        self.do_back(self)
+
+        self.io.newline()
+        self.io.print_msg("Retargetting Session")
+        self.io.newline()
+        try:
+            target = self.getip_prompt("Target IP Address",
+                                       self.fbglobalvars.get('targetip', ''))
+            callback = self.getip_prompt("Callback IP Address", '')
+            redirection = self.io.prompt_user("Use Redirection", "yes")
+            if redirection.lower() in ("no", "n", "off"):
+                redirection = "off"
+            else:
+                redirection = "on"
+            # Setup logging
+            log_dir = None
+            project = self.fbglobalvars.get('project', '')
+            while log_dir is None:
+                (project, log_dir) = self._prompt_for_logging(target, project)
+
+        except (exception.PromptErr, exception.CmdErr), err:
+            self.io.print_error(err.getErr())
+            return
+
+        self.io.newline()
+        self.io.print_msg("Initializing Global State")
+        self.do_setg("TargetIp   %s" % target)
+        self.do_setg("CallbackIp %s" % callback)
+        self.do_redirect(redirection)
+        self.do_setg("LogDir %s" % log_dir)
+        self.do_setg("Project %s" % (project))
+        self.io.newline()
+        if self.log:
+            if 'Project' in self.fbglobalvars: self.log.set(project_name=self.fbglobalvars['Project'])
+            self.log.open()
+    """
+    CMD: Standard OP
+
+    """
+    def help_standardop(self):
+        self.io.print_standardop()
+
+    def do_standardop(self, *ignore):
+        """Print standard OP usage message"""
+        self.help_standardop()
+
+
diff --git a/windows/fuzzbunch/iohandler.py b/windows/fuzzbunch/iohandler.py
new file mode 100644
index 0000000..27b6e20
--- /dev/null
+++ b/windows/fuzzbunch/iohandler.py
@@ -0,0 +1,860 @@
+"""
+IO Handling classes
+
+The IO Handler works as a wrapper around all user input and output.
+
+Theoretically, to change the way Fuzzbunch looks should only require changing
+this file.  Specialized print functions provide a template-like facility.
+
+"""
+import sys
+import exception
+from util import variable_replace
+
+MAX_OUTPUT_ROWS = 5
+MAX_PROMPT_ECHO_LEN = 50
+
+try:
+    try:
+        import readline
+    except ImportError:
+        import pyreadline as readline
+    HAVE_READLINE = True
+except:
+    HAVE_READLINE = False
+
+mswindows = (sys.platform == "win32")
+
+__all__ = ["IOhandler"]
+
+"""
+Valid Attributes : none,      bold,
+                   faint,     italic,
+                   underline, blink,
+                   fast,      reverse,
+                   concealed
+
+Valid Colors : grey     red 
+               green    yellow 
+               blue     magenta 
+               cyan     white
+"""
+COLORIZEMAP = {"[-]" : {"fg" : "red",     "attr" : "bold"},
+               "[+]" : {"fg" : "green",   "attr" : "bold"},
+               "[!]" : {"fg" : "red",     "attr" : "bold"},
+               "[*]" : {"fg" : "green",   "attr" : "bold"},
+               "[?]" : {"fg" : "blue",    "attr" : "bold"}}
+
+VMAP = {"[-]" : {"fg" : "magenta",   "attr" : "bold"},
+        "[+]" : {"fg" : "magenta",   "attr" : "bold"},
+        "[!]" : {"fg" : "magenta",   "attr" : "bold"},
+        "[*]" : {"fg" : "magenta",   "attr" : "bold"},
+        "[?]" : {"fg" : "magenta",   "attr" : "bold"}}
+
+class DevNull:
+    def write(self, *ignore):
+        pass
+    def close(self):
+        pass
+    def flush(self):
+        pass
+
+def truncate(string, length=MAX_PROMPT_ECHO_LEN):
+    return string if (len(string) <= length) else ("%s... (plus %d characters)" % (string[:length], len(string) - length))
+
+class IOhandler:
+    """Handle I/O for fuzzbunch commands"""
+
+    def __init__(self, stdin=None, 
+                       stdout=None, 
+                       use_raw=1,
+                       noprompt=False,
+                       completekey='tab',
+                       enablecolor=True,
+                       history=4096):
+
+        """
+
+        @param  stdin
+        @param  stdout
+        @param  use_raw         
+        @param  noprompt        Do we want to prompt for values upon plugin execution?
+        @param  completekey     Command completion
+        """
+
+        import sys
+        if stdin is not None:
+            self.stdin = stdin
+        else:
+            self.stdin = sys.stdin
+
+        if stdout is not None:
+            self.stdout = stdout
+        else:
+            self.stdout = sys.stdout
+
+        self.stderr = self.stdout
+
+        self.logout = DevNull()
+        self.noprompt  = noprompt
+        self.raw_input = use_raw
+        self.completekey = completekey
+        self.havecolor = False          # Are we in color mode?
+        self.enablecolor = enablecolor  # Do we want to permanently enable color.  Change to False to disable
+        self.colormode = "ansi"
+        self.colormap  = COLORIZEMAP
+        self.historysize = history
+
+    def setlogfile(self, logfile):
+        self.logout.close()
+        try:
+            self.logout = open(logfile, "w")
+        except:
+            self.logout = DevNull()
+
+    def setcolormode(self, isEnabled):
+        """Switch to enable or disable color output"""
+        self.enablecolor=isEnabled
+
+    def switch(self):
+        if self.colormap == COLORIZEMAP:
+            self.colormap = VMAP
+        else:
+            self.colormap = COLORIZEMAP
+
+    def pre_input(self, completefn):
+        if self.raw_input:
+            if HAVE_READLINE:
+                import atexit
+                self.old_completer = readline.get_completer()
+                # Fix Bug #3129: Limit the history size to consume less memory
+                readline.set_history_length(self.historysize)   
+                readline.set_completer(completefn)
+                readline.parse_and_bind(self.completekey+": complete")
+                try:
+                    readline.read_history_file()
+                except IOError:
+                    pass
+                atexit.register(readline.write_history_file)
+                self.havecolor = True
+                if mswindows and self.enablecolor:
+                    self.cwrite = readline.GetOutputFile().write_color
+                else:
+                    self.cwrite = self.stdout.write
+
+    def post_input(self):
+        if self.raw_input:
+            if HAVE_READLINE:
+                readline.set_completer(self.old_completer)
+                self.havecolor = False
+        self.cwrite = None
+
+    """
+    User input handling
+
+    """
+    def get_input_lines(self, prompt):
+        done = False
+        lines = []
+        while not done:
+            line = self.get_input(prompt)
+            if line == 'EOF':
+                done = True
+            else:
+                lines.append(line)
+        return ''.join(lines)
+
+    def get_input_line(self, prompt):
+        line = self.get_input(prompt)
+        if line == 'EOF':
+            return ''
+        else:
+            return line.strip()
+
+    def get_input(self, prompt):
+        if self.raw_input:
+            try:
+                line = raw_input(prompt)
+            except (EOFError, KeyboardInterrupt):
+                line = 'EOF'
+        else:
+            self.write(prompt)
+            self.flush()
+            line = self.stdin.readline()
+            if not len(line):
+                line = 'EOF'
+            else:
+                line = line[:-1]
+        return line
+       
+    def prompt_user(self, msg, default=None, params=None, gvars=None):
+        if self.noprompt:
+            return variable_replace(default, gvars)     # Fix a small bug in 3.2.0
+
+        if default is not None:
+            # If we pass a default, interepret any variables (marked with '$')
+            interpreted_default = variable_replace(default, gvars)
+            p = "[?] %s [%s] : " % (msg, truncate(interpreted_default))
+        else:
+            # No default, so empty string
+            p = "[?] %s : " % msg
+            interpreted_default = ""
+
+        if self.havecolor and self.enablecolor:
+            p = self.colorize(p)
+        line = self.get_input(p)
+
+        # Check the user input
+        if line.upper() in ("EOF",):
+            self.newline()
+
+        if line.upper() in ("EOF", "Q", "QUIT"):
+            raise exception.PromptErr, "Aborted by user"
+
+        if line.upper() in ("?", "HELP"):
+            raise exception.PromptHelp, "No help available"
+
+        # Retrieve the line, and replace any '$' vars with their values
+        line = variable_replace(line, gvars)
+        if not len(line.strip()):
+            # If line is empty, just use the default
+            line = interpreted_default
+
+        # If it's a choice, figure out which value they chose
+        if params:
+            try:
+                index = int(line)
+                line = params[index][0]
+            except (IndexError, ValueError):
+                raise exception.CmdErr, "Invalid input"
+
+        return line
+
+    def prompt_yn(self, msg, default="Yes", params=None, gvars=None):
+        if default.lower() not in ["yes", 'y', 'no', 'n']:
+            default = 'No'
+        yn = self.prompt_user(msg, default, params=params, gvars=gvars).lower()
+        if yn == 'yes' or yn == 'y':
+            return True
+        return False
+
+    def prompt_continue(self):
+        line = self.prompt_user("Execute Plugin?", "Yes")
+        if line.lower() not in ("yes", "y"):
+            raise exception.CmdErr, "Execution Aborted"
+        return
+
+    def prompt_confirm_redir(self):
+        line = self.prompt_user("Press Any Key To Continue")
+        del line
+        return
+
+    def prompt_runsubmode(self, text):
+        line = self.prompt_user(text, "Yes")
+        if line.lower() not in ("yes", "y"):
+            return False
+        else:
+            return True
+
+    """
+    Basic user output handling
+
+    """
+    def flush(self):
+        self.logout.flush()
+        self.stdout.flush()
+
+    def log(self, line):
+        line += "\n"
+        self.logout.write(line)
+
+    def write(self, line):
+        self.log(line)
+        line += "\n"
+
+        # Fix bug #2910
+        if self.havecolor and self.enablecolor:
+            try:
+                self.cwrite(self.colorize(line))
+            except LookupError:
+                # We failed to print in color.  This is a problem looking up the encoding
+                # Permanently disable color and continue
+                self.havecolor = False
+                self.enablecolor = False
+                self.stdout.write(line)
+        else:
+            self.stdout.write(line)
+        self.flush()
+
+    def newline(self):
+        self.write("")
+
+    def print_error(self, line):
+        self.write("[-] " + line)
+
+    def print_success(self, line):
+        self.write("[+] " + line)
+
+    def print_warning(self, line):
+        self.write("[!] " + line)
+
+    def print_msg(self, line):
+        self.write("[*] " + line)
+
+
+    """
+    Output formatting help
+
+    """
+    def get_single_col_max_width(self, data, colnum):
+        # Min len = 6
+        maxlen = 6
+        for row in data:
+            for i,col in enumerate(row):
+                if i == colnum:
+                    maxlen = max(maxlen, len(col))
+        return maxlen
+
+    def get_column_max_width(self, data):
+        maxlens = list(0 for i in range(0, len(data[0])))
+        for row in data:
+            for i,col in enumerate(row):
+                maxlens[i] = max(maxlens[i], len(col), 1)
+        return maxlens
+
+    def print_headingline(self, msg):
+        self.newline()
+        self.write(msg)
+        self.write("=" * len(msg))
+        self.newline()
+
+    def print_vheading(self, vector):
+        self.newline()
+        for v in vector:
+            self.write(v)
+        self.newline()
+
+    def vprint(self, fmt, vector, max_str_len=None):
+        for v in vector:
+            if max_str_len:
+                if isinstance(v, tuple):
+                    v = tuple(truncate(field, max_str_len) for field in v)
+                else:
+                    v = truncate(field, max_str_len)
+            self.write(fmt % v)
+        self.newline()
+
+    def makeplural(self, name, count):
+        if count < 2:
+            return name
+
+        if name.endswith("h"):
+            return name + "es"
+        elif name.endswith("s"):
+            return name
+        else:
+            return name + "s"
+
+    """
+    Color support
+
+    """
+    def colorize(self, line):
+        for pattern, attrs in self.colormap.items():
+            plen = len(pattern)
+            index = line.find(pattern)
+            if self.colormap == VMAP:
+                pattern = "[TF]"
+            if index != -1:
+                r = index + plen
+                line = (line[:index] +
+                        self.color(**attrs) +
+                        pattern +
+                        self.color() +
+                        line[r:])
+                return line
+        return line
+
+    def color(self, fg=None, bg=None, attr=None):
+        if self.colormode != "ansi":
+            return ""
+
+        attrs  = 'none bold faint italic underline blink fast reverse concealed'
+        colors = 'grey red green yellow blue magenta cyan white'
+        attrs  = dict((s,i) for i,s in enumerate(attrs.split()))
+        colors = dict((s,i) for i,s in enumerate(colors.split()))
+        fgoffset, bgoffset = 30,40
+
+        cmd = ["0"]
+
+        if fg in colors:
+            cmd.append("%s" % (colors[fg] + fgoffset))
+        if bg in colors:
+            cmd.append("%s" % (colors[bg] + bgoffset))
+        if attr:
+            for a in attr.split():
+                if a in attrs:
+                    cmd.append("%s" % attrs[a])
+
+        return "\033[" + ";".join(cmd) + "m"
+
+                
+    """
+    Specialized output routines
+
+    """
+    # OK because it's readline
+    def print_history(self, args):
+        self.newline()
+        for index,item in args['items']:
+            self.write("%4d  %s" % (index, item))
+        self.newline()
+    def print_cmd_list(self, args):
+        self.print_headingline(args['title'])
+        cmds = args['commands']
+
+        cmds.insert(0, ("Command", "Description"))
+        cmds.insert(1, ("-------", "-----------"))
+        self.vprint("  %-15s %s", cmds)
+
+    def print_banner(self, args):
+        self.write(args['banner'])
+        self.write("--[ Version %s" % args['version'])
+        for count, type in args['stats']:
+            self.write("  * %d %s" % (count, self.makeplural(type, count)))
+        self.newline()
+
+    def print_opensessions(self, args):
+        self.newline()
+        for session in enumerate(args['sessions']):
+            self.print_warning("Session item %d (%s) has open contract" % session)
+        self.newline()
+
+    def print_usage(self, arg):
+        self.write("Usage: %s\n" % arg[0])
+        self.write("\n".join(arg[1:]))
+
+    def print_module_lists(self, args):
+        category = args['module']
+        modules  = args['plugins']
+        self.print_headingline("Plugin Category: %s" % category)
+        modules.sort()
+        modules.insert(0, ("Name", "Version"))
+        modules.insert(1, ("----", "-------"))
+        widths = self.get_column_max_width(modules)
+        self.vprint("  %%-%ds %%s" % (widths[0] + 4), modules)
+
+    def print_module_types(self, args):
+        self.print_headingline("Plugin Categories")
+        modules = args['modules']
+        modules.sort()
+        modules.insert(0, ("Category", "Active Plugin"))
+        modules.insert(1, ("--------", "-------------"))
+        widths = self.get_column_max_width(modules)
+        self.vprint("  %%-%ds %%s" % (widths[0] + 4), modules)
+
+    def print_session_item(self, args):
+        self.print_vheading(("Name: %s" % args['name'],
+                            "Status: %s" % args['status']))
+
+        for type,info in args['info']:
+            self.write("%s:\n" % type)
+            if info:
+                params = [x[:2] for x in dict(info.get_paramlist()).values()]
+                params.insert(0, ("Name", "Value"))
+                params.insert(1, ("----", "-----"))
+                widths = self.get_column_max_width(params)
+                self.vprint("  %%-%ds %%s" % (widths[0] + 4), params, MAX_PROMPT_ECHO_LEN)
+
+
+    def print_session_items(self, args):
+        items = args['items']
+        self.print_headingline("Session History")
+        if not items:
+            self.write("  *Empty*\n")
+            self.newline()
+        else:
+            _list = [("Index", "Name", "Status"),
+                     ("-----", "----", "------")]
+            for index,item in enumerate(items):
+                _list.append((str(index), item[0], item[1]))
+
+            widths = self.get_column_max_width(_list)
+            fmt    = "%%7s %%-%ds %%s" % (widths[1] + 4)
+            self.vprint(fmt, _list, MAX_PROMPT_ECHO_LEN)
+
+    # Move to table
+    def is_table_row_empty(self, v):
+        ncols = len(v)
+        for i in range(0, ncols):
+            if len(v[i]) > 0 and len(v[i][0]) > 0:
+                return False
+        return True
+
+    # Move to table
+    def get_table_row(self, vector):
+        ncols = len(vector)
+
+        while not self.is_table_row_empty(vector):
+            line = []
+            for i in range(0, ncols):
+                try:
+                    val = vector[i].pop(0)
+                except IndexError:
+                    val = ""
+                line.append(val)
+            yield line
+
+    # Move to Table
+    def print_row(self, widths, data):
+        fmt = "%%-%ds    " * len(widths) % tuple(widths)
+        vectors = []
+        for i,width in enumerate(widths):
+            vector = []
+            col = data[i]
+            printed_rows = 0
+            while col:
+                if printed_rows > MAX_OUTPUT_ROWS:
+                    vector.append("... (plus %d more lines)" % (len(col) / widths[i]))
+                    break
+                vector.append(col[:widths[i]])
+                col = col[widths[i]:]
+                printed_rows += 1
+            vectors.append(vector)
+
+        for line in self.get_table_row(vectors):
+            self.write(fmt % tuple(line))
+
+    # Move to Table
+    def print_table(self, widths, heading, params):
+        sep = tuple(['-' * len(word) for word in heading[0]])
+        heading.append(sep)
+        heading.extend(params)
+
+        for d in heading:
+            self.print_row(widths, d)
+        self.newline()
+
+    def print_set_names(self, args):
+        self.print_headingline("Module: %s" % args['title'])
+        params = args['vars']
+        if not params:
+            self.write(" *Empty")
+            self.newline()
+        else:
+            widths = [self.get_single_col_max_width(params, 0), 50]
+            self.print_table(widths, [("Name", "Value")], params)
+
+    def print_exe_set_names(self, args):
+        if not args['session']:
+            return self.print_set_names(args)
+        self.print_headingline("Module: %s" % args['title'])
+        params = args['vars']
+        session = args['session']['params']
+
+        print_params = []
+        for param in params:
+            if session.get(param.name):
+                realval = truncate(session.get(param.name))
+                redirval = truncate(param.value)
+            else:
+                realval = truncate(param.value)
+                redirval = ""
+            print_params.append((param.name, realval, redirval))
+        widths = self.get_column_max_width(print_params)
+        widths[1] = max(widths[1], len("Set Value"))
+        widths[2] = max(widths[2], len("Redirected Value"))
+        self.print_table(widths, [("Name", "Set Value", "Redirected Value")], print_params)
+
+    def print_set_attributes(self, title, param, attribs):
+        self.print_vheading(("Module: %s" % title,
+                            "Parameter: %s" % param))
+
+        attribs.insert(0, ("Parameter Attribute", "Value"))
+        attribs.insert(1, ("-------------------", "-----"))
+        widths = self.get_column_max_width(attribs)
+        fmt = "  %%-%ds %%s" % (widths[0] + 4)
+        self.vprint(fmt, attribs)
+
+
+    def print_set_choices(self, choices):
+        choices.insert(0, ("Parameter Options", "Description"))
+        choices.insert(1, ("-----------------", "-----------"))
+        widths = self.get_column_max_width(choices)
+        fmt = "    %%-%ds %%s" % (widths[0] + 4)
+        self.vprint(fmt, choices)
+        
+
+    def print_sorted_vals(self, sorted_vals, vals):
+        i = 0
+        for cat in ("Contract", "History", "Other"):
+            self.write("\n---[ %s\n" % cat)
+            for index in sorted_vals[cat]:
+                (val, name, label, info) = vals[index]
+                self.write("   %d) %s (%s)" % (i, val, name))
+                i += 1
+
+        if len(sorted_vals["Contract"]):
+            default = 0
+        else:
+            default = i - 1
+
+        return i,default
+
+    def print_param_list(self, param_list):
+        self.write("")
+        widths = self.get_column_max_width(param_list)
+        widths[0] = max(widths[0], len('Name'))
+        widths[1] = max(widths[1], len('Value'))
+        widths[2] = 50
+        self.print_table(widths, [('Name', 'Value', 'Description')], param_list)
+
+    def print_touch_info(self, args):
+        touchlist = args['touchlist']
+        self.print_headingline("Touch List")
+
+        if not touchlist:
+            self.write("  *Empty*\n")
+            self.newline()
+        else:
+            hdrlist = []
+            hdrlist.append(("Index", "Name", "Description"))
+            hdrlist.append(("-----", "----", "-----------"))
+
+            widths = self.get_column_max_width(touchlist)
+        
+            fmt = "%%7s  %%-%ds %%s" % (widths[0] + 4)
+            self.vprint(fmt, hdrlist)
+
+            fmt = "%%7d  %%-%ds %%s (%%s)" % (widths[0] + 4)
+            for i,touch in enumerate(touchlist):
+                self.write(fmt % ((i,) + touch))
+            self.newline()
+
+    """
+    Apply command
+    
+    """
+    def print_apply_prompt_list(self, args):
+        if args['default']:
+            default = args['default']
+        else:
+            default = '[NOT SET]'
+        vals = args['vals']
+        vals = [(str(i), args['contract'], v) for i,v in enumerate(args['vals'])]
+        vals.append((str(i+1), "Current Value", default))
+
+        widths = self.get_column_max_width(vals)
+        widths[0] = len("Index")
+        widths[2] = 50
+
+        self.newline()
+        self.print_msg("%s :: Deconflict" % args['variable'])
+        self.newline()
+        self.print_table(widths, [("Index", "Session ID", "Value")], vals)
+
+    def print_apply_prompt(self, args):
+        if args['default']:
+            default = args['default']
+        else:
+            default = '[NOT SET]'
+        vals = [(str(i), contract.get_item_info(), param.value.value)
+                for i,(param,contract) in enumerate(args['vals'])]
+        vals.append((str(i+1), "Current Value", default))
+
+        widths = self.get_column_max_width(vals)
+        widths[0] = len("Index")
+        widths[2] = 50
+
+        self.newline()
+        self.print_msg("%s :: Deconflict" % args['variable'])
+        self.newline()
+        self.print_table(widths, [("Index", "Session ID", "Value")], vals)
+
+
+    """
+    Prompt Command
+
+    """
+    def print_prompt_param(self, args, default):
+        self.newline()
+        self.print_msg(" %s :: %s" % (args['name'], args['description']))
+
+        fmt = []
+        if args['attribs']:
+            fmt.append("")
+            widths = self.get_column_max_width(args['attribs'])
+            choice_fmt = "   %%s%%d) %%-%ds %%s" % (widths[0] + 4)
+            for i,(attr,val) in enumerate(args['attribs']):
+                if default and i == int(default): 
+                    markdef = "*"
+                else:
+                    markdef = " "
+                fmt.append(choice_fmt % (markdef,i,attr,val))
+        self.vprint("%s", fmt)
+
+    def print_prompt_param_help(self, args):
+        self.newline()
+        fmt = [ "     Name : %s" % args['name'],
+                "     Desc : %s" % args['description'],
+                "     Type : %s" % args['type'],
+                " Required : %s" % args['required'],
+                " Is Valid : %s" % args['valid']]
+        if args['type'] != "Choice":
+            fmt.append("    Value : %s" % args['value'])
+
+        self.vprint("%s", fmt)
+
+    """
+    Redirection
+
+    """
+    def print_localiplist(self, iplist):
+        self.print_headingline("Local IP Addresses")
+        for ip in iplist:
+            self.write(" * %s " % ip)
+        self.newline()
+
+    def print_redir_info(self, redir, paramList):
+        #params = iDict(paramList)
+
+        try:
+            self.print_headingline("Local")
+            if not redir or not redir['local']:
+                self.write(" *Empty* ")
+            else:
+                for l in redir['local']:
+                    self.write("Name: %s" % l.name)
+                    self.write("Protocol: %s" % l.protocol)
+                    self.write("Listen Address: %s" % l.listenaddr)
+                    self.write("Listen Port: %s" % l.listenport)
+                    self.write("Destination Address: %s" % l.destaddr)
+                    self.write("Destination Port: %s" % l.destport)
+                    self.write("Source Port : %s" % l.srcport)
+                    self.write("")
+            self.print_headingline("Remote")
+            if not redir or not redir['remote']:
+                self.write(" *Empty* ")
+            else:
+                for r in redir['remote']:
+                    self.write("Name: %s" % r.name)
+                    self.write("Protocol: %s" % r.protocol)
+                    self.write("Listen Address: %s" % r.listenaddr)
+                    self.write("Listen Port: %s" % r.listenport)
+                    self.write("Destination Address: %s" % r.destaddr)
+                    self.write("Destination Port: %s" % r.destport)
+        except:
+            # XXX - ESKE. Due to group visibility some of the redir params
+            # being looked up might not be in the params list
+            pass
+        self.write("")
+
+
+
+
+    def print_local_tunnels(self, tunnels):
+        data = [("Proto", "Listen IP", "Source IP", "Destination IP")]
+
+        for tunnel in tunnels:
+            if tunnel.srcport is None:
+                srcport = 'ANY'
+            else:
+                srcport = '0'
+            data.append((tunnel.protocol,
+                        tunnel.listenaddr + ":" + tunnel.listenport,
+                        "Redirector" + ":" + srcport,
+                        tunnel.destaddr + ":" + tunnel.destport))
+
+        maxlens = self.get_column_max_width(data)
+        data.insert(1, tuple(["-" * length for length in maxlens]))
+
+        fmt = "%%-%ds   %%-%ds   %%-%ds   %%-%ds" % tuple(maxlens)
+        for line in data:
+            self.write(fmt % line)
+
+
+    def print_remote_tunnels(self, tunnels):
+        data = [("Proto", "Destination IP", "Listen IP", "Target")]
+
+        for tunnel in tunnels:
+            data.append((tunnel.protocol,
+                         tunnel.destaddr + ":" + tunnel.destport, 
+                         tunnel.listenaddr + ":" + tunnel.listenport,
+                         "TARGET"))
+
+        maxlens = self.get_column_max_width(data)
+        data.insert(1, tuple(["-" * length for length in maxlens]))
+
+        fmt = "%%-%ds   %%-%ds   %%-%ds   %%-%ds" % tuple(maxlens)
+        for line in data:
+            self.write(fmt % line)
+
+
+    def print_global_redir(self, tunnels):
+        self.print_headingline("Local")
+        if not tunnels['local']:
+            self.write(" *empty* ")
+        else:
+            self.print_local_tunnels(tunnels['local'])
+
+        self.print_headingline("Remote")
+        if not tunnels['remote']:
+            self.write(" *empty* ")
+        else:
+            self.print_remote_tunnels(tunnels['remote'])
+        self.write("")
+
+    """
+    Autorun
+
+    """
+
+    def print_autoruncmds(self, status, auto):
+        if status:
+            self.print_msg("Autorun ON")
+            for cat, cmds in auto.items():
+                self.print_headingline(cat + " Autorun List")
+                for i,cmd in enumerate(cmds):
+                    self.write("  %d) %s" % (i,cmd[0]))
+                self.newline()
+        else:
+            self.print_msg("Autorun OFF")
+        self.newline()
+
+
+    """
+    General Help
+
+    """
+    def print_standardop(self):
+        standardop = """
+    Fuzzbunch2 Standard OP Usage Help
+    ---------------------------------
+
+    === Summary ===
+
+    Run the following commands.  Answer questions along the way.
+    Abort on any failures.
+
+    use PcConfig
+    use Explodingcan
+    use Pclauncher
+
+    === Detail ===
+
+    use PcConfig will run the Peddlecheap configuration plugin and will
+    generate a configured Peddlecheap DLL.
+
+    use Explodingcan will run the Explodingcan exploit.  It will first run
+    through the Explodingcan touch plugin then try to run the exploit.  This
+    plugin will generate an open socket connection that MUST be consumed by the
+    Pclauncher plugin before exiting.
+
+    use Pclauncher will upload the configured Peddlecheap DLL to target over
+    the open connection from Explodingcan and run it from memory.  A new window
+    will be opened for the LP to communicate with target.
+
+    """
+        self.write(standardop)
+
+
diff --git a/windows/fuzzbunch/log.py b/windows/fuzzbunch/log.py
new file mode 100644
index 0000000..91bdf25
--- /dev/null
+++ b/windows/fuzzbunch/log.py
@@ -0,0 +1,369 @@
+version = '0.4.2'
+
+import json
+import os
+import platform
+import shutil
+import sys
+from uuid import uuid1
+from copy import deepcopy
+from datetime import datetime
+from traceback import print_exception
+is_windows = platform.uname()[0].lower() == 'windows'
+
+def uuid(): return str(uuid1())
+    
+class log(object):
+    def __init__(self, tool_name, tool_version, options={}, **params):
+        # record parent if child, otherwise do following setup only if parent log
+        self.parent = options.get('parent') # None == root, instance_parent
+        self.uuid = uuid() # instance_uuid
+        if not self.parent:
+            # user-controllable options
+            for option in ['debug', 'enabled', 'verbose']:
+                value = options.get(option) if isinstance(options.get(option), bool) else True 
+                self.__setattr__(option, value)
+            
+            # dispatcher depends on a common prefix being used across output files
+            # dispatcher will look for files dropped in directories under the log_root
+            self.prefix = 'concernedparent'
+            self.log_root = 'c:\\temp' if is_windows else '/tmp'
+            
+            # create log_dir from log_root/prefix, otherwise use cwd/prefix
+            self.log_dir = os.path.join(self.log_root, self.prefix)
+            if self.enabled:
+                try:
+                    if not os.path.exists(self.log_dir):
+                        os.makedirs(self.log_dir)
+                except:
+                    try:
+                        self.log_dir = os.path.join(os.getcwd(), self.prefix)
+                        if not os.path.exists(self.log_dir):
+                            os.makedirs(self.log_dir)
+                    except:
+                        self.enabled = False
+                        self.notify_of_error('Could not open a log output directory.  Logging will be disabled.')
+                finally:
+                    if self.verbose and self.enabled: print "Logging to " + self.log_dir
+        # setup a queue of parameters to write once next log entry
+        self.__queue = {}
+        
+        # register the tool name, version, and extra params with the log
+        self._register(tool_name, tool_version, **params)
+
+    def queue(self, **params):
+        ''' Queue any number of params for next call.  Returns log. '''
+        try:
+            for key in params: self.__queue[key] = deepcopy(params[key])
+        except:
+            self.notify_of_error("Could not set queue by dictionary.  Parameters were:\n"+str(params))
+        return self
+    
+    def get(self, key, default=None):
+        ''' Get the value of key from the params, return default if not found. '''
+        return self.__params.get(key, default)
+    
+    def set(self, **params):
+        ''' Set the value of params for all future calls.  Returns log. '''
+        try:
+            for key in params: self.__params[key] = deepcopy(params[key])
+        except:
+            self.notify_of_error("Could not set params.  Parameters were:\n"+str(params))
+        return self
+    
+    def set_machine_info(self, hostname=None, os_name=None, os_version=None, os_arch=None, hw_processor=None, **params):
+        ''' Set various attributes about the machine from which the log is being produced.  Returns log. '''
+        return self.set(local_hostname=hostname, local_os_name=os_name, local_os_version=os_version, local_os_arch=os_arch, local_hw_processor=hw_processor, **params)
+        
+    def make_child(self, tool_name, tool_version, parent_uuid=None, **params):
+        try:
+            child = deepcopy(self)
+            child.__init__(tool_name, tool_version, dict(parent=self), **params)
+            if parent_uuid: child.queue(event_parent_uuid=parent_uuid)
+            return child
+        except:
+            self.notify_of_error('Creating child log for ' + str(tool_name) + ' ' + str(tool_version))
+            return None
+    
+    ''' Tool-related helper methods. '''
+    def open(self, command_line=None, **params):
+        ''' Reports this tool was opened, pass in command line if known.  Returns log. '''
+        self('tool opened', command_line=command_line, **params)
+        return self
+    def close(self, command_line=None, results=None, status=None, success=None, **params):
+        ''' Reports this tool was closed. '''
+        self.running = False
+        self('tool closed', command_line=command_line, command_results=results, command_status=status, command_success=success, command_uuid=uuid() if command_line else None, **params)
+    
+    def command(self, name, results=None, status=None, success=None, *args, **params):
+        ''' A tool's internal command caused activity on the remote machine.  Returns event_uuid. '''
+        return self('command executed', command_name=name, command_args=str(args), command_results=results, command_status=status, command_success=success, command_uuid=uuid(), **params)
+    
+    def launch_from_command(self, command_name, tool_name, tool_version, **params):
+        ''' Reports that a command was run from this tool instance, spawning a child tool.  Returns log. ''' 
+        parent_uuid = self.command(command_name, **params)
+        child = self.make_child(tool_name, tool_version, parent_uuid)
+        return child
+    
+    def file_from_path(self, full_path, parent_uuid=None, **params):
+        ''' Upload a file given its local path.  Returns event_uuid. '''
+        try:
+            full_path = os.path.realpath(os.path.normpath(full_path))
+            (file_path, file_name) = os.path.split(full_path)
+            shutil.copyfile(full_path, self.basefilename()+'.'+file_name)
+        except: self.notify_of_error('Could not access file ' + full_path)
+        else: return self('remote file', parent_uuid, file_origin_name=file_name, file_origin_path=file_path, file_origin_created=datetime.utcfromtimestamp(os.path.getctime(full_path)).isoformat(' '), **params)
+        return None
+    
+    def file_from_content(self, content, storage_name, parent_uuid=None, **params):
+        ''' Upload a file given its content.  Returns event_uuid. '''
+        try:
+            storage_name = storage_name or "%s.txt"%(uuid())
+            full_path = self.basefilename()+'.'+storage_name
+            with open(full_path, 'wb') as f:
+                f.write(content.encode('utf-8'))
+        except: self.notify_of_error('Could not write file ' + full_path)
+        else: return self('remote file', parent_uuid, file_origin_name=storage_name, file_origin_path=None, file_origin_created=datetime.utcfromtimestamp(os.path.getctime(full_path)).isoformat(' '), **params)
+        return None
+    
+    def file_from_file(self, fd, parent_uuid=None, **params):
+        ''' Upload a file given an open file descriptor to a local path.  Returns event_uuid. '''
+        try: # if isinstance(fd,file)...
+            fd.flush()
+            return self.file_from_path(fd.name, parent_uuid, **params)
+        except:
+            self.notify_of_error('Could not access file descriptor for '+str(fd))
+            return None
+        
+    ''' Execution-related helper methods. '''
+    def start(self):
+        ''' Queues the start time of execution.  Results in stop time being marked by next log call.  Returns log. '''
+        return self.queue(start_time=datetime.utcnow())
+    
+    def execute_exploit(self, **params):
+        ''' Intended for use by other methods (success/fail).  Reports execution of an exploit from within this tool. Returns event_uuid.'''
+        return self('exploit executed', **params)
+    
+    def execute_tool(self, **params): return self(event_type='tool executed', **params)
+    def successful_exploit(self, **params): return self.execute_exploit(exploit_success=True, **params)
+    def failed_exploit(self, **params): return self.execute_exploit(exploit_success=False, **params)
+    
+    def execute_tool_from_command_line(self, command_line, **params):
+        ''' Reports execution of this tool and the command line that started it. '''
+        return self.execute_tool(command_line=command_line, **params)
+    def successful_exploit_from_command_line(self, command_line, **params):
+        ''' Reports successful exploitation from this tool and the command line that started it. '''
+        return self.successful_exploit(command_line=command_line, **params)
+    def failed_exploit_from_command_line(self, command_line, **params):
+        ''' Reports failed exploitation from this tool and the command line that started it. '''
+        return self.failed_exploit(command_line=command_line, **params)
+    
+    def successful_exploit_from_command(self, command, tool_name, tool_version, **params):
+        ''' Ran single-fire local command to exploit with sub-tool name/version.  Report successful exploit.  Return event_uuid. '''
+        return self.launch_from_command(command, tool_name, tool_version).successful_exploit(**params)
+    def failed_exploit_from_command(self, command, tool_name, tool_version, **params):
+        ''' Ran single-file local command to exploit with sub-tool name/version.  Report failed exploit.  Return event_uuid. '''
+        return self.launch_from_command(command, tool_name, tool_version).failed_exploit(**params)
+    
+    ''' Network-related helper methods. '''
+   
+    def interface_enabled(self, ip, project=None, mac=None, name=None, **params):
+        ''' Enable a network interface on the reporting machine. '''
+        return self(event_type='interface enabled', interface_ip=ip, interface_project=project, interface_mac=mac, interface_name=name, **params)
+    def interface_disabled(self, ip, project=None, mac=None, name=None, **params):
+        ''' Disable a network interface on the reporting machine. '''
+        return self(event_type='interface disabled', interface_ip=ip, interface_project=project, interface_mac=mac, interface_name=name, **params)
+    
+    def socket_opened(self, port, ip='0.0.0.0', project=None, is_tcp=None, is_udp=None, is_raw=None, **params):
+        ''' Open a local RAW/UDP or TCP LISTENing socket. '''
+        if is_raw or is_tcp or is_udp: return self(event_type='socket opened', socket_port=port, socket_ip=ip, socket_project=project, socket_is_raw=is_raw, socket_is_tcp=is_tcp, socket_is_udp=is_udp, **params)
+        else: self.notify_of_error('Could not open socket.  No socket type specified.')
+    def socket_closed(self, port, ip='0.0.0.0', project=None, is_tcp=None, is_udp=None, is_raw=None, **params):
+        ''' Close a local socket and any open connections. '''
+        if is_raw or is_tcp or is_udp: return self(event_type='socket closed', socket_port=port, socket_ip=ip, socket_project=project, socket_is_raw=is_raw, socket_is_tcp=is_tcp, socket_is_udp=is_udp, **params)
+        else: self.notify_of_error('Could not close socket.  No socket type specified.')
+    
+    def channel_opened(self, listen_ip, listen_port, redirect_from_ip, forward_to_ip, forward_to_port, is_tcp=None, listen_project=None, redirect_from_project=None, forward_to_project=None,  **params):
+        ''' Create a channel from a listening ip:port or [ip,...]:port to a redirector, from which data is forwarded to an ip:port. '''
+        return self(event_type='channel opened', channel_listen_ip=listen_ip, channel_listen_port=listen_port, channel_listen_project=listen_project, channel_forward_to_ip=forward_to_ip, channel_forward_to_port=forward_to_port, channel_forward_to_project=forward_to_project, channel_redirect_from_ip=redirect_from_ip, channel_redirect_from_project=redirect_from_project, channel_is_tcp=is_tcp, **params)
+    def channel_closed(self, listen_ip, listen_port, listen_project=None, **params):
+        ''' Terminate a channel from a listening ip:port or [ip,...]:port to a redirector, from which data is forwarded to an ip:port. '''
+        return self(event_type='channel closed', channel_listen_ip=listen_ip, channel_listen_port=listen_port, channel_listen_project=listen_project, **params)
+    
+    def connection_opened(self, source_ip, source_port, destination_ip, destination_port, is_tcp=None, source_project=None, destination_project=None, **params):
+        ''' Open (successfully) a direct connection between source (initiating) and destination (receiving) ip:port pairs. '''
+        return self(event_type='connection opened', connection_source_ip=source_ip, connection_source_project=source_project, connection_source_port=source_port, connection_destination_ip=destination_ip, connection_destination_project=destination_project, connection_destination_port=destination_port, connection_is_tcp=is_tcp, **params)
+    def connection_closed(self, source_ip, source_port, destination_ip, destination_port, is_tcp=None, source_project=None, destination_project=None, **params):
+        ''' Close a direct connection between source (initiating) and destination (receiving) ip:port pairs. '''
+        return self(event_type='connection closed', connection_source_ip=source_ip, connection_source_project=source_project, connection_source_port=source_port, connection_destination_ip=destination_ip, connection_destination_project=destination_project, connection_destination_port=destination_port, connection_is_tcp=is_tcp, **params)
+    
+    
+    # UNVETTED
+    def connection_refused(self, source_ip, source_port, destination_ip, destination_port, is_tcp=None, source_project=None, destination_project=None, **params):
+        ''' Connection from source ip:port to destination (listening) ip:port was refused. ''' 
+        return self(event_type='connection refused', connection_source_ip=source_ip, connection_source_project=source_project, connection_source_port=source_port, connection_destination_ip=destination_ip, connection_destination_project=destination_project, connection_destination_port=destination_port, connection_is_tcp=is_tcp, **params)
+    def connection_rejected(self, source_ip, source_port, destination_ip, destination_port, is_tcp=None, source_project=None, destination_project=None, **params):
+        ''' Connection from source ip:port to destination (listening) ip:port was rejected. ''' 
+        return self(event_type='connection rejected', connection_source_ip=source_ip, connection_source_project=source_project, connection_source_port=source_port, connection_destination_ip=destination_ip, connection_destination_project=destination_project, connection_destination_port=destination_port, connection_is_tcp=is_tcp, **params)
+    def connection_failed(self, source_ip, source_port, destination_ip, destination_port, is_tcp=None, source_project=None, destination_project=None, **params):
+        ''' Connection from source ip:port to destination (listening) ip:port failed. ''' 
+        return self(event_type='connection failed', connection_source_ip=source_ip, connection_source_project=source_project, connection_source_port=source_port, connection_destination_ip=destination_ip, connection_destination_project=destination_project, connection_destination_port=destination_port, connection_is_tcp=is_tcp, **params)
+    def trigger_sent(self, trigger_type, source_ip, source_port, target_ip, target_port, is_tcp=None, **params):
+        ''' Send a trigger from source ip:port at a target (probably locally listening) ip:port. '''
+        return self(event_type='trigger sent', trigger_source_ip=source_ip, trigger_source_port=source_port, trigger_target_ip=target_ip, trigger_target_port=target_port, trigger_type=trigger_type, **params)
+    
+
+    # Library Functionality
+    def basefilename(self):
+        return os.path.join(self.log_dir, self.prefix) + '.' + datetime.utcnow().strftime('%Y%m%d%H%M%S') + '.' + self.get('tool_name').lower()
+
+    def notify_of_warning(self,warning_string=''):
+        if self.enabled and self.verbose:
+            print "Warning:", warning_string
+            if self.debug:
+                exception_type, exception_value, exception_traceback = sys.exc_info()
+                print_exception(exception_type, exception_value, exception_traceback, limit=10, file=sys.stdout)
+    
+    def notify_of_error(self,error_string=''):
+        if self.enabled:
+            if self.verbose: print "Error:", error_string
+            if self.debug:
+                exception_type, exception_value, exception_traceback = sys.exc_info()
+                if self.verbose: print_exception(exception_type, exception_value, exception_traceback, limit=10, file=sys.stdout)
+                else:
+                    try:
+                        with open(self.basefilename()+'.error', 'a') as f:
+                            f.write('Error: '+str(error_string)+'\n')
+                            print_exception(exception_type, exception_value, exception_traceback, limit=10, file=f)
+                            self(event_type='error file', file_origin_name=f.name[f.name.rfind(self.get('tool_name').lower()):], file_origin_path=os.path.dirname(f.name), file_origin_created=datetime.utcfromtimestamp(os.path.getctime(f.name)).isoformat(' '))
+                    except:
+                        print 'Notice: The following is a notification of something gone awry and should not impact you operationally.'
+                        print 'Please save the following traceback and inform the developer.\nError:', error_string
+                        print_exception(exception_type, exception_value, exception_traceback, limit=10, file=sys.stdout)
+                        exception_type, exception_value, exception_traceback = sys.exc_info()
+                        print_exception(exception_type, exception_value, exception_traceback, limit=10, file=sys.stdout)
+
+    def _register(self, tool_name, tool_version, **params):
+        try:
+            def_pars = {'tool_name': str(tool_name) if tool_name else 'Unknown',
+                        'tool_version': str(tool_version) if tool_version else None,
+                        'instance_uuid': self.uuid,
+                        'instance_parent_uuid': self.parent.uuid if self.parent else None,
+                        'instance_log_version': version,
+                        }
+        except:
+            def_pars = {'tool_name': 'Unknown', 'tool_version': None, 'instance_uuid': uuid(), 'instance_parent_uuid': None, 'instance_log_version': version}
+            self.notify_of_warning('Tool parameters invalid.  Moving on.')
+        try:
+            self.__params = deepcopy(params)
+            for k in def_pars:
+                if not self.__params.has_key(k):
+                    self.__params[k] = def_pars[k]
+        except:
+            self.__params = def_pars
+            self.notify_of_warning('{params} passed were invalid and have been reset.  Moving on.')
+    
+    def __contains__(self,element):
+        try: return True if self[element] else True
+        except AttributeError: return False
+    
+    def __getitem__(self,key):
+        return self.__getattribute__(key) # removed  __getattr__(key) since get/setattr no longer defined
+    
+    def __setitem__(self,key,value):
+        self.__setattr__(key, value)
+        
+    def __call__(self, event_type='heartbeat', parent_uuid=None, event_time=None, **params):
+        ''' Basic log call.  At a minimum, this will write the tool name and version specified during init,
+            an event_type (heartbeat if not specified), a parent event (only if specified), and an event_time
+            (now if not specified). ''' 
+        try:
+            # build output dictionary
+            d = self._flatten(event_time=event_time if event_time else datetime.utcnow(),
+                              event_type=event_type,
+                              event_uuid=uuid(),
+                              event_parent_uuid=parent_uuid,
+                              **params)
+            
+            # mark stop time and replace event time with start time
+            if d.get('start_time'):
+                d['stop_time'] = d['event_time']
+                d['event_time'] = d['start_time']
+            
+            # write/append JSON entry to file    
+            if self.enabled:            
+                try:
+                    filename = self.basefilename() + '.json'
+                    with open(filename, 'a') as f:
+                        f.write(self._dumps(d)+'\n')
+                except:
+                    self.notify_of_error("Failed to generate output file.  Parameters were:\n"+str(params))
+                    try: os.remove(filename)
+                    except: pass
+                
+            return d['event_uuid']
+        except:
+            self.notify_of_error("Key error.  Parameters were:\n"+str(params))
+
+    def _flatten(self, **params):
+        try:
+            ret = self.__params.copy()
+            for k in self.__queue:
+                ret[k] = self.__queue[k]
+            self.__queue = {}
+            for k in params:
+                ret[k] = deepcopy(params[k])
+            return ret
+        except:
+            self.notify_of_error("Problem flattening log.  Parameters so far were:\n"+str(ret)+'\nParameters passed were:\n'+str(params))
+            return {}
+
+    def _dumps(self, obj):
+        return json.dumps(obj, cls=self._dtencoder)
+
+    class _dtencoder(json.JSONEncoder):
+        def default(self, obj):
+            if isinstance(obj, datetime): return obj.isoformat(' ')
+            return json.JSONEncoder.default(self, obj)
+        
+    """
+    def __getattr__(self,name):
+        return object.__getattribute__(self,lower(name))
+    
+    def __setattr__(self,name,value):
+        object.__setattr__(self, lower(name), value)
+        if isinstance(self.__getattr__(lower(name)), self.baselogtype):
+            self.__getattr__(name).log = self
+            self.__getattr__(name).name = lower(name)
+
+    import threading
+    def pacemaker(self, timeout=60):
+    #   This is a stand-alone heartbeat generator.  To pulse from your own control loop,
+    #   call your AbstractLog subclass instance event handler (e.g. AbstractLog['event']()
+        def __target(timeout=60):
+            if platform.uname()[0].lower() == "windows":
+                import win32con
+                import win32event
+                self.running = True
+                kill = win32event.CreateEvent(None, 1, 0, None)
+                pulse = win32event.CreateWaitableTimer(None, 0, None)
+                win32event.SetWaitableTimer(pulse, 0, timeout*1000, None, None, False)
+                while(self.running):
+                    try:
+                        result = win32event.WaitForMultipleObjects([kill, pulse], False, 1000)
+                        
+                        # if kill signal received, break loop
+                        if(result == win32con.WAIT_OBJECT_0): break
+                        # elif timeout has passed, generate a pulse
+                        elif(result == win32con.WAIT_OBJECT_0 + 1): self['event']()
+                    except:
+                        self.notify_of_error("Pacemaker shutdown.  Heartbeats will not be generated.")
+                        win32event.SetEvent(kill)
+            elif self.verbose: print "Pacemaker only supported in Windows at this time. " 
+       
+        try:
+            self.thread = threading.Thread(target=__target, args=(timeout,) )
+            #self.thread.start() NOT READY FOR DEPLOYMENT
+        except:
+            self.notify_of_error("Pacemaker thread exception.  Heartbeats will not be generated.")
+    """
\ No newline at end of file
diff --git a/windows/fuzzbunch/plugin.py b/windows/fuzzbunch/plugin.py
new file mode 100644
index 0000000..818ed19
--- /dev/null
+++ b/windows/fuzzbunch/plugin.py
@@ -0,0 +1,450 @@
+"""
+Fuzzbunch plugin base class
+
+Wraps the truantchild Config class to provide easy access to setting and
+getting parameters.
+
+"""
+import truantchild
+import exception
+import util
+import edfmeta
+
+
+__all__ = ["Plugin"]
+
+
+"""
+Decorators
+
+"""
+def setwrapper(f):
+    def wrap(*args, **kwargs):
+        try:
+            return f(*args, **kwargs)
+        except AttributeError:
+            raise exception.CmdErr, "Unknown parameter"
+        except (ValueError, TypeError, OverflowError):
+            raise exception.CmdErr, "Invalid value"
+        except (IOError, RuntimeError, ZeroDivisionError,
+                IndexError, SyntaxError, MemoryError) as err:
+            raise exception.CmdErr("TRCH internal : " + str(err))
+            
+    return wrap
+
+def resetwrapper(f):
+    def wrap(*args, **kwargs):
+        try:
+            return f(*args, **kwargs)
+        except AttributeError:
+            raise exception.CmdErr, "Unknown parameter"
+        except (IOError, RuntimeError, ZeroDivisionError,
+                IndexError, SyntaxError, MemoryError) as err:
+            raise exception.CmdErr("TRCH internal : " + str(err))
+    return wrap
+
+def getwrapper(f):
+    def wrap(*args, **kwargs):
+        try:
+            return f(*args, **kwargs)
+        except AttributeError:
+            raise exception.CmdErr, "Unknown parameter"
+    return wrap
+
+def safesetparameter(f):
+    """save and restore old value if new is invalid"""
+    def wrap(self, name, value):
+        old = self.get(name)
+        f(self, name, value)
+        if not self.hasValidValue(name):
+            self._trch_set(name, old)
+            raise exception.CmdErr, "Invalid value for '%s' (%s)" % (name, value)
+    return wrap
+
+def safesetchoice(f):
+    """Set a choice (cannot be invalid setting) and update
+    [non-hidden] parameters lower in the tree."""
+    def wrap(self, name, value):
+        paramcache = self.cache_choiceparams(name)
+        old = self.get(name)
+        f(self, name, value)
+        if not self.hasValidValue(name):
+            # Restore to the old
+            self._trch_set(name, old)
+            raise exception.CmdErr, "Invalid value for %s (%s)" % (name, value)
+        # We want var matches, not var/val 
+        for param in paramcache:
+            if param.name in util.iDict(self.cache_choiceparams(name)):
+                try:
+                    if not self.getParameter(param.name).isHidden():
+                        self.set(*param)
+                except (exception.CmdErr, AttributeError):
+                    # XXX Is ignoring errors here a good idea?
+                    pass
+    return wrap
+
+"""
+Plugin base class
+
+"""
+class Plugin(truantchild.Config):
+    def __init__(self, files, io):
+        import truantchild
+        from pytrch import TrchError as TruantchildError
+        try:
+            truantchild.Config.__init__(self, files)
+            self.param_order = edfmeta.parse_iparamorder(self.xmlInConfig)
+            self._curParams   = self._inputParams
+            self._defaults    = self.getParameters()
+
+            self.io = io            
+            self.touchlist = []     
+            self.redirection = {}
+            self.consolemode = util.CONSOLE_DEFAULT
+            self.lastsession = None
+        except AttributeError:
+            #print >>sys.stderr, "Plugin.__init__ failed to find an attribute - %s" % (str(e))
+            raise
+        except TruantchildError:
+            #print >>sys.stderr, "Plugin.__init__ failed to initialize Config - %s" % (str(e))
+            raise
+            
+    """
+    Parameter value set and get
+
+    """
+    def set(self, name, value, globalvars={}):
+        if self.isParameter(name):
+            self.set_parameter(name, util.variable_replace(value, globalvars))
+        else:
+            self.set_choice(name, util.variable_replace(value, globalvars))
+
+    def get(self, name):
+        """Get a specific parameter value"""
+        return self._trch_get(name)
+
+    @resetwrapper
+    def reset(self, name):
+        self._trch_reset(name)
+
+    @safesetparameter
+    def set_parameter(self, name, value):
+        """Set a parameter to value"""
+        self._trch_set(name, value)
+
+    @safesetchoice
+    def set_choice(self, name, value):
+        """Set a choice to a value."""
+        self._trch_set(name, value)
+
+    def cache_choiceparams(self, name):
+        """Cache values, Ignore hidden"""
+        paramcache = []
+        choice = self._trch_findparamchoice(name)
+        if choice:
+            for param in choice.getParameterList():
+                if param.name == name:
+                    continue
+                paramcache.append(param) 
+                paramcache += self.cache_choiceparams(param.name)
+        return paramcache
+
+    """
+    Individual Parameter Interface
+
+    """
+    def getDescription(self, name):
+        """Get the description of a parameter"""
+        return self._trch_getdescription(name)
+
+    def getType(self, name):
+        """Get the type of a parameter"""
+        return self._trch_gettype(name)
+
+    def getFormat(self, name):
+        """Get the format of a parameter"""
+        return self._trch_getformat(name)
+
+    def getAttributeList(self, name):
+        """Get the attribute list of a parameter"""
+        return self._trch_getattributelist(name)
+
+    def getParameter(self, name):
+        """Get the parameter struct"""
+        return self._trch_findoption(name)
+
+    def hasParameter(self, name):
+        if self.getParameter(name):
+            return True
+        else:
+            return False
+    
+    def isParamchoice(self, name):
+        return self._trch_isparamchoice(name)
+
+    def isParameter(self, name):
+        return self._trch_isparameter(name)
+
+    # Added to support fixing bug #2133
+    def isHiddenParameter(self, name):
+        """Given a parameter name, is that parameter hidden?"""
+        param = self.getParameter(name)
+        if self.isParameter(name):
+            return param.isHidden()
+        return False
+
+    """
+    Multiple parameters
+
+    """
+    def getParameters(self, hidden=True):
+        """Get the current parameter list"""
+        # Members of the plist array are dictionary items
+        plist = self._trch_getparameterlist()
+        if not hidden:
+            plist = [x for x in plist if not self.isHiddenParameter(x.name)]
+
+        if not self.param_order:
+            return plist
+
+        # Give them same order in which they appear in xml file
+        pdict = util.iDict(plist)
+        order = [ util.Param(pname, pdict.pop(pname) or "") 
+                      for pname in self.param_order
+                      if pname in pdict ]
+
+        return order + list(pdict.items())
+
+    def iterPromptParameters(self):
+        
+        # Take all the root level parameters first
+        rootparams = self._trch_getrootparameterlist()
+        for param in self.getParameters():
+            if self._trch_isparameter(param.name) and \
+               param in rootparams and \
+               not self.isHiddenParameter(param.name):
+                    yield param
+
+        # Walk all choices.  Need to take into account that setting a choice
+        # causes changes to everything below it.
+        usedchoices = []
+        done = False
+        while not done:
+            for param in self.getParameters():
+                if self._trch_isparamchoice(param.name) and \
+                   param.name not in usedchoices and \
+                   not self.isHiddenParameter(param.name):
+                    usedchoices.append(param.name)
+                    yield param
+                    break
+            else:
+                done = True
+        usedchoices += util.iDict(rootparams).keys()
+
+        # Now all the choices are stable, we can walk all params that are under
+        # a choice which is anything that we haven't looked at yet
+        for param in self.getParameters():
+            if self._trch_isparameter(param.name) and \
+               param.name not in usedchoices and \
+               not self.isHiddenParameter(param.name):
+                yield param
+
+    def getOutputParameters(self):
+        """Get the output parameter list"""
+        return self._trch_getoutputparameters()
+
+    def getDefaultParameters(self):
+        """Return the defaults parameters"""
+        return self._defaults
+
+    def setParameters(self, params):
+        for param in self.iterPromptParameters():
+            if param in params.items():
+                try:
+                    self.set(param.name, params[param.name])
+                except exception.CmdErr:
+                    self.io.print_warning("Skipping %s - Bad value" % param.name)
+                else:
+                    self.io.print_success("Set %s => %s" % (param.name, params[param.name]))
+
+        if self.redirection:
+            targetip   = params.get('targetip', None)
+            targetport = params.get('targetport', None)
+            callbackip = params.get('callbackip', None)
+
+            redir = self.getRedirection() 
+            if callbackip:
+                for r in redir['remote']:
+                    self.set(r.listenaddr, callbackip)
+            if targetip:
+                for l in redir['local']:
+                    # Only set this if we want the TargetIp
+                    if l.listenaddr == 'TargetIp':
+                        self.set(l.listenaddr, targetip)
+
+    """
+    Parameter validity
+
+    """
+    def hasValidValue(self, name):
+        """Check if a parameter of the whole set has a valid value"""
+        return self._trch_hasvalidvalue(name)
+
+    def isValid(self, name=None):
+        """Check if a parameter or the whole set is invalid"""
+        return self._trch_isvalid(name)
+
+    def getInvalid(self):
+        """Get a list of all parameters with invalid values"""
+        # XXX - Should be smarter about choices
+        return [ (param.name, param.value, self.getDescription(param.name))
+                 for param in self.getParameters()
+                 if not self.isValid(param.name) ]
+
+    """
+    Plugin execution
+
+    """
+    def execute(self, session, mode):
+        """Execute the plugin"""
+        pass
+
+    def validate(self):
+        """Validate the plugin"""
+        return True
+
+    def getSessionDescription(self):
+        """Extra information about a session"""
+        return ""
+
+    """
+    Rendezvous
+
+    """
+    def doRendezvous(self, value):
+        """Do required actions to complete EDF Rendezvous"""
+        return False
+
+    def createsRendezvous(self):
+        for name,val in self._outputParams.getParameterList():
+            if "Socket" == self._outputParams.findOption(name).getType():
+                return True
+        return False
+
+    """
+    Run Mode
+
+    """
+    def initConsoleMode(self):
+        self.consolemode = util.CONSOLE_DEFAULT
+
+    def getConsoleMode(self):
+        return self.consolemode
+
+    """
+    Redirection
+
+    """
+    def initRedirection(self):
+        self.redirection = {}
+
+    def getRedirection(self):
+        return self.redirection
+
+    def canRedirect(self):
+        if not self.redirection:
+            return False
+        if not self.redirection['remote'] and not self.redirection['local']:
+            return False
+        return True
+
+    def canDeploy(self):
+        return False
+        
+    """
+    Touches
+
+    """
+    def initTouches(self):
+        self.touchlist = []
+
+    def getTouchList(self):
+        return self.touchlist
+
+    def get_touch(self, index):
+        try:
+            return self.getTouchList()[index]
+        except IndexError:
+            raise exception.CmdErr, "Bad touch"
+
+    """
+    Truantchild abstractions
+    """
+    @setwrapper
+    def _trch_set(self, name, value):
+        """Set a parameter to a value"""
+        self._curParams.set(name, value)
+
+    @getwrapper
+    def _trch_get(self, name):
+        """Return the value of a parameter"""
+        return self._curParams.get(name)
+
+    def _trch_reset(self, name):
+        return self._curParams.reset(name)
+
+    @getwrapper
+    def _trch_getdescription(self, name):
+        return self._curParams.getDescription(name)
+
+    @getwrapper
+    def _trch_gettype(self, name):
+        return self._curParams.getType(name)
+
+    @getwrapper
+    def _trch_getformat(self, name):
+        return self._curParams.getFormat(name)
+
+    @getwrapper
+    def _trch_getattributelist(self, name):
+        return self._curParams.getAttributeList(name)
+
+    def _trch_findoption(self, name):
+        return self._curParams.findOption(name)
+
+    def _trch_isparamchoice(self, name):
+        return self._curParams.isParamchoice(name)
+
+    def _trch_isparameter(self, name):
+        return self._curParams.isParameter(name)
+
+    def _trch_findparamchoice(self, name):
+        return self._curParams.findParamchoice(name)
+
+    def _trch_getparameterlist(self):
+        return self._curParams.getParameterList()
+
+    def _trch_getrootparameterlist(self):
+        return self._curParams.getRootParameterList()
+
+    @getwrapper
+    def _trch_hasvalidvalue(self, name):
+        return self._curParams.hasValidValue(name)
+
+    @getwrapper
+    def _trch_isvalid(self, name):
+        return self._curParams.isValid(name)
+    
+    def _trch_addrendezvousparam(self, value):
+        self._curParams.addRendezvousParam(value)
+
+    def _trch_getoutputparameters(self):
+        return self._outputParams.getParameterList()
+
+    # Added to support fixing Bug #2133 
+    @getwrapper
+    def _trch_findparameter(self, name):
+        return self._curParams.findParameter(name)
+
+
+
diff --git a/windows/fuzzbunch/pluginfinder.py b/windows/fuzzbunch/pluginfinder.py
new file mode 100644
index 0000000..a7a0061
--- /dev/null
+++ b/windows/fuzzbunch/pluginfinder.py
@@ -0,0 +1,93 @@
+import pluginmanager
+import sys
+import os
+import exception
+
+mswindows = (sys.platform == "win32")
+
+if mswindows:
+    BINARY_EXT = (".exe",".py")
+else:
+    BINARY_EXT = ("", ".py")
+
+FB_CONFIG_EXT = ".fb"
+PLUGIN_CONFIG_EXT = ".xml"
+
+class PluginfinderError(Exception):
+    pass
+
+def getextensionfiles(location, ext):
+    return [file 
+            for file in os.listdir(location) 
+            if file.endswith(ext)]
+
+def configlistsearch(configlist, item):
+    for file in configlist:
+        if file.startswith(item):
+            return configlist.index(file)
+    return None
+
+def getpluginlist(location, bin):
+    """@brief   Get a list of available plugins from a given directory
+    
+    @param  location        Directory to search for plugins
+    @param  bin             Is what we're trying to load binary?
+    """
+    fblist     = getextensionfiles(location, FB_CONFIG_EXT)         # get list of .fb files
+    configlist = getextensionfiles(location, PLUGIN_CONFIG_EXT)     # get list of .xml files
+    dirlist    = os.listdir(location)
+    pluginlist = []
+    
+    for config in configlist:
+        base    = ".".join(config.split(".")[:-2])
+
+        # Try to find a corresponding .fb file for each .xml file
+        fbindex = configlistsearch(fblist, base)
+        if fbindex is not None:
+            if bin:
+                for ext in BINARY_EXT:
+                    if base + ext in dirlist:
+                        # Add a tuple containing (config, executable, fbfile) to pluginlist
+                        pluginlist.append((os.path.join(location, config),
+                                           os.path.join(location, base + ext),
+                                           os.path.join(location, fblist[fbindex])))
+            else:
+                # Cover the case in which we don't have an executable file 
+                pluginlist.append((os.path.join(location, config),
+                                   "noFile",
+                                   os.path.join(location, fblist[fbindex])))
+    return pluginlist
+
+
+def addplugins(fb, type, location, constructor, manager=pluginmanager.PluginManager, bin=True):
+    """
+    @brief Enumerate available plugins and add them to the fuzzbunch pluginmanager
+
+    @param fb           Fuzzbunch object
+    @param type         String with the type of plugin to add (Exploit, Payload,  Touch, etc...)
+    @param location     The disk location to look for that type of plugin
+    @param constructor  Constructor to use to instantiate the plugin
+    """
+    # Get a list of tuples for the available plugins in 'location'
+    # Each entry will be (config, executable, fbfile)
+    
+    #
+    # XXX Should we ensure the directories exist and load nothing, or 
+    # fail, in the event the directory doesn't exist already.
+    #
+    plugins = getpluginlist(location, bin)
+    manager = fb.register_manager(type, manager)
+    
+    for plugin in plugins:
+        try:
+            manager.add_plugin(plugin, constructor)
+        except exception.PluginXmlErr:
+            # We encountered an error in the plugin's XML file.  We don't want
+            # this to kill execution of Fuzzbunch
+            import os.path
+            (d,f) = os.path.split(plugin[0])
+            n = f.split('-')[0]
+            fb.io.pre_input(None)
+            fb.io.print_warning("Failed to load %s - XML Error" % (str(n)))
+            fb.io.post_input()
+
diff --git a/windows/fuzzbunch/pluginmanager.py b/windows/fuzzbunch/pluginmanager.py
new file mode 100644
index 0000000..4e1d9ec
--- /dev/null
+++ b/windows/fuzzbunch/pluginmanager.py
@@ -0,0 +1,743 @@
+"""
+    EDF Plugin Manager
+
+"""
+from command   import CmdCtx
+from iohandler import truncate
+import exception
+import util
+import traceback
+
+MAX_PARAM_ECHO_LEN = 60
+
+EDF_PLUGIN_INFO = """
+    Name: %s
+ Version: %s
+    Type: %s
+"""
+
+__all__ = ["PluginManager"]
+
+class PluginManager(CmdCtx):
+    """A PluginManager maintains a list of available plugins OF A GIVEN TYPE.  For
+    instance, one PluginManager will exist for each of exploits, touches, payloads, etc.
+    It also extends the commands available to interact with various plug-ins.  Extension
+    commands are:
+    * apply
+    * execute
+    * export
+    * prompt
+    * rendezvouz
+    * reset
+    * touch
+    * validate
+
+    """
+    def __init__(self, type, fb):
+        CmdCtx.__init__(self, type, type)
+        self.pluginList = util.iDict()
+        self.activePlugin = None
+        self.session = fb.session
+        self.io = fb.io
+        self.fb = fb
+
+    """
+    Plugin Management
+
+    """
+    def add_plugin(self, files, Constructor):
+        from pytrch import TrchError as TruantchildError
+        try:
+            item = Constructor(files, self.io)
+            try:
+                self.pluginList[item.getName()] = item 
+            except AttributeError:
+                # We're in MinSizeRel
+                name = files[0].split('-')[0]
+                self.pluginList[name] = item
+        except TruantchildError, e:
+            # If we fail to process something, don't load this plugin, but also don't fail
+            # to load the other plugins
+            raise exception.PluginXmlErr(str(e))
+
+    def get_plugin(self, name):
+        try:
+            return self.pluginList[name]
+        except KeyError:
+            raise exception.CmdErr, "'%s' not a valid %s" % (name, self.get_type())
+
+    def get_plugins(self):
+        for plugin in self.pluginList.values():
+            yield plugin
+        return 
+
+    def get_plugin_names(self):
+        return self.pluginList.keys()
+
+    def get_active_name(self):
+        if self.activePlugin:
+            return self.get_name()
+        else:
+            return "None"
+
+    def set_active_plugin(self, name):
+        self.activePlugin = self.get_plugin(name)
+        self.name = self.activePlugin.getName()
+
+    def unset_active_plugin(self):
+        self.activePlugin = None
+        self.name = self.type
+
+    def get_active_plugin(self):
+        return self.activePlugin
+
+    
+    """
+    Current context info 
+
+    """
+    def print_info(self, pname=None):
+        """Get the currently active plugin and print various 
+        informational items about it: 
+        * Name, Version, Type
+        * Redirection information
+        * Parameters established for that context
+        """
+        if pname == None:
+            plugin = self.get_active_plugin()
+        else:
+            plugin = self.get_plugin(pname)
+
+        # XXX - Output Fix
+        self.io.write(EDF_PLUGIN_INFO % (plugin.getName(), 
+                                         plugin.getVersion(),
+                                         self.get_type()))
+        #self.io.write(plugin.getBinaryHash() + "\n")
+        #self.io.write(plugin.getConfigHash() + "\n")
+        #self.io.write(plugin.getMetaHash() + "\n")
+                                         
+
+        self.io.write("Redirection:")
+        self.io.print_redir_info(plugin.getRedirection(), 
+                                 plugin.getParameters())
+
+        # Bug #2133: Fix this so that hidden parameters are cached but not
+        # displayed
+        self.io.write("Parameters:")
+        params = [ (param[0], param[1], plugin.getDescription(param[0]))
+                   for param in plugin.getParameters(hidden=False) ]
+        self.io.print_param_list(params)
+
+    """
+    Main plugin routines
+
+    """
+    def complete_execute(self, text, line, arglist, state, begidx, endidx):
+        cmap = dict([(val,key) for key,val in util.consolemode_map.items()])
+        clist = [cmap[util.CONSOLE_REUSE], cmap[util.CONSOLE_NEW]]
+
+        if state == 1:
+            return [item 
+                    for item in sorted(clist)
+                    if item.lower().startswith(text.lower())]
+        return [""]
+
+    def help_execute(self):
+        usage = ["execute [mode]",
+                 "Executes the current plugin. Mode specifies to",
+                 "open a new window or reuse the current console.",
+                 "Plugin default will be used if mode is not specified",
+                 "Modes:",
+                 "  new      Run plugin in a new window",
+                 "  reuse    Reuse the current window",
+                 "  default  Use the plugin default"]
+        self.io.print_usage(usage)
+
+    def exe_print_params(self, plugin, redirid):
+        args = {'title'   : plugin.getName(),
+                'session' : self.fb.redirection.get_session(redirid),
+                'vars'    : plugin.getParameters(hidden=True)}
+        self.io.print_exe_set_names(args)
+
+    def do_execute(self, input):
+        """Execute the current plugin"""
+        session = None
+        self.io.newline()
+        inputList = input.strip().split()
+        if len(inputList) > 0:
+            consolemode = inputList[0].lower()
+            consolemode = util.convert_consolemode(consolemode)
+        else:
+            consolemode = 0
+
+        plugin = self.get_active_plugin()
+        self.io.print_warning("Preparing to Execute %s" % plugin.name)
+        if plugin.validate(self.session.get_dirs(), globalvars=self.fb.fbglobalvars) and plugin.isValid():
+            # XXX - Get the description before redirection.
+            # This really should be fixed to not care about order
+            plugin_desc = plugin.getSessionDescription()
+            redirid = self.fb.redirection.pre_exec(plugin)
+            
+            try:
+                # Last chance to quit, print execution info and prompt
+                if redirid:
+                    self.fb.redirection.print_session(redirid)
+                    #self.fb.do_redirect("")
+                    self.io.print_warning("Verify Redirection Tunnels Exist")
+                    self.io.prompt_confirm_redir()
+                self.exe_print_params(plugin, redirid)
+                self.io.prompt_continue()
+                self.io.print_msg("Executing Plugin")
+                if self.fb.log:
+                    self.fb.log[plugin.name] = self.fb.log.launch_from_command('execute', plugin.getName(), plugin.getConfigVersion()).start()
+                # Generate a new session and execute
+                session = self.session.add_item(plugin.getName(),
+                                                plugin_desc)
+                newwindow, logfile = plugin.execute(session, 
+                                                    consolemode, 
+                                                    self.fb.is_interactive(),
+                                                    self.fb.is_scripted(),
+                                                    globalvars=self.fb.fbglobalvars,
+                                                    runMode="FB")
+            except Exception as e:
+                self.io.print_error("Error running plugin: {0}".format(e))
+                newwindow = False
+                session = None
+            finally:
+                self.fb.redirection.post_exec(plugin, redirid)
+                if self.fb.log and plugin.name in self.fb.log:
+                    try:
+                        try: session
+                        except: pass
+                        else:
+                            if 'Project' in self.fb.fbglobalvars: self.fb.log[plugin.name].set(project_name=self.fb.fbglobalvars['Project'])
+                            self.fb.log[plugin.name].queue(**dict([(k,v) for k,v in session.history.params.values()]+[(v[0],v[1]) for v in session.contract.params.values()]))
+                            if session.is_failed(): parent = self.fb.log[plugin.name].failed_exploit()
+                            else: parent = self.fb.log[plugin.name].successful_exploit()
+                            self.fb.log[plugin.name].file_from_path(logfile, parent)
+                    except:
+                        if self.fb.log: self.fb.log.notify_of_error('Recording use of ' + str(plugin.name))
+
+            if newwindow:
+                self.io.print_warning("Plugin Spawned in New Console - Running Detached")
+            else:
+                if session and not session.is_failed():
+                    self.io.print_success("%s Succeeded" % plugin.name)
+                    if plugin.createsRendezvous():
+                        self.io.newline()
+                        self.io.print_warning("Connection to Target Established")
+                        self.io.print_warning("Waiting For Next Stage")
+                else:
+                    raise exception.CmdErr, "%s Failed" % plugin.name
+        else:
+            #self.do_validate()
+            raise exception.CmdErr, "Execution Aborted"
+        self.io.newline()
+
+
+    def help_validate(self):
+        usage = ["validate",
+                 "Validates the current plugin parameters"]
+        self.io.print_usage(usage)
+
+    def do_validate(self, *ignore):
+        """Validate the current parameter settings"""
+        plugin = self.get_active_plugin()
+
+        self.io.print_msg("Checking %s parameters" % plugin.getName())
+        self.io.newline()
+        if plugin.validate(self.session.get_dirs(), globalvars=self.fb.fbglobalvars) and self.activePlugin.isValid():
+            self.io.print_success("Parameters are valid")
+        else:
+            self.io.print_error("Parameter check failed")
+            #self.io.print_param_list(plugin.getInvalid())    
+    
+    """
+    Session parameter inheritance
+
+    """
+    def complete_apply(self, text, line, arglist, state, begidx, endidx):
+        """Command completion for apply command."""
+        # XXX - one might not be good to have completion for
+        itemList = [str(i) 
+                    for i,item in enumerate(sorted(self.session.get_itemlist()))]
+        if state == 1:
+            return [i for i in itemList if i.startswith(text)]
+        return [""]
+
+    def help_apply(self):
+        usage = ["apply [index]",
+                 "Inherits the output parameters from plugins that",
+                 "are marked READY and input parameters from all",
+                 "plugins in the session history. Specify an index",
+                 "to inherit parameters from a specific session",
+                 "regardless of state"]
+        self.io.print_usage(usage)
+
+    def apply_prompt(self, var, vals, plugin, singlemode=False):
+        if var.lower() == "rendezvous":
+            default = None
+        else:
+            default = plugin.get(var)
+
+        if not default:
+            default = ""
+
+        # vals is a list of oParams
+        if len(vals) == 1 or singlemode:
+            (param, contract) = vals[0]
+        else:
+            params = {'default'  : default,
+                      'variable' : var,
+                      'vals'     : vals}
+            self.io.print_apply_prompt(params)
+
+            line = self.io.prompt_user(var, "0")
+            if line == "":
+                line = "0"
+            try:
+                index = int(line)
+            except ValueError:
+                raise exception.CmdErr, "Invalid Input"
+
+            if index == len(vals):
+                # picked current
+                self.io.print_success("Using current val for %s" % var)
+                return True
+            else:
+                try:
+                    (param, contract) = vals[int(line)]
+                except (IndexError, ValueError):
+                    raise exception.CmdErr, "Invalid Input"
+
+        if var.lower() == "rendezvous":
+            sval = param.value.value
+            plugin.doRendezvous(sval)
+        else:
+            if param.value.format.lower() == plugin.getFormat(var).lower():
+                # scalar => scalar or
+                # list => list
+                sval = param.value.value
+            elif param.value.format.lower() == 'scalar':
+                # scalar => list
+                sval = util.scalar_to_list(param.value)
+            else:
+                # list => scalar
+                vals = util.parse_param_list(param.value.value, param.value.type)
+                if not vals:
+                    raise exception.CmdErr, "Invalid Input"
+
+                params = {'default'  : "",
+                          'contract' : contract.get_item_info(),
+                          'variable' : var,
+                          'vals'     : vals}
+                self.io.print_apply_prompt_list(params)
+                line = self.io.prompt_user(var, "0")
+                if line == "":
+                    line = "0"
+
+                try:
+                    index = int(line)
+                except IndexError:
+                    raise exception.CmdErr, "Invalid Input"
+
+                if index == len(vals):
+                    #picked current
+                    self.io.print_success("Using current val for %s" % var)
+                    return True
+                else:
+                    try:
+                        sval = vals[index]
+                    except (IndexError, ValueError):
+                        raise exception.CmdErr, "Invalid Input"
+
+            plugin.set(var, sval, globalvars=self.fb.fbglobalvars)
+
+        if contract:
+            contract.mark_used()
+        self.io.print_success("Set %s => %s" % (var, sval))
+
+        return True
+
+    def apply_singleloop(self, var, params, plugin, singlemode=False):
+        done = None
+        while not done:
+            try:
+                if var not in params:
+                    raise exception.CmdErr, "Unknown var"
+                done = self.apply_prompt(var, params[var], plugin, singlemode)
+            except exception.PromptErr, err:
+                raise 
+            except exception.CmdErr, err:
+                self.io.print_error(err.getErr())
+                # With errors, continue on, skipping param
+                self.io.print_error("Skipping '%s'" % var)
+                done = True
+
+    def apply_process(self, params, plugin, singlemode=False):
+        self.io.print_msg("Applying Session Parameters")
+        # Iterate over the plugin's parameters
+        for var,val in plugin.iterPromptParameters():
+            if var.lower() == "rendezvous":
+                continue
+            if var in params:
+                self.apply_singleloop(var, params, plugin, singlemode)
+
+        for k in params.keys():
+            if k.lower() == "rendezvous" and plugin.hasParameter("ConnectedTcp"):
+                self.apply_singleloop("Rendezvous", params, plugin, singlemode)
+
+    def do_apply(self, input):
+        """Apply parameters values from session items"""
+        plugin = self.get_active_plugin()
+        params = util.iDict()
+
+        inputList = input.strip().split()
+        if not inputList:
+            # Case where we just type 'apply'
+            for contract in self.session.get_contractlist():
+                for param in contract.get_paramlist():
+                    params.setdefault(param.name, []).append((param, contract))
+            self.apply_process(params, plugin)
+        else:
+            # Case where we type 'apply X'
+            try:
+                index = int(inputList[0])
+            except ValueError:
+                raise exception.CmdErr, "apply [index]"
+
+            contract = self.fb.session.get_contract(index)
+            for param in contract.get_paramlist():
+                params[param.name] = [(param, contract)]
+            self.apply_process(params, plugin, singlemode=True)
+            
+
+    """
+    Interactive prompt mode
+
+    """
+    def help_prompt(self):
+        usage = ["prompt",
+                 "Walks through plugin parameters prompting the user to set",
+                 "a value for each one"]
+        self.io.print_usage(usage)
+
+    def prompt_param(self, name, value, plugin):
+        """Prompt for a parameter, and set the value in the session on response"""
+        valid_convert = {1 : "YES", 0 : "NO"}
+        param      = plugin.getParameter(name)
+        attribs    = util.iDict(param.getAttributeList())
+        attribvals = param.getAttributeValueList()
+
+        args = {'name'        : name,
+                'value'       : value,
+                'description' : attribs['Description'],
+                'required'    : attribs['Required'],
+                'valid'       : valid_convert[plugin.isValid(name)],
+                'type'        : attribs.get('Type', "Choice"),
+                'attribs'     : attribvals,}
+
+        if plugin.isParamchoice(name):
+            default_value = ""
+            for i,p in enumerate(attribvals):
+                if p.name.lower() == value.lower():
+                    default_value = str(i)
+        else:
+            default_value = value
+
+        self.io.print_prompt_param(args, default_value)
+        line = self.io.prompt_user(name, default_value, attribvals, gvars=self.fb.fbglobalvars)
+        if line != value:
+            self.do_set(name + " " + line)
+
+        if plugin.hasValidValue(name):
+            return True
+        else:
+            return False
+
+    def prompt_param_help(self, name, value, plugin):
+        valid_convert = {1 : "YES", 0 : "NO"}
+        param      = plugin.getParameter(name)
+        attribs    = util.iDict(param.getAttributeList())
+        attribvals = param.getAttributeValueList()
+
+        args = {'name'        : name,
+                'value'       : value,
+                'description' : attribs['Description'],
+                'required'    : attribs['Required'],
+                'valid'       : valid_convert[plugin.isValid(name)],
+                'type'        : attribs.get('Type', "Choice"),
+                'attribs'     : attribvals,}
+        self.io.print_prompt_param_help(args)
+
+    def do_prompt(self, input):
+        """Walk through all parameters prompting for a value for each one"""
+        plugin = self.get_active_plugin()
+        self.io.newline()
+        self.io.print_warning("Enter Prompt Mode :: %s" % plugin.name)
+
+        inputList = input.strip().split()
+        if len(inputList) == 1 and inputList[0].lower() == "confirm":
+            self.do_set("")
+            if plugin.isValid():
+                self.io.print_warning("plugin variables are valid")
+            else:
+                self.io.print_warning("Plugin Variables are NOT Valid")
+            if not self.io.prompt_runsubmode("Prompt For Variable Settings?"):
+                self.io.print_warning("Skipping Prompt")
+                if self.fb.log: self.fb.log.command('prompt', '%s %s configured with default parameters'%(plugin.getName(),plugin.getConfigVersion()))
+                return
+
+        for name, value in plugin.iterPromptParameters():
+            done = None
+            while not done:
+                try:
+                    done = self.prompt_param(name, value, plugin)
+                except exception.PromptHelp, err:
+                    self.prompt_param_help(name, value, plugin)
+                except exception.PromptErr, err:
+                    raise
+                except exception.CmdErr, err:
+                    self.io.print_error(err.getErr())
+        self.io.newline()
+        if self.fb.log: self.fb.log.command('prompt', '%s %s configured with manually entered parameters'%(plugin.getName(),plugin.getConfigVersion()))
+
+    """
+    Parameter handling user commands
+
+    """
+    def complete_set(self, text, line, arglist, state, begidx, endidx):
+        paramlist = self.get_active_plugin().getParameters(hidden=False)
+
+        if state == 1:
+            return [item[0] 
+                    for item in sorted(paramlist) 
+                    if item[0].upper().startswith(text.upper())]
+        elif state == 2:
+            if arglist[1] not in dict(paramlist):
+                return [""]
+            else:
+                try:
+                    plugin = self.get_active_plugin()
+                    param  = plugin.getParameter(arglist[1])
+                    if plugin.isParamchoice(arglist[1]):
+                        attribVal = param.getAttributeValueList()
+                        return [attr.name
+                                for attr in attribVal
+                                if attr.name.upper().startswith(text.upper())]
+                except exception.CmdErr:
+                    return [""]
+        else:
+            return [""]
+
+    def help_set(self):
+        usage = ["set [parameter] [value]",
+                 "Set a configuration parameter.  This command is context",
+                 "sensitive and will set options for the active plugin context",
+                 "only.  Set with no arguments will show all parameters and",
+                 "values.",
+                 "  L:value  - Input ascii string to widechar",
+                 "  H:value  - Input hex string"]
+        self.io.print_usage(usage)
+
+    @util.charconvert
+    def do_set(self, input):
+        """Set a configuration parameter"""
+        plugin    = self.get_active_plugin()
+        inputList = input.strip().split()
+        if not inputList:
+            # Print the list of parameters
+
+            args = {'title' : plugin.getName(),
+                    'vars'  : plugin.getParameters(hidden=False)}
+            self.io.print_set_names(args)
+        elif len(inputList) == 1:
+            param = plugin.getParameter(inputList[0])
+            try:
+                # XXX - Output Fix
+                attribList = param.getAttributeList()
+                self.io.print_set_attributes(plugin.getName(),
+                                             inputList[0],
+                                             attribList)
+                if plugin.isParamchoice(inputList[0]):
+                    attribVal = param.getAttributeValueList()
+                    self.io.print_set_choices(attribVal)
+            except AttributeError:
+                raise exception.CmdErr, "set [param] [value]"
+        elif len(input) >= 2:
+            set_value = " ".join(inputList[1:])
+            plugin.set(inputList[0], set_value, globalvars=self.fb.fbglobalvars)
+            self.io.print_success("Set %s => %s" % (inputList[0], truncate(set_value)))
+
+    """
+    Parameter reset 
+
+    """
+    def complete_reset(self, text, line, arglist, state, begidx, endidx):
+        paramlist = self.get_active_plugin().getParameters()
+        if state == 1:
+            return [item[0] 
+                    for item in sorted(paramlist) 
+                    if item[0].upper().startswith(text.upper())]
+        return [""]
+
+    def help_reset(self):
+        usage = ["reset [parameter]",
+                 "Reset a configuration parameter to default"]
+        self.io.print_usage(usage)
+
+    def do_reset(self, input):
+        """Reset a configuration parameter"""
+        plugin    = self.get_active_plugin()
+        inputList = input.strip().split()
+        if not inputList:
+            args = {'title' : plugin.getName(),
+                    'vars'  : plugin.getParameters()}
+            self.io.print_set_names(args)
+        elif len(inputList) == 1:
+            plugin.reset(inputList[0])
+            self.io.print_success("Reset %s" % inputList[0])
+        else:
+            raise exception.CmdErr, "Invalid input"
+
+    """
+    Parameter exporting to globals
+
+    """
+    def complete_export(self, text, line, arglist, state, begidx, endidx):
+        paramlist = self.get_active_plugin().getParameters()
+        if state == 1:
+            return [item[0] 
+                    for item in sorted(paramlist) 
+                    if item[0].upper().startswith(text.upper())]
+        return [""]
+
+    def help_export(self):
+        usage = ["export [parameter] [globalname]",
+                 "Export a configuration parameter to the global namespace."]
+        self.io.print_usage(usage)
+
+    def do_export(self, input):
+        """Export a local parameter as a global"""
+        plugin    = self.get_active_plugin()
+        inputList = input.strip().split()
+        if not inputList:
+            args = {'title' : plugin.getName(),
+                    'vars'  : plugin.getParameters()}
+            self.io.print_set_names(args)
+        elif len(inputList) == 1:
+            param = plugin.getParameter(inputList[0])
+            try:
+                # XXX - Output Fix
+                attribList = param.getAttributeList()
+                self.io.print_set_attributes(plugin.getName(),
+                                             inputList[0],
+                                             attribList)
+                if plugin.isParamchoice(inputList[0]):
+                    attribVal = param.getAttributeValueList()
+                    self.io.print_set_choices(attribVal)
+            except AttributeError:
+                raise exception.CmdErr, "export [param] [globalname]"
+        elif len(input) >= 2:
+            value = plugin.get(inputList[0])
+            self.fb.do_setg("%s %s" % (inputList[1], value))
+        
+    """
+    Touch support
+
+    """
+    def complete_touch(self, text, line, arglist, state, begidx, endidx):
+        plugin = self.get_active_plugin()
+        if state == 1:
+            return [str(i) for i in range(0, len(plugin.getTouchList()))]
+        return [""]
+
+    def help_touch(self):
+        usage = ["touch [index | all]",
+                 "Run a touch associated with the current plugin.",
+                 "Specify an index to run a single touch. Specify",
+                 "all to run all touches."]
+        self.io.print_usage(usage)
+
+    def touch_mapinput(self, plugin, touch):
+        self.io.print_msg("Inheriting Input Variables")
+        for param in touch["iparams"].items():
+            self.fb.runcmd_noex("set %s %s" % param)
+        for param in touch["ivparams"].items():
+            try:
+                val = plugin.get(param.value)
+                if val:
+                    self.fb.runcmd_noex("set %s %s" % (param.name, val))
+            except exception.CmdErr:
+                pass
+
+    def touch_mapoutput(self, plugin, touch, contract):
+        self.io.print_msg("Exporting Contract To Exploit")
+        params = util.iDict()
+        for param in contract.get_paramlist():
+            params[param.name] = [(param, contract)]
+            if param.name in touch['oparams']:
+                params[ touch['oparams'][param.name] ] = [(param, contract)]
+
+        for var,val in plugin.iterPromptParameters():
+            if var in touch['oparams'].values():
+                self.apply_singleloop(var, params, plugin, True)
+    
+    def touch_single(self, plugin, index):
+        touch  = plugin.get_touch(index)
+
+        self.fb.runcmd_noex("use %s" % touch["name"])
+        touchplugin = self.fb.get_manager("Touch").get_active_plugin()
+        touchplugin.lastsession = None
+
+        self.touch_mapinput(plugin, touch)
+        self.fb.runcmd_noex("prompt")
+        self.fb.runcmd_noex("execute")
+        # This looks like a bug, but lastsession is actually modified in edfplugin.execute
+        self.touch_mapoutput(plugin, touch, touchplugin.lastsession.contract)
+        if touch["postmsg"]:
+            self.io.print_warning(touch["postmsg"])
+
+
+    def do_touch(self, input):
+        """Run a touch plugin"""
+        argc, argv = util.parseinput(input, 1)
+        if argc == 0:
+            args = {'touchlist': [ (t["displayname"], t["description"], t["name"])
+                                   for t in self.get_active_plugin().getTouchList() ]}
+            self.io.print_touch_info(args)
+        elif argc == 1:
+            if argv[0].lower() == 'all':
+                index = None
+            else:
+                try:
+                    index = int(argv[0])
+                except (IndexError, ValueError):
+                    raise exception.CmdErr, "Bad touch"
+
+            plugin = self.get_active_plugin()
+            try:
+                if index is None:
+                    for i in range(0, len(plugin.getTouchList())):
+                        self.touch_single(plugin, i)
+                else:
+                    self.touch_single(plugin, index)
+            finally:
+                self.fb.runcmd_noex("enter %s" % self.type)
+        self.io.newline()
+
+    """
+    Rendezvous
+
+    """
+    def help_rendezvous(self):
+        usage = ["rendezvous",
+                 "Adds a rendezvous input parameter.  This is part of",
+                 "the oh-shit button."]
+        self.io.print_usage(usage)
+
+    def do_rendezvous(self, input):
+        """Create a rendezvous input parameter"""
+        self.get_active_plugin().doRendezvous("0")
+
+
diff --git a/windows/fuzzbunch/pyreadline/__init__.py b/windows/fuzzbunch/pyreadline/__init__.py
new file mode 100644
index 0000000..893acf1
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/__init__.py
@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+import logger,clipboard,lineeditor,modes
+from rlmain import *
+__all__ = [ 'parse_and_bind',
+            'get_line_buffer',
+            'insert_text',
+            'clear_history',
+            'read_init_file',
+            'read_history_file',
+            'write_history_file',
+            'get_history_length',
+            'set_history_length',
+            'set_startup_hook',
+            'set_pre_input_hook',
+            'set_completer',
+            'get_completer',
+            'get_begidx',
+            'get_endidx',
+            'set_completer_delims',
+            'get_completer_delims',
+            'add_history',
+            'GetOutputFile']
+
+import release 
diff --git a/windows/fuzzbunch/pyreadline/clipboard/__init__.py b/windows/fuzzbunch/pyreadline/clipboard/__init__.py
new file mode 100644
index 0000000..66a8419
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/clipboard/__init__.py
@@ -0,0 +1,73 @@
+import sys
+success=False
+in_ironpython="IronPython" in sys.version
+if in_ironpython:
+    try:
+        from ironpython_clipboard import GetClipboardText,SetClipboardText
+        success=True
+    except ImportError:
+        pass
+else:
+    try:
+        from win32_clipboard import GetClipboardText,SetClipboardText
+        success=True
+    except ImportError:
+        raise    
+    
+
+def send_data(lists):
+    SetClipboardText(make_tab(lists))
+    
+
+def set_clipboard_text(toclipboard):
+    SetClipboardText(str(toclipboard))
+
+def make_tab(lists):
+    if hasattr(lists,"tolist"):
+        lists=lists.tolist()
+    ut=[]
+    for rad in lists:
+        if type(rad) in [list,tuple]:
+            ut.append("\t".join(["%s"%x for x in rad]))
+        else:
+            ut.append("%s"%rad)
+    return "\n".join(ut)            
+    
+def make_list_of_list(txt):
+    def make_num(x):
+        try:
+            return int(x)
+        except ValueError:
+            try:
+                return float(x)
+            except ValueError:
+                try:
+                    return complex(x)
+                except ValueError:
+                    return x
+        return x                
+    ut=[]
+    flag=False
+    for rad in [x for x in txt.split("\r\n") if x!=""]:
+        raden=[make_num(x) for x in rad.split("\t")]
+        if str in map(type,raden):
+            flag=True
+        ut.append(raden)
+    return ut,flag
+
+
+def get_clipboard_text_and_convert(paste_list=False):
+    """Get txt from clipboard. if paste_list==True the convert tab separated 
+    data to list of lists. Enclose list of list in array() if all elements are 
+    numeric"""
+    txt=GetClipboardText()
+    if txt:
+        if paste_list and "\t" in txt:
+            array,flag=make_list_of_list(txt)
+            if flag:
+                txt=repr(array)
+            else:
+                txt="array(%s)"%repr(array)
+            txt="".join([c for c in txt if c not in " \t\r\n"])
+    return txt
+
diff --git a/windows/fuzzbunch/pyreadline/clipboard/ironpython_clipboard.py b/windows/fuzzbunch/pyreadline/clipboard/ironpython_clipboard.py
new file mode 100644
index 0000000..2d1708e
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/clipboard/ironpython_clipboard.py
@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2006  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+import clr
+clr.AddReferenceByPartialName("System.Windows.Forms")
+import System.Windows.Forms.Clipboard as cb
+
+def GetClipboardText():
+    text=""
+    if cb.ContainsText():
+        text=cb.GetText()
+
+    return text
+
+def SetClipboardText(text):
+    cb.SetText(text)    
+
+if __name__ == '__main__':
+    txt=GetClipboardText()                            # display last text clipped
+    print txt
+     
+     
+     
+     
\ No newline at end of file
diff --git a/windows/fuzzbunch/pyreadline/clipboard/win32_clipboard.py b/windows/fuzzbunch/pyreadline/clipboard/win32_clipboard.py
new file mode 100644
index 0000000..d951e55
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/clipboard/win32_clipboard.py
@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2003-2006 Jack Trainor.
+#       Copyright (C) 2006  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+###################################
+#
+# Based on recipe posted to ctypes-users
+# see archive
+# http://aspn.activestate.com/ASPN/Mail/Message/ctypes-users/1771866
+#
+#
+
+###################################################################################
+#
+# The Python win32clipboard lib functions work well enough ... except that they
+# can only cut and paste items from within one application, not across
+# applications or processes.
+#
+# I've written a number of Python text filters I like to run on the contents of
+# the clipboard so I need to call the Windows clipboard API with global memory
+# for my filters to work properly.
+#
+# Here's some sample code solving this problem using ctypes.
+#
+# This is my first work with ctypes.  It's powerful stuff, but passing arguments
+# in and out of functions is tricky.  More sample code would have been helpful,
+# hence this contribution.
+#
+###################################################################################
+
+from ctypes import *
+from pyreadline.keysyms.winconstants import CF_TEXT, GHND
+
+OpenClipboard = windll.user32.OpenClipboard
+EmptyClipboard = windll.user32.EmptyClipboard
+GetClipboardData = windll.user32.GetClipboardData
+GetClipboardFormatName = windll.user32.GetClipboardFormatNameA
+SetClipboardData = windll.user32.SetClipboardData
+EnumClipboardFormats = windll.user32.EnumClipboardFormats
+CloseClipboard = windll.user32.CloseClipboard
+OpenClipboard.argtypes=[c_int]
+EnumClipboardFormats.argtypes=[c_int]
+CloseClipboard.argtypes=[]
+GetClipboardFormatName.argtypes=[c_uint,c_char_p,c_int]
+GetClipboardData.argtypes=[c_int]
+SetClipboardData.argtypes=[c_int,c_int]
+
+GlobalLock = windll.kernel32.GlobalLock
+GlobalAlloc = windll.kernel32.GlobalAlloc
+GlobalUnlock = windll.kernel32.GlobalUnlock
+GlobalLock.argtypes=[c_int]
+GlobalUnlock.argtypes=[c_int]
+memcpy = cdll.msvcrt.memcpy
+
+def enum():
+    OpenClipboard(0)
+    q=EnumClipboardFormats(0)
+    while q:
+        print q,
+        q=EnumClipboardFormats(q)
+    CloseClipboard()
+
+def getformatname(format):
+    buffer = c_buffer(" "*100)
+    bufferSize = sizeof(buffer)
+    OpenClipboard(0)
+    GetClipboardFormatName(format,buffer,bufferSize)
+    CloseClipboard()
+    return buffer.value
+
+def GetClipboardText():
+    text = ""
+    if OpenClipboard(0):
+        hClipMem = GetClipboardData(CF_TEXT)
+        if hClipMem:        
+            GlobalLock.restype = c_char_p
+            text = GlobalLock(hClipMem)
+            GlobalUnlock(hClipMem)
+        CloseClipboard()
+    return text
+
+def SetClipboardText(text):
+    buffer = c_buffer(text)
+    bufferSize = sizeof(buffer)
+    hGlobalMem = GlobalAlloc(c_int(GHND), c_int(bufferSize))
+    GlobalLock.restype = c_void_p
+    lpGlobalMem = GlobalLock(c_int(hGlobalMem))
+    memcpy(lpGlobalMem, addressof(buffer), c_int(bufferSize))
+    GlobalUnlock(c_int(hGlobalMem))
+    if OpenClipboard(0):
+        EmptyClipboard()
+        SetClipboardData(c_int(CF_TEXT), c_int(hGlobalMem))
+        CloseClipboard()
+
+if __name__ == '__main__':
+    txt=GetClipboardText()                            # display last text clipped
+    print txt
+     
+     
+     
+     
\ No newline at end of file
diff --git a/windows/fuzzbunch/pyreadline/configuration/pyreadlineconfig.ini b/windows/fuzzbunch/pyreadline/configuration/pyreadlineconfig.ini
new file mode 100644
index 0000000..447e300
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/configuration/pyreadlineconfig.ini
@@ -0,0 +1,85 @@
+#Bind keys for exit (keys only work on empty lines
+
+bind_exit_key("Control-d")
+bind_exit_key("Control-z")
+
+#Commands for moving	
+bind_key("Home",                "beginning_of_line")
+bind_key("End",                 "end_of_line")
+bind_key("Left",                "backward_char")
+bind_key("Control-b",           "backward_char")
+bind_key("Right",               "forward_char")
+bind_key("Control-f",           "forward_char")
+bind_key("Alt-f",               "forward_word")
+bind_key("Alt-b",               "backward_word")
+bind_key("Clear",               "clear_screen")
+bind_key("Control-l",           "clear_screen")
+bind_key("Control-a",           "beginning_of_line")
+bind_key("Control-e",           "end_of_line")
+#bind_key("Control-l",          "redraw_current_line")
+
+#Commands for Manipulating the History
+bind_key("Return",              "accept_line")
+bind_key("Control-p",           "previous_history")
+bind_key("Control-n",           "next_history")
+bind_key("Up",                  "history_search_backward")
+bind_key("Down",                "history_search_forward")
+bind_key("Alt-<",               "beginning_of_history")
+bind_key("Alt->",               "end_of_history")
+bind_key("Control-r",           "reverse_search_history")
+bind_key("Control-s",           "forward_search_history")
+bind_key("Alt-p",               "non_incremental_reverse_search_history")
+bind_key("Alt-n",               "non_incremental_forward_search_history")
+
+bind_key("Control-z",           "undo")
+bind_key("Control-_",           "undo")
+
+#Commands for Changing Text
+bind_key("Delete",              "delete_char")
+bind_key("Control-d",           "delete_char")
+bind_key("BackSpace",           "backward_delete_char")
+#bind_key("Control-Shift-v",    "quoted_insert")
+bind_key("Control-space",       "self_insert")
+bind_key("Control-BackSpace",   "backward_delete_word")
+
+#Killing and Yanking
+bind_key("Control-k",           "kill_line")
+bind_key("Control-shift-k",     "kill_whole_line")
+bind_key("Escape",              "kill_whole_line")
+bind_key("Meta-d",              "kill_word")
+bind_key("Control-w",           "unix_word_rubout")
+#bind_key("Control-Delete",     "forward_kill_word")
+
+#Copy paste
+bind_key("Shift-Right",         "forward_char_extend_selection")
+bind_key("Shift-Left",          "backward_char_extend_selection")
+bind_key("Shift-Control-Right", "forward_word_extend_selection")
+bind_key("Shift-Control-Left",  "backward_word_extend_selection")
+bind_key("Control-m",           "set_mark")
+
+bind_key("Control-Shift-x",     "copy_selection_to_clipboard")
+#bind_key("Control-c",           "copy_selection_to_clipboard")  #Needs allow_ctrl_c(True) below to be uncommented
+bind_key("Control-q",           "copy_region_to_clipboard")
+bind_key('Control-Shift-v',     "paste_mulitline_code")
+bind_key("Control-x",           "cut_selection_to_clipboard")
+
+bind_key("Control-v",           "paste")
+bind_key("Control-y",           "yank")
+bind_key("Alt-v",               "ipython_paste")
+
+#Unbinding keys:
+#un_bind_key("Home")
+
+#Other
+bell_style("none") #modes: none, audible, visible(not implemented)
+show_all_if_ambiguous("on")
+mark_directories("on")
+completer_delims(" \t\n\"\\'`@$><=;|&{(?")
+debug_output("off")
+#allow_ctrl_c(True)  #(Allows use of ctrl-c as copy key, still propagate keyboardinterrupt when not waiting for input)
+
+history_filename("~/.pythonhistory")
+history_length(200) #value of -1 means no limit
+
+#set_mode("vi")  #will cause following bind_keys to bind to vi mode as well as activate vi mode
+#ctrl_c_tap_time_interval(0.3)
\ No newline at end of file
diff --git a/windows/fuzzbunch/pyreadline/configuration/startup.py b/windows/fuzzbunch/pyreadline/configuration/startup.py
new file mode 100644
index 0000000..e967fd7
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/configuration/startup.py
@@ -0,0 +1,16 @@
+# -*- coding: UTF-8 -*-
+# Example snippet to use in a PYTHONSTARTUP file
+try:
+    import pyreadline.rlmain
+    #pyreadline.rlmain.config_path=r"c:\xxx\pyreadlineconfig.ini"
+    import readline,atexit
+except ImportError:
+    print "Module readline not available."
+else:
+    #import tab completion functionality
+    import rlcompleter
+    #activate tab completion
+    readline.parse_and_bind("tab: complete")
+    readline.read_history_file()
+    atexit.register(readline.write_history_file)
+    del readline,rlcompleter,atexit
diff --git a/windows/fuzzbunch/pyreadline/console/__init__.py b/windows/fuzzbunch/pyreadline/console/__init__.py
new file mode 100644
index 0000000..f5ea1ab
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/console/__init__.py
@@ -0,0 +1,21 @@
+import glob,sys
+
+success=False
+in_ironpython="IronPython" in sys.version
+
+if in_ironpython:
+    try:
+        from ironpython_console import *
+        success=True
+    except ImportError:
+        raise
+else:
+    try:
+        from console import *
+        success=True
+    except ImportError:
+        pass
+
+
+if not success:
+    raise ImportError("Could not find a console implementation for your platform")
diff --git a/windows/fuzzbunch/pyreadline/console/ansi.py b/windows/fuzzbunch/pyreadline/console/ansi.py
new file mode 100644
index 0000000..16697cb
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/console/ansi.py
@@ -0,0 +1,181 @@
+# -*- coding: ISO-8859-1 -*-
+import re,sys,os
+
+terminal_escape = re.compile('(\001?\033\\[[0-9;]*m\002?)')
+escape_parts = re.compile('\001?\033\\[([0-9;]*)m\002?')
+
+
+class AnsiState(object):
+    def __init__(self,bold=False,inverse=False,color="white",background="black",backgroundbold=False):
+        self.bold=bold
+        self.inverse=inverse
+        self.color=color
+        self.background=background
+        self.backgroundbold=backgroundbold
+
+    trtable={"black":0,"red":4,"green":2,"yellow":6,"blue":1,"magenta":5,"cyan":3,"white":7}
+    revtable=dict(zip(trtable.values(),trtable.keys()))
+    def get_winattr(self):
+        attr=0
+        if self.bold:
+            attr|=0x0008
+        if self.backgroundbold:
+            attr|=0x0080
+        if self.inverse:
+            attr|=0x4000
+        attr|=self.trtable[self.color]
+        attr|=(self.trtable[self.background]<<4)
+        return attr
+
+    def set_winattr(self,attr):
+        self.bold=bool(attr&0x0008)
+        self.backgroundbold=bool(attr&0x0080)
+        self.inverse=bool(attr&0x4000)
+        self.color=self.revtable[attr&0x0007]
+        self.background=self.revtable[(attr&0x0070)>>4]
+        
+    winattr=property(get_winattr,set_winattr)
+    def __repr__(self):
+        return 'AnsiState(bold=%s,inverse=%s,color=%9s,background=%9s,backgroundbold=%s)# 0x%x'%(self.bold,
+                                                                                                 self.inverse,
+                                                                                                 '"%s"'%self.color,
+                                                                                                 '"%s"'%self.background,
+                                                                                                 self.backgroundbold,
+                                                                                                 self.winattr)
+
+    def copy(self):
+        x=AnsiState()
+        x.bold=self.bold
+        x.inverse=self.inverse
+        x.color=self.color
+        x.background=self.background
+        x.backgroundbold=self.backgroundbold
+        return x
+defaultstate=AnsiState(False,False,"white")
+
+trtable={0:"black",1:"red",2:"green",3:"yellow",4:"blue",5:"magenta",6:"cyan",7:"white"}
+
+class AnsiWriter(object):
+    def __init__(self,default=defaultstate):
+        if isinstance(defaultstate,AnsiState):
+            self.defaultstate=default
+        else:
+            self.defaultstate=AnsiState()
+            self.defaultstate.winattr=defaultstate
+            
+            
+    def write_color(self,text, attr=None):
+        '''write text at current cursor position and interpret color escapes.
+
+        return the number of characters written.
+        '''
+        if isinstance(attr,AnsiState):
+            defaultstate=attr
+        elif attr is None:  #use attribute form initial console
+            attr = self.defaultstate.copy()
+        else:
+            defaultstate=AnsiState()
+            defaultstate.winattr=attr
+            attr=defaultstate
+        chunks = terminal_escape.split(text)
+        n = 0 # count the characters we actually write, omitting the escapes
+        res=[]
+        for chunk in chunks:
+            m = escape_parts.match(chunk)
+            if m:
+                parts=m.group(1).split(";")
+                if len(parts)==1 and parts[0]=="0":
+                    attr = self.defaultstate.copy()
+                    continue
+                for part in parts:
+                    if part == "0": # No text attribute
+                        attr = self.defaultstate.copy()
+                        attr.bold=False
+                    elif part == "7": # switch on reverse
+                        attr.inverse=True
+                    elif part == "1": # switch on bold (i.e. intensify foreground color)
+                        attr.bold=True 
+                    elif len(part) == 2 and "30" <= part <= "37": # set foreground color
+                        attr.color = trtable[int(part)-30]
+                    elif len(part) == 2 and "40" <= part <= "47": # set background color
+                        attr.color = trtable[int(part)-40]
+                continue
+            n += len(chunk)
+            if True:
+                res.append((attr.copy(),chunk))
+        return n,res
+
+    def parse_color(self,text, attr=None):
+        n,res=self.write_color(text,attr)
+        return n,[attr.winattr for attr,text in res]
+
+def write_color(text,attr=None):
+    a=AnsiWriter(defaultstate)
+    return a.write_color(text,attr)
+
+def write_color_old( text, attr=None):
+    '''write text at current cursor position and interpret color escapes.
+
+    return the number of characters written.
+    '''
+    res=[]
+    chunks = terminal_escape.split(text)
+    n = 0 # count the characters we actually write, omitting the escapes
+    if attr is None:#use attribute from initial console
+        attr = 15
+    for chunk in chunks:
+        m = escape_parts.match(chunk)
+        if m:
+            for part in m.group(1).split(";"):
+                if part == "0": # No text attribute
+                    attr = 0
+                elif part == "7": # switch on reverse
+                    attr |= 0x4000
+                if part == "1": # switch on bold (i.e. intensify foreground color)
+                    attr |= 0x08
+                elif len(part) == 2 and "30" <= part <= "37": # set foreground color
+                    part = int(part)-30
+                    # we have to mirror bits
+                    attr = (attr & ~0x07) | ((part & 0x1) << 2) | (part & 0x2) | ((part & 0x4) >> 2)
+                elif len(part) == 2 and "40" <= part <= "47": # set background color
+                    part = int(part)-40
+                    # we have to mirror bits
+                    attr = (attr & ~0x70) | ((part & 0x1) << 6) | ((part & 0x2) << 4) | ((part & 0x4) << 2)
+                # ignore blink, underline and anything we don't understand
+            continue
+        n += len(chunk)
+        if chunk:
+            res.append(("0x%x"%attr,chunk))
+    return res
+
+
+#trtable={0:"black",1:"red",2:"green",3:"yellow",4:"blue",5:"magenta",6:"cyan",7:"white"}
+
+if __name__=="__main__":
+    import pprint
+    pprint=pprint.pprint
+
+    s="\033[0;31mred\033[0;32mgreen\033[0;33myellow\033[0;34mblue\033[0;35mmagenta\033[0;36mcyan\033[0;37mwhite\033[0m"
+    pprint (write_color(s))    
+    pprint (write_color_old(s))
+    s="\033[1;31mred\033[1;32mgreen\033[1;33myellow\033[1;34mblue\033[1;35mmagenta\033[1;36mcyan\033[1;37mwhite\033[0m"
+    pprint (write_color(s))    
+    pprint (write_color_old(s))    
+
+    s="\033[0;7;31mred\033[0;7;32mgreen\033[0;7;33myellow\033[0;7;34mblue\033[0;7;35mmagenta\033[0;7;36mcyan\033[0;7;37mwhite\033[0m"
+    pprint (write_color(s))    
+    pprint (write_color_old(s))
+    s="\033[1;7;31mred\033[1;7;32mgreen\033[1;7;33myellow\033[1;7;34mblue\033[1;7;35mmagenta\033[1;7;36mcyan\033[1;7;37mwhite\033[0m"
+    pprint (write_color(s))    
+    pprint (write_color_old(s))    
+
+    
+if __name__=="__main__":
+    import console
+    
+    c=console.Console()
+    c.write_color("dhsjdhs")
+    c.write_color("\033[0;32mIn [\033[1;32m1\033[0;32m]:")
+    print
+    pprint (write_color("\033[0;32mIn [\033[1;32m1\033[0;32m]:"))    
+    
diff --git a/windows/fuzzbunch/pyreadline/console/console.py b/windows/fuzzbunch/pyreadline/console/console.py
new file mode 100644
index 0000000..00e0515
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/console/console.py
@@ -0,0 +1,758 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+'''Cursor control and color for the Windows console.
+
+This was modeled after the C extension of the same name by Fredrik Lundh. 
+'''
+
+# primitive debug printing that won't interfere with the screen
+
+import sys
+import traceback
+import re
+from pyreadline.logger import log,log_sock
+
+try:
+    from ctypes import *
+    from _ctypes import call_function
+except ImportError:
+    raise ImportError("You need ctypes to run this code")
+
+# my code
+from pyreadline.keysyms import make_KeyPress
+from pyreadline.console.ansi import AnsiState,AnsiWriter
+
+# some constants we need
+STD_INPUT_HANDLE = -10
+STD_OUTPUT_HANDLE = -11
+ENABLE_WINDOW_INPUT = 0x0008
+ENABLE_MOUSE_INPUT = 0x0010
+ENABLE_PROCESSED_INPUT = 0x0001
+WHITE = 0x7
+BLACK = 0
+MENU_EVENT = 0x0008
+KEY_EVENT = 0x0001
+MOUSE_MOVED = 0x0001
+MOUSE_EVENT = 0x0002
+WINDOW_BUFFER_SIZE_EVENT = 0x0004
+FOCUS_EVENT = 0x0010
+MENU_EVENT = 0x0008
+VK_SHIFT = 0x10
+VK_CONTROL = 0x11
+VK_MENU = 0x12
+GENERIC_READ = int(0x80000000L)
+GENERIC_WRITE = 0x40000000
+
+# Windows structures we'll need later
+class COORD(Structure):
+    _fields_ = [("X", c_short),
+                ("Y", c_short)]
+
+class SMALL_RECT(Structure):
+    _fields_ = [("Left", c_short),
+                ("Top", c_short),
+                ("Right", c_short),
+                ("Bottom", c_short)]
+
+class CONSOLE_SCREEN_BUFFER_INFO(Structure):
+    _fields_ = [("dwSize", COORD),
+                ("dwCursorPosition", COORD),
+                ("wAttributes", c_short),
+                ("srWindow", SMALL_RECT),
+                ("dwMaximumWindowSize", COORD)]
+
+class CHAR_UNION(Union):
+    _fields_ = [("UnicodeChar", c_short),
+                ("AsciiChar", c_char)]
+
+class CHAR_INFO(Structure):
+    _fields_ = [("Char", CHAR_UNION),
+                ("Attributes", c_short)]
+
+class KEY_EVENT_RECORD(Structure):
+    _fields_ = [("bKeyDown", c_byte),
+                ("pad2", c_byte),
+                ('pad1', c_short),
+                ("wRepeatCount", c_short),
+                ("wVirtualKeyCode", c_short),
+                ("wVirtualScanCode", c_short),
+                ("uChar", CHAR_UNION),
+                ("dwControlKeyState", c_int)]
+
+class MOUSE_EVENT_RECORD(Structure):
+    _fields_ = [("dwMousePosition", COORD),
+                ("dwButtonState", c_int),
+                ("dwControlKeyState", c_int),
+                ("dwEventFlags", c_int)]
+
+class WINDOW_BUFFER_SIZE_RECORD(Structure):
+    _fields_ = [("dwSize", COORD)]
+
+class MENU_EVENT_RECORD(Structure):
+    _fields_ = [("dwCommandId", c_uint)]
+
+class FOCUS_EVENT_RECORD(Structure):
+    _fields_ = [("bSetFocus", c_byte)]
+
+class INPUT_UNION(Union):
+    _fields_ = [("KeyEvent", KEY_EVENT_RECORD),
+                ("MouseEvent", MOUSE_EVENT_RECORD),
+                ("WindowBufferSizeEvent", WINDOW_BUFFER_SIZE_RECORD),
+                ("MenuEvent", MENU_EVENT_RECORD),
+                ("FocusEvent", FOCUS_EVENT_RECORD)]
+
+class INPUT_RECORD(Structure):
+    _fields_ = [("EventType", c_short),
+                ("Event", INPUT_UNION)]
+
+class CONSOLE_CURSOR_INFO(Structure):
+    _fields_ = [("dwSize", c_int),
+                ("bVisible", c_byte)]
+
+
+try:
+    consolecodepage=sys.stdout.encoding
+except AttributeError:        #This error occurs when pdb imports readline and doctest has replaced 
+                              #stdout with stdout collector
+    consolecodepage="ascii"   #assume ascii codepage
+    
+def ensure_text(text):
+    """helper to ensure that text passed to WriteConsoleA is ascii"""
+    if isinstance(text, unicode):
+        return text.encode(consolecodepage,"replace")
+    return text
+
+# I didn't want to have to individually import these so I made a list, they are
+# added to the Console class later in this file.
+
+funcs = [
+    'AllocConsole',
+    'CreateConsoleScreenBuffer',
+    'FillConsoleOutputAttribute',
+    'FillConsoleOutputCharacterA',
+    'FreeConsole',
+    'GetConsoleCursorInfo',
+    'GetConsoleMode',
+    'GetConsoleScreenBufferInfo',
+    'GetConsoleTitleA',
+    'GetProcAddress',
+    'GetStdHandle',
+    'PeekConsoleInputA',
+    'ReadConsoleInputA',
+    'ScrollConsoleScreenBufferA',
+    'SetConsoleActiveScreenBuffer',
+    'SetConsoleCursorInfo',
+    'SetConsoleCursorPosition',
+    'SetConsoleMode',
+    'SetConsoleScreenBufferSize',
+    'SetConsoleTextAttribute',
+    'SetConsoleTitleA',
+    'SetConsoleWindowInfo',
+    'WriteConsoleA',
+    'WriteConsoleOutputCharacterA',
+    ]
+
+# I don't want events for these keys, they are just a bother for my application
+key_modifiers = { VK_SHIFT:1,
+                  VK_CONTROL:1,
+                  VK_MENU:1, # alt key
+                  0x5b:1, # windows key
+                 }
+
+class Console(object):
+    '''Console driver for Windows.
+
+    '''
+
+    def __init__(self, newbuffer=0):
+        '''Initialize the Console object.
+
+        newbuffer=1 will allocate a new buffer so the old content will be restored
+        on exit.
+        '''
+        #Do I need the following line? It causes a console to be created whenever
+        #readline is imported into a pythonw application which seems wrong. Things
+        #seem to work without it...
+        #self.AllocConsole()
+
+        if newbuffer:
+            self.hout = self.CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
+                                                                                                 0, None, 1, None)
+            self.SetConsoleActiveScreenBuffer(self.hout)
+        else:
+            self.hout = self.GetStdHandle(STD_OUTPUT_HANDLE)
+
+        self.hin = self.GetStdHandle(STD_INPUT_HANDLE)
+        self.inmode = c_int(0)
+        self.GetConsoleMode(self.hin, byref(self.inmode))
+        self.SetConsoleMode(self.hin, 0xf)
+        info = CONSOLE_SCREEN_BUFFER_INFO()
+        self.GetConsoleScreenBufferInfo(self.hout, byref(info))
+        self.attr = info.wAttributes
+        self.saveattr = info.wAttributes # remember the initial colors
+
+        self.defaultstate=AnsiState()
+        self.defaultstate.winattr=info.wAttributes
+        self.ansiwriter=AnsiWriter(self.defaultstate)
+#        self.ansiwriter.defaultstate.bold=False
+        
+        background = self.attr & 0xf0
+        for escape in self.escape_to_color:
+            if self.escape_to_color[escape] is not None:
+                self.escape_to_color[escape] |= background
+        log('initial attr=%x' % self.attr)
+        self.softspace = 0 # this is for using it as a file-like object
+        self.serial = 0
+
+        self.pythondll = CDLL('python%s%s' % (sys.version[0], sys.version[2]))
+        self.inputHookPtr = c_int.from_address(addressof(self.pythondll.PyOS_InputHook)).value
+        setattr(Console, 'PyMem_Malloc', self.pythondll.PyMem_Malloc)
+
+    def __del__(self):
+        '''Cleanup the console when finished.'''
+        # I don't think this ever gets called
+        self.SetConsoleTextAttribute(self.hout, self.saveattr)
+        self.SetConsoleMode(self.hin, self.inmode)
+        self.FreeConsole()
+
+    def _get_top_bot(self):
+        info = CONSOLE_SCREEN_BUFFER_INFO()
+        self.GetConsoleScreenBufferInfo(self.hout, byref(info))
+        rect = info.srWindow
+        top = rect.Top 
+        bot = rect.Bottom 
+        return top,bot
+
+    def fixcoord(self, x, y):
+        '''Return a long with x and y packed inside, also handle negative x and y.'''
+        if x < 0 or y < 0:
+            info = CONSOLE_SCREEN_BUFFER_INFO()
+            self.GetConsoleScreenBufferInfo(self.hout, byref(info))
+            if x < 0:
+                x = info.srWindow.Right - x
+                y = info.srWindow.Bottom + y
+
+        # this is a hack! ctypes won't pass structures but COORD is just like a
+        # long, so this works.
+        return c_int(y << 16 | x)
+
+    def pos(self, x=None, y=None):
+        '''Move or query the window cursor.'''
+        if x is None:
+            info = CONSOLE_SCREEN_BUFFER_INFO()
+            self.GetConsoleScreenBufferInfo(self.hout, byref(info))
+            return (info.dwCursorPosition.X, info.dwCursorPosition.Y)
+        else:
+            return self.SetConsoleCursorPosition(self.hout, self.fixcoord(x, y))
+
+    def home(self):
+        '''Move to home.'''
+        self.pos(0,0)
+
+# Map ANSI color escape sequences into Windows Console Attributes
+
+    terminal_escape = re.compile('(\001?\033\\[[0-9;]+m\002?)')
+    escape_parts = re.compile('\001?\033\\[([0-9;]+)m\002?')
+    escape_to_color = { '0;30': 0x0,             #black
+                        '0;31': 0x4,             #red
+                        '0;32': 0x2,             #green
+                        '0;33': 0x4+0x2,         #brown?
+                        '0;34': 0x1,             #blue
+                        '0;35': 0x1+0x4,         #purple
+                        '0;36': 0x2+0x4,         #cyan
+                        '0;37': 0x1+0x2+0x4,     #grey
+                        '1;30': 0x1+0x2+0x4,     #dark gray
+                        '1;31': 0x4+0x8,         #red
+                        '1;32': 0x2+0x8,         #light green
+                        '1;33': 0x4+0x2+0x8,     #yellow
+                        '1;34': 0x1+0x8,         #light blue
+                        '1;35': 0x1+0x4+0x8,     #light purple
+                        '1;36': 0x1+0x2+0x8,     #light cyan
+                        '1;37': 0x1+0x2+0x4+0x8, #white
+                        '0': None,
+                       }
+
+    # This pattern should match all characters that change the cursor position differently
+    # than a normal character.
+    motion_char_re = re.compile('([\n\r\t\010\007])')
+
+    def write_scrolling(self, text, attr=None):
+        '''write text at current cursor position while watching for scrolling.
+
+        If the window scrolls because you are at the bottom of the screen
+        buffer, all positions that you are storing will be shifted by the
+        scroll amount. For example, I remember the cursor position of the
+        prompt so that I can redraw the line but if the window scrolls,
+        the remembered position is off.
+
+        This variant of write tries to keep track of the cursor position
+        so that it will know when the screen buffer is scrolled. It
+        returns the number of lines that the buffer scrolled.
+
+        '''
+        x, y = self.pos()
+        w, h = self.size()
+        scroll = 0 # the result
+        # split the string into ordinary characters and funny characters
+        chunks = self.motion_char_re.split(text)
+        for chunk in chunks:
+            log('C:'+chunk)
+            n = self.write_color(chunk, attr)
+            if len(chunk) == 1: # the funny characters will be alone
+                if chunk[0] == '\n': # newline
+                    x = 0
+                    y += 1
+                elif chunk[0] == '\r': # carriage return
+                    x = 0
+                elif chunk[0] == '\t': # tab
+                    x = 8*(int(x/8)+1)
+                    if x > w: # newline
+                        x -= w
+                        y += 1
+                elif chunk[0] == '\007': # bell
+                    pass
+                elif chunk[0] == '\010':
+                    x -= 1
+                    if x < 0:
+                        y -= 1 # backed up 1 line
+                else: # ordinary character
+                    x += 1
+                if x == w: # wrap
+                    x = 0
+                    y += 1
+                if y == h: # scroll
+                    scroll += 1
+                    y = h - 1
+            else: # chunk of ordinary characters
+                x += n
+                l = int(x / w) # lines we advanced
+                x = x % w # new x value
+                y += l
+                if y >= h: # scroll
+                    scroll += y - h + 1
+                    y = h - 1
+        return scroll
+
+    def write_color(self, text, attr=None):
+        '''write text at current cursor position and interpret color escapes.
+
+        return the number of characters written.
+        '''
+        log('write_color("%s", %s)' % (text, attr))
+        chunks = self.terminal_escape.split(text)
+        log('chunks=%s' % repr(chunks))
+        junk = c_int(0)
+        n = 0 # count the characters we actually write, omitting the escapes
+        for chunk in chunks:
+            m = self.escape_parts.match(chunk)
+            if m:
+                attr = self.escape_to_color[m.group(1)]
+                continue
+            n += len(chunk)
+            log('attr=%s' % attr)
+            if attr is None:
+                attr = self.attr
+            self.SetConsoleTextAttribute(self.hout, attr)
+            self.WriteConsoleA(self.hout, ensure_text(chunk), len(chunk), byref(junk), None)
+        return n
+
+    def write_color(self, text, attr=None):
+        n,res= self.ansiwriter.write_color(text,attr)
+        junk = c_int(0)
+        for attr,chunk in res:
+            log(str(attr))
+            log(str(chunk))
+            self.SetConsoleTextAttribute(self.hout, attr.winattr)
+            self.WriteConsoleA(self.hout, ensure_text(chunk), len(chunk), byref(junk), None)
+        return n
+
+
+    def write_plain(self, text, attr=None):
+        '''write text at current cursor position.'''
+        log('write("%s", %s)' %(text,attr))
+        if attr is None:
+            attr = self.attr
+        n = c_int(0)
+        self.SetConsoleTextAttribute(self.hout, attr)
+        self.WriteConsoleA(self.hout, ensure_text(chunk), len(chunk), byref(junk), None)
+        return len(text)
+
+    # make this class look like a file object
+    def write(self, text):
+        log('write("%s")' % text)
+        return self.write_color(text)
+
+    #write = write_scrolling
+
+    def isatty(self):
+        return True
+
+    def flush(self):
+        pass
+
+    def page(self, attr=None, fill=' '):
+        '''Fill the entire screen.'''
+        if attr is None:
+            attr = self.attr
+        if len(fill) != 1:
+            raise ValueError
+        info = CONSOLE_SCREEN_BUFFER_INFO()
+        self.GetConsoleScreenBufferInfo(self.hout, byref(info))
+        if info.dwCursorPosition.X != 0 or info.dwCursorPosition.Y != 0:
+            self.SetConsoleCursorPosition(self.hout, self.fixcoord(0, 0))
+
+        w = info.dwSize.X
+        n = c_int(0)
+        for y in range(info.dwSize.Y):
+            self.FillConsoleOutputAttribute(self.hout, attr, w, self.fixcoord(0, y), byref(n))
+            self.FillConsoleOutputCharacterA(self.hout, ord(fill[0]), w, self.fixcoord(0, y), byref(n))
+
+        self.attr = attr
+
+    def text(self, x, y, text, attr=None):
+        '''Write text at the given position.'''
+        if attr is None:
+            attr = self.attr
+
+        pos = self.fixcoord(x, y)
+        n = c_int(0)
+        self.WriteConsoleOutputCharacterA(self.hout, text, len(text), pos, byref(n))
+        self.FillConsoleOutputAttribute(self.hout, attr, n, pos, byref(n))
+
+    def clear_to_end_of_window(self):
+        top,bot=self._get_top_bot()
+        pos=self.pos()
+        w,h=self.size()
+        self.rectangle( (pos[0],pos[1],w,pos[1]+1))
+        if pos[1]<bot:
+            self.rectangle((0,pos[1]+1,w,bot+1))
+
+    def rectangle(self, rect, attr=None, fill=' '):
+        '''Fill Rectangle.'''
+        log_sock("rect:%s"%[rect])
+        x0, y0, x1, y1 = rect
+        n = c_int(0)
+        if attr is None:
+            attr = self.attr
+        for y in range(y0, y1):
+            pos = self.fixcoord(x0, y)
+            self.FillConsoleOutputAttribute(self.hout, attr, x1-x0, pos, byref(n))
+            self.FillConsoleOutputCharacterA(self.hout, ord(fill[0]), x1-x0, pos, byref(n))
+
+    def scroll(self, rect, dx, dy, attr=None, fill=' '):
+        '''Scroll a rectangle.'''
+        if attr is None:
+            attr = self.attr
+
+        x0, y0, x1, y1 = rect
+        source = SMALL_RECT(x0, y0, x1-1, y1-1)
+        dest = self.fixcoord(x0+dx, y0+dy)
+        style = CHAR_INFO()
+        style.Char.AsciiChar = fill[0]
+        style.Attributes = attr
+
+        return self.ScrollConsoleScreenBufferA(self.hout, byref(source), byref(source),
+                                                                                     dest, byref(style))
+
+    def scroll_window(self, lines):
+        '''Scroll the window by the indicated number of lines.'''
+        info = CONSOLE_SCREEN_BUFFER_INFO()
+        self.GetConsoleScreenBufferInfo(self.hout, byref(info))
+        rect = info.srWindow
+        log('sw: rtop=%d rbot=%d' % (rect.Top, rect.Bottom))
+        top = rect.Top + lines
+        bot = rect.Bottom + lines
+        h = bot - top
+        maxbot = info.dwSize.Y-1
+        if top < 0:
+            top = 0
+            bot = h
+        if bot > maxbot:
+            bot = maxbot
+            top = bot - h
+
+        nrect = SMALL_RECT()
+        nrect.Top = top
+        nrect.Bottom = bot
+        nrect.Left = rect.Left
+        nrect.Right = rect.Right
+        log('sn: top=%d bot=%d' % (top,bot))
+        r=self.SetConsoleWindowInfo(self.hout, True, byref(nrect))
+        log('r=%d' % r)
+
+    def get(self):
+        '''Get next event from queue.'''
+        inputHookFunc = c_int.from_address(self.inputHookPtr).value
+
+        Cevent = INPUT_RECORD()
+        count = c_int(0)
+        while 1:
+            if inputHookFunc:
+                call_function(inputHookFunc, ())
+            status = self.ReadConsoleInputA(self.hin, byref(Cevent), 1, byref(count))
+            if status and count.value == 1:
+                e = event(self, Cevent)
+                log_sock(str(e.keyinfo),"keypress")
+                return e
+
+    def getkeypress(self):
+        '''Return next key press event from the queue, ignoring others.'''
+        while 1:
+            e = self.get()
+            if e.type == 'KeyPress' and e.keycode not in key_modifiers:
+                log(e)
+                if e.keyinfo.keyname == 'next':
+                    self.scroll_window(12)
+                elif e.keyinfo.keyname == 'prior':
+                    self.scroll_window(-12)
+                else:
+                    return e
+            elif e.type == 'KeyRelease' and e.keyinfo==(True, False, False, 83):
+                log("getKeypress:%s,%s,%s"%(e.keyinfo,e.keycode,e.type))
+                return e
+                
+    def getchar(self):
+        '''Get next character from queue.'''
+
+        Cevent = INPUT_RECORD()
+        count = c_int(0)
+        while 1:
+            status = self.ReadConsoleInputA(self.hin, byref(Cevent), 1, byref(count))
+            if (status and count.value==1 and Cevent.EventType == 1 and
+                    Cevent.Event.KeyEvent.bKeyDown):
+                sym = keysym(Cevent.Event.KeyEvent.wVirtualKeyCode)
+                if len(sym) == 0:
+                    sym = Cevent.Event.KeyEvent.uChar.AsciiChar
+                return sym
+
+    def peek(self):
+        '''Check event queue.'''
+        Cevent = INPUT_RECORD()
+        count = c_int(0)
+        status = self.PeekConsoleInputA(self.hin, byref(Cevent), 1, byref(count))
+        log_sock("%s %s %s"%(status,count,Cevent))
+        if status and count == 1:
+            return event(self, Cevent)
+
+    def title(self, txt=None):
+        '''Set/get title.'''
+        if txt:
+            self.SetConsoleTitleA(txt)
+        else:
+            buffer = c_buffer(200)
+            n = self.GetConsoleTitleA(buffer, 200)
+            if n > 0:
+                return buffer.value[:n]
+
+    def size(self, width=None, height=None):
+        '''Set/get window size.'''
+        info = CONSOLE_SCREEN_BUFFER_INFO()
+        status = self.GetConsoleScreenBufferInfo(self.hout, byref(info))
+        if not status:
+            return None
+        if width is not None and height is not None:
+            wmin = info.srWindow.Right - info.srWindow.Left + 1
+            hmin = info.srWindow.Bottom - info.srWindow.Top + 1
+            #print wmin, hmin
+            width = max(width, wmin)
+            height = max(height, hmin)
+            #print width, height
+            self.SetConsoleScreenBufferSize(self.hout, self.fixcoord(width, height))
+        else:
+            return (info.dwSize.X, info.dwSize.Y)
+
+    def cursor(self, visible=None, size=None):
+        '''Set cursor on or off.'''
+        info = CONSOLE_CURSOR_INFO()
+        if self.GetConsoleCursorInfo(self.hout, byref(info)):
+            if visible is not None:
+                info.bVisible = visible
+            if size is not None:
+                info.dwSize = size
+            self.SetConsoleCursorInfo(self.hout, byref(info))
+
+    def bell(self):
+        self.write('\007')
+
+    def next_serial(self):
+        '''Get next event serial number.'''
+        self.serial += 1
+        return self.serial
+
+# add the functions from the dll to the class
+for func in funcs:
+    setattr(Console, func, getattr(windll.kernel32, func))
+
+from event import Event
+
+VkKeyScan = windll.user32.VkKeyScanA
+
+
+class event(Event):
+    '''Represent events from the console.'''
+    def __init__(self, console, input):
+        '''Initialize an event from the Windows input structure.'''
+        self.type = '??'
+        self.serial = console.next_serial()
+        self.width = 0
+        self.height = 0
+        self.x = 0
+        self.y = 0
+        self.char = ''
+        self.keycode = 0
+        self.keysym = '??'
+        self.keyinfo = None # a tuple with (control, meta, shift, keycode) for dispatch
+        self.width = None
+        
+        if input.EventType == KEY_EVENT:
+            if input.Event.KeyEvent.bKeyDown:
+                self.type = "KeyPress"
+            else:
+                self.type = "KeyRelease"
+            self.char = input.Event.KeyEvent.uChar.AsciiChar
+            self.keycode = input.Event.KeyEvent.wVirtualKeyCode
+            self.state = input.Event.KeyEvent.dwControlKeyState
+            self.keyinfo=make_KeyPress(self.char,self.state,self.keycode)
+
+        elif input.EventType == MOUSE_EVENT:
+            if input.Event.MouseEvent.dwEventFlags & MOUSE_MOVED:
+                self.type = "Motion"
+            else:
+                self.type = "Button"
+            self.x = input.Event.MouseEvent.dwMousePosition.X
+            self.y = input.Event.MouseEvent.dwMousePosition.Y
+            self.state = input.Event.MouseEvent.dwButtonState
+        elif input.EventType == WINDOW_BUFFER_SIZE_EVENT:
+            self.type = "Configure"
+            self.width = input.Event.WindowBufferSizeEvent.dwSize.X
+            self.height = input.Event.WindowBufferSizeEvent.dwSize.Y
+        elif input.EventType == FOCUS_EVENT:
+            if input.Event.FocusEvent.bSetFocus:
+                self.type = "FocusIn"
+            else:
+                self.type = "FocusOut"
+        elif input.EventType == MENU_EVENT:
+            self.type = "Menu"
+            self.state = input.Event.MenuEvent.dwCommandId
+
+def getconsole(buffer=1):
+        """Get a console handle.
+
+        If buffer is non-zero, a new console buffer is allocated and
+        installed.  Otherwise, this returns a handle to the current
+        console buffer"""
+
+        c = Console(buffer)
+
+        return c
+
+# The following code uses ctypes to allow a Python callable to
+# substitute for GNU readline within the Python interpreter. Calling
+# raw_input or other functions that do input, inside your callable
+# might be a bad idea, then again, it might work.
+
+# The Python callable can raise EOFError or KeyboardInterrupt and
+# these will be translated into the appropriate outputs from readline
+# so that they will then be translated back!
+
+# If the Python callable raises any other exception, a traceback will
+# be printed and readline will appear to return an empty line.
+
+# I use ctypes to create a C-callable from a Python wrapper that
+# handles the exceptions and gets the result into the right form.
+
+# the type for our C-callable wrapper
+HOOKFUNC22 = CFUNCTYPE(c_char_p, c_char_p)
+HOOKFUNC23 = CFUNCTYPE(c_char_p, c_void_p, c_void_p, c_char_p)
+
+readline_hook = None # the python hook goes here
+readline_ref = None  # this holds a reference to the c-callable to keep it alive
+
+def hook_wrapper_23(stdin, stdout, prompt):
+    '''Wrap a Python readline so it behaves like GNU readline.'''
+    try:
+        # call the Python hook
+        res = readline_hook(prompt)
+        # make sure it returned the right sort of thing
+        if res and not isinstance(res, str):
+            raise TypeError, 'readline must return a string.'
+    except KeyboardInterrupt:
+        # GNU readline returns 0 on keyboard interrupt
+        return 0
+    except EOFError:
+        # It returns an empty string on EOF
+        res = ''
+    except:
+        print >>sys.stderr, 'Readline internal error'
+        traceback.print_exc()
+        res = '\n'
+    # we have to make a copy because the caller expects to free the result
+    n = len(res)
+    p = Console.PyMem_Malloc(n+1)
+    cdll.msvcrt.strncpy(p, res, n+1)
+    return p
+
+def hook_wrapper(prompt):
+    '''Wrap a Python readline so it behaves like GNU readline.'''
+    try:
+        # call the Python hook
+        res = readline_hook(prompt)
+        # make sure it returned the right sort of thing
+        if res and not isinstance(res, str):
+            raise TypeError, 'readline must return a string.'
+    except KeyboardInterrupt:
+        # GNU readline returns 0 on keyboard interrupt
+        return 0
+    except EOFError:
+        # It returns an empty string on EOF
+        res = ''
+    except:
+        print >>sys.stderr, 'Readline internal error'
+        traceback.print_exc()
+        res = '\n'
+    # we have to make a copy because the caller expects to free the result
+    p = cdll.msvcrt._strdup(res)
+    return p
+
+def install_readline(hook):
+    '''Set up things for the interpreter to call our function like GNU readline.'''
+    global readline_hook, readline_ref
+    # save the hook so the wrapper can call it
+    readline_hook = hook
+    # get the address of PyOS_ReadlineFunctionPointer so we can update it
+    PyOS_RFP = c_int.from_address(Console.GetProcAddress(sys.dllhandle,
+                                                 "PyOS_ReadlineFunctionPointer"))
+    # save a reference to the generated C-callable so it doesn't go away
+    if sys.version < '2.3':
+        readline_ref = HOOKFUNC22(hook_wrapper)
+    else:
+        readline_ref = HOOKFUNC23(hook_wrapper_23)
+    # get the address of the function
+    func_start = c_int.from_address(addressof(readline_ref)).value
+    # write the function address into PyOS_ReadlineFunctionPointer
+    PyOS_RFP.value = func_start
+
+if __name__ == '__main__':
+    import time, sys
+
+    
+    def p(char):
+        return chr(VkKeyScan(ord(char)) & 0xff)
+
+    c = Console(0)
+    sys.stdout = c
+    sys.stderr = c
+    c.page()
+    print p("d"),p("D")
+    c.pos(5, 10)
+    c.write('hi there')
+    print 'some printed output'
+    for i in range(10):
+        c.getkeypress()
+    del c
diff --git a/windows/fuzzbunch/pyreadline/console/console_attributes.py b/windows/fuzzbunch/pyreadline/console/console_attributes.py
new file mode 100644
index 0000000..9262331
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/console/console_attributes.py
@@ -0,0 +1,16 @@
+
+FOREGROUND_BLUE           = 0x0001
+FOREGROUND_GREEN          = 0x0002
+FOREGROUND_RED            = 0x0004
+FOREGROUND_INTENSITY      = 0x0008
+BACKGROUND_BLUE           = 0x0010
+BACKGROUND_GREEN          = 0x0020
+BACKGROUND_RED            = 0x0040
+BACKGROUND_INTENSITY      = 0x0080
+COMMON_LVB_LEADING_BYTE   = 0x0100
+COMMON_LVB_TRAILING_BYTE  = 0x0200
+COMMON_LVB_GRID_HORIZONTAL= 0x0400
+COMMON_LVB_GRID_LVERTICAL = 0x0800
+COMMON_LVB_GRID_RVERTICAL = 0x1000
+COMMON_LVB_REVERSE_VIDEO  = 0x2000
+COMMON_LVB_UNDERSCORE     = 0x4000
diff --git a/windows/fuzzbunch/pyreadline/console/consolebase.py b/windows/fuzzbunch/pyreadline/console/consolebase.py
new file mode 100644
index 0000000..79afd24
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/console/consolebase.py
@@ -0,0 +1,52 @@
+class baseconsole:
+    def __init__(self):
+        pass
+        
+    def bell(self):
+        raise NotImplementedError
+
+    def pos(self, x=None, y=None):
+        '''Move or query the window cursor.'''
+        raise NotImplementedError
+
+    def size(self):
+        raise NotImplementedError
+
+    def rectangle(self, rect, attr=None, fill=' '):
+        '''Fill Rectangle.'''
+        raise NotImplementedError
+
+    def write_scrolling(self, text, attr=None):
+        '''write text at current cursor position while watching for scrolling.
+
+        If the window scrolls because you are at the bottom of the screen
+        buffer, all positions that you are storing will be shifted by the
+        scroll amount. For example, I remember the cursor position of the
+        prompt so that I can redraw the line but if the window scrolls,
+        the remembered position is off.
+
+        This variant of write tries to keep track of the cursor position
+        so that it will know when the screen buffer is scrolled. It
+        returns the number of lines that the buffer scrolled.
+
+        '''
+        raise NotImplementedError
+    
+    def getkeypress(self):
+        '''Return next key press event from the queue, ignoring others.'''
+        raise NotImplementedError
+        
+    def write(self, text):
+        raise NotImplementedError
+    
+    def page(self, attr=None, fill=' '):
+        '''Fill the entire screen.'''
+        raise NotImplementedError
+
+    def isatty(self):
+        return True
+
+    def flush(self):
+        pass
+
+    
\ No newline at end of file
diff --git a/windows/fuzzbunch/pyreadline/console/event.py b/windows/fuzzbunch/pyreadline/console/event.py
new file mode 100644
index 0000000..6bd03e3
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/console/event.py
@@ -0,0 +1,25 @@
+class Event(object):
+    '''Represent events from the console.'''
+    def __init__(self, console, input):
+        pass
+    def __repr__(self):
+        '''Display an event for debugging.'''
+        if self.type in ['KeyPress', 'KeyRelease']:
+            s = "%s char='%s'%d keysym='%s' keycode=%d:%x state=%x keyinfo=%s" % \
+                    (self.type, self.char, ord(self.char), self.keysym, self.keycode, self.keycode,
+                     self.state, self.keyinfo)
+        elif self.type in ['Motion', 'Button']:
+            s = '%s x=%d y=%d state=%x' % (self.type, self.x, self.y, self.state)
+        elif self.type == 'Configure':
+            s = '%s w=%d h=%d' % (self.type, self.width, self.height)
+        elif self.type in ['FocusIn', 'FocusOut']:
+            s = self.type
+        elif self.type == 'Menu':
+            s = '%s state=%x' % (self.type, self.state)
+        else:
+            s = 'unknown event type'
+        return s
+
+
+#    def __str__(self):
+#        return "('%s',%s,%s,%s)"%(self.char,self.key,self.state,self.keyinfo)
\ No newline at end of file
diff --git a/windows/fuzzbunch/pyreadline/console/ironpython_console.py b/windows/fuzzbunch/pyreadline/console/ironpython_console.py
new file mode 100644
index 0000000..bded923
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/console/ironpython_console.py
@@ -0,0 +1,428 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+'''Cursor control and color for the .NET console.
+'''
+
+#
+# Ironpython requires a patch to work do:
+#
+# In file PythonCommandLine.cs patch line:     
+#    class PythonCommandLine
+#    {
+
+# to:
+#    public class PythonCommandLine
+#    {
+#
+#
+#
+# primitive debug printing that won't interfere with the screen
+
+import clr,sys
+clr.AddReferenceToFileAndPath(sys.executable)
+import IronPythonConsole
+
+import sys
+import re
+import os
+
+import System
+
+from event import Event
+from pyreadline.logger import log,log_sock
+
+#print "Codepage",System.Console.InputEncoding.CodePage
+from pyreadline.keysyms import make_keysym, make_keyinfo,make_KeyPress,make_KeyPress_from_keydescr
+from pyreadline.console.ansi import AnsiState
+color=System.ConsoleColor
+
+ansicolor={"0;30": color.Black,
+           "0;31": color.DarkRed,
+           "0;32": color.DarkGreen,
+           "0;33": color.DarkYellow,
+           "0;34": color.DarkBlue,
+           "0;35": color.DarkMagenta,
+           "0;36": color.DarkCyan,
+           "0;37": color.DarkGray,
+           "1;30": color.Gray,
+           "1;31": color.Red,
+           "1;32": color.Green,
+           "1;33": color.Yellow,
+           "1;34": color.Blue,
+           "1;35": color.Magenta,
+           "1;36": color.Cyan,
+           "1;37": color.White
+          }
+
+winattr={"black":0,"darkgray":0+8,
+         "darkred":4,"red":4+8,
+         "darkgreen":2,"green":2+8,
+         "darkyellow":6,"yellow":6+8,
+         "darkblue":1,"blue":1+8,
+         "darkmagenta":5, "magenta":5+8,
+         "darkcyan":3,"cyan":3+8,
+         "gray":7,"white":7+8}
+
+class Console(object):
+    '''Console driver for Windows.
+
+    '''
+
+    def __init__(self, newbuffer=0):
+        '''Initialize the Console object.
+
+        newbuffer=1 will allocate a new buffer so the old content will be restored
+        on exit.
+        '''
+        self.serial=0
+        self.attr = System.Console.ForegroundColor
+        self.saveattr = winattr[str(System.Console.ForegroundColor).lower()]
+        self.savebg=System.Console.BackgroundColor
+        log('initial attr=%s' % self.attr)
+        log_sock("%s"%self.saveattr)
+
+    def _get(self):
+        top=System.Console.WindowTop
+        log_sock("WindowTop:%s"%top,"console")
+        return top
+    def _set(self,value):
+        top=System.Console.WindowTop
+        log_sock("Set WindowTop:old:%s,new:%s"%(top,value),"console")
+    WindowTop=property(_get,_set)
+    del _get,_set
+
+    def __del__(self):
+        '''Cleanup the console when finished.'''
+        # I don't think this ever gets called
+        pass
+
+    def pos(self, x=None, y=None):
+        '''Move or query the window cursor.'''
+        if x is not None:
+            System.Console.CursorLeft=x
+        else:
+            x=System.Console.CursorLeft
+        if y is not None:
+            System.Console.CursorTop=y
+        else:
+            y=System.Console.CursorTop
+        return x,y
+
+    def home(self):
+        '''Move to home.'''
+        self.pos(0,0)
+
+# Map ANSI color escape sequences into Windows Console Attributes
+
+    terminal_escape = re.compile('(\001?\033\\[[0-9;]*m\002?)')
+    escape_parts = re.compile('\001?\033\\[([0-9;]*)m\002?')
+
+    # This pattern should match all characters that change the cursor position differently
+    # than a normal character.
+    motion_char_re = re.compile('([\n\r\t\010\007])')
+
+    def write_scrolling(self, text, attr=None):
+        '''write text at current cursor position while watching for scrolling.
+
+        If the window scrolls because you are at the bottom of the screen
+        buffer, all positions that you are storing will be shifted by the
+        scroll amount. For example, I remember the cursor position of the
+        prompt so that I can redraw the line but if the window scrolls,
+        the remembered position is off.
+
+        This variant of write tries to keep track of the cursor position
+        so that it will know when the screen buffer is scrolled. It
+        returns the number of lines that the buffer scrolled.
+
+        '''
+        x, y = self.pos()
+        w, h = self.size()
+        scroll = 0 # the result
+
+        # split the string into ordinary characters and funny characters
+        chunks = self.motion_char_re.split(text)
+        for chunk in chunks:
+            log('C:'+chunk)
+            n = self.write_color(chunk, attr)
+            if len(chunk) == 1: # the funny characters will be alone
+                if chunk[0] == '\n': # newline
+                    x = 0
+                    y += 1
+                elif chunk[0] == '\r': # carriage return
+                    x = 0
+                elif chunk[0] == '\t': # tab
+                    x = 8*(int(x/8)+1)
+                    if x > w: # newline
+                        x -= w
+                        y += 1
+                elif chunk[0] == '\007': # bell
+                    pass
+                elif chunk[0] == '\010':
+                    x -= 1
+                    if x < 0:
+                        y -= 1 # backed up 1 line
+                else: # ordinary character
+                    x += 1
+                if x == w: # wrap
+                    x = 0
+                    y += 1
+                if y == h: # scroll
+                    scroll += 1
+                    y = h - 1
+            else: # chunk of ordinary characters
+                x += n
+                l = int(x / w) # lines we advanced
+                x = x % w # new x value
+                y += l
+                if y >= h: # scroll
+                    scroll += y - h + 1
+                    y = h - 1
+        return scroll
+
+    trtable={0:color.Black,4:color.DarkRed,2:color.DarkGreen,6:color.DarkYellow,
+             1:color.DarkBlue,5:color.DarkMagenta,3:color.DarkCyan,7:color.Gray,
+             8:color.DarkGray,4+8:color.Red,2+8:color.Green,6+8:color.Yellow,
+             1+8:color.Blue,5+8:color.Magenta,3+8:color.Cyan,7+8:color.White}
+
+    def write_color(self, text, attr=None):
+        '''write text at current cursor position and interpret color escapes.
+
+        return the number of characters written.
+        '''
+        log('write_color("%s", %s)' % (text, attr))
+        chunks = self.terminal_escape.split(text)
+        log('chunks=%s' % repr(chunks))
+        bg=self.savebg
+        n = 0 # count the characters we actually write, omitting the escapes
+        if attr is None:#use attribute from initial console
+            attr = self.attr
+        try:
+            fg=self.trtable[(0x000f&attr)]
+            bg=self.trtable[(0x00f0&attr)>>4]
+        except TypeError:
+            fg=attr
+            
+        for chunk in chunks:
+            m = self.escape_parts.match(chunk)
+            if m:
+                log(m.group(1))
+                attr=ansicolor.get(m.group(1),self.attr)
+            n += len(chunk)
+            System.Console.ForegroundColor=fg
+            System.Console.BackgroundColor=bg
+            #self.WriteConsoleA(self.hout, chunk, len(chunk), byref(junk), None)
+            System.Console.Write(chunk)
+        return n
+
+    def write_plain(self, text, attr=None):
+        '''write text at current cursor position.'''
+        log('write("%s", %s)' %(text,attr))
+        if attr is None:
+            attr = self.attr
+        n = c_int(0)
+        self.SetConsoleTextAttribute(self.hout, attr)
+        self.WriteConsoleA(self.hout, text, len(text), byref(n), None)
+        return len(text)
+        
+    if os.environ.has_key("EMACS"):
+        def write_color(self, text, attr=None):
+            junk = c_int(0)
+            self.WriteFile(self.hout, text, len(text), byref(junk), None)
+            return len(text)
+        write_plain = write_color
+
+    # make this class look like a file object
+    def write(self, text):
+        log('write("%s")' % text)
+        return self.write_color(text)
+
+    #write = write_scrolling
+
+    def isatty(self):
+        return True
+
+    def flush(self):
+        pass
+
+    def page(self, attr=None, fill=' '):
+        '''Fill the entire screen.'''
+        System.Console.Clear()
+
+    def text(self, x, y, text, attr=None):
+        '''Write text at the given position.'''
+        self.pos(x,y)
+        self.write_color(text,attr)
+
+    def clear_to_end_of_window(self):
+        oldtop=self.WindowTop
+        lastline=self.WindowTop+System.Console.WindowHeight
+        pos=self.pos()
+        w,h=self.size()
+        length=w-pos[0]+min((lastline-pos[1]-1),5)*w-1
+        self.write_color(length*" ")
+        self.pos(*pos)
+        self.WindowTop=oldtop
+        
+    def rectangle(self, rect, attr=None, fill=' '):
+        '''Fill Rectangle.'''
+        pass
+        oldtop=self.WindowTop
+        oldpos=self.pos()
+        #raise NotImplementedError
+        x0, y0, x1, y1 = rect
+        if attr is None:
+            attr = self.attr
+        if fill:
+            rowfill=fill[:1]*abs(x1-x0)
+        else:
+            rowfill=' '*abs(x1-x0)
+        for y in range(y0, y1):
+                System.Console.SetCursorPosition(x0,y)
+                self.write_color(rowfill,attr)
+        self.pos(*oldpos)
+
+    def scroll(self, rect, dx, dy, attr=None, fill=' '):
+        '''Scroll a rectangle.'''
+        pass
+        raise NotImplementedError
+
+    def scroll_window(self, lines):
+        '''Scroll the window by the indicated number of lines.'''
+        top=self.WindowTop+lines
+        if top<0:
+            top=0
+        if top+System.Console.WindowHeight>System.Console.BufferHeight:
+            top=System.Console.BufferHeight
+        self.WindowTop=top
+
+    def getkeypress(self):
+        '''Return next key press event from the queue, ignoring others.'''
+        ck=System.ConsoleKey
+        while 1:
+            e = System.Console.ReadKey(True)
+            if e.Key == System.ConsoleKey.PageDown: #PageDown
+                self.scroll_window(12)
+            elif e.Key == System.ConsoleKey.PageUp:#PageUp
+                self.scroll_window(-12)
+            elif str(e.KeyChar)=="\000":#Drop deadkeys
+                log_sock("Deadkey: %s"%e)
+                return event(self,e)
+                pass
+            else:
+                return event(self,e)
+
+    def title(self, txt=None):
+        '''Set/get title.'''
+        if txt:
+            System.Console.Title=txt
+        else:
+            return System.Console.Title
+
+    def size(self, width=None, height=None):
+        '''Set/get window size.'''
+        sc=System.Console
+        
+    
+        if width is not None and height is not None:
+            sc.BufferWidth,sc.BufferHeight=width,height
+        else:
+            return sc.BufferWidth,sc.BufferHeight
+
+        if width is not None and height is not None:
+            sc.WindowWidth,sc.WindowHeight=width,height
+        else:
+            return sc.WindowWidth-1,sc.WindowHeight-1
+    
+    def cursor(self, visible=True, size=None):
+        '''Set cursor on or off.'''
+        System.Console.CursorVisible=visible
+
+    def bell(self):
+        System.Console.Beep()
+
+    def next_serial(self):
+        '''Get next event serial number.'''
+        self.serial += 1
+        return self.serial
+
+class event(Event):
+    '''Represent events from the console.'''
+    def __init__(self, console, input):
+        '''Initialize an event from the Windows input structure.'''
+        self.type = '??'
+        self.serial = console.next_serial()
+        self.width = 0
+        self.height = 0
+        self.x = 0
+        self.y = 0
+        self.char = str(input.KeyChar)
+        self.keycode = input.Key
+        self.state = input.Modifiers
+        log_sock("%s,%s,%s"%(input.Modifiers,input.Key,input.KeyChar),"console")
+        self.type="KeyRelease"
+        self.keysym = make_keysym(self.keycode)
+        self.keyinfo = make_KeyPress(self.char, self.state, self.keycode)
+
+def make_event_from_keydescr(keydescr):
+    def input():
+        return 1
+    input.KeyChar="a"
+    input.Key=System.ConsoleKey.A
+    input.Modifiers=System.ConsoleModifiers.Shift
+    input.next_serial=input
+    e=event(input,input)
+    del input.next_serial
+    keyinfo=make_KeyPress_from_keydescr(keydescr)
+    e.keyinfo=keyinfo
+    return e
+
+CTRL_C_EVENT=make_event_from_keydescr("Control-c")
+
+def install_readline(hook):
+    def hook_wrap():
+        try:
+            res=hook()
+        except KeyboardInterrupt,x:   #this exception does not seem to be caught
+            res=""
+        except EOFError:
+            return None
+        if res[-1:]=="\n":
+            return res[:-1]
+        else:
+            return res
+    class IronPythonWrapper(IronPythonConsole.IConsole):
+        def ReadLine(self,autoIndentSize): 
+            return hook_wrap()
+        def Write(self,text, style):
+            System.Console.Write(text)
+        def WriteLine(self,text, style): 
+            System.Console.WriteLine(text)
+    IronPythonConsole.PythonCommandLine.MyConsole = IronPythonWrapper()
+
+
+
+if __name__ == '__main__':
+    import time, sys
+    c = Console(0)
+    sys.stdout = c
+    sys.stderr = c
+    c.page()
+    c.pos(5, 10)
+    c.write('hi there')
+    c.title("Testing console")
+#    c.bell()
+    print
+    print "size",c.size()
+    print '  some printed output'
+    for i in range(10):
+        e=c.getkeypress()
+        print e.Key,chr(e.KeyChar),ord(e.KeyChar),e.Modifiers
+    del c
+
+    System.Console.Clear()
diff --git a/windows/fuzzbunch/pyreadline/error.py b/windows/fuzzbunch/pyreadline/error.py
new file mode 100644
index 0000000..be2c24e
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/error.py
@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2006  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+
+class ReadlineError(Exception):
+    pass
+
+class GetSetError(ReadlineError):
+    pass
diff --git a/windows/fuzzbunch/pyreadline/get_doc.py b/windows/fuzzbunch/pyreadline/get_doc.py
new file mode 100644
index 0000000..111761f
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/get_doc.py
@@ -0,0 +1,18 @@
+import sys,textwrap
+
+rlmain=sys.modules["pyreadline.rlmain"]
+rl=rlmain.rl
+
+def get_doc(rl):
+    methods=[(x,getattr(rl,x)) for x in dir(rl) if callable(getattr(rl,x))]
+    return [ (x,m.__doc__ )for x,m in methods if m.__doc__]
+    
+    
+def get_rest(rl):
+    q=get_doc(rl)
+    out=[]
+    for funcname,doc in q:
+        out.append(funcname)
+        out.append("\n".join(textwrap.wrap(doc,80,initial_indent="   ")))
+        out.append("")
+    return out     
\ No newline at end of file
diff --git a/windows/fuzzbunch/pyreadline/keysyms/__init__.py b/windows/fuzzbunch/pyreadline/keysyms/__init__.py
new file mode 100644
index 0000000..bbb82b1
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/keysyms/__init__.py
@@ -0,0 +1,20 @@
+import sys
+
+success=False
+in_ironpython="IronPython" in sys.version
+
+if in_ironpython:
+    try:
+        from ironpython_keysyms import *
+        success=True
+    except ImportError,x:
+        raise
+else:
+    try:
+        from keysyms import *
+        success=True
+    except ImportError,x:
+        pass
+    
+if not success:
+    raise ImportError("Could not import keysym for local pythonversion",x)
\ No newline at end of file
diff --git a/windows/fuzzbunch/pyreadline/keysyms/common.py b/windows/fuzzbunch/pyreadline/keysyms/common.py
new file mode 100644
index 0000000..7fa4e5d
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/keysyms/common.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+# table for translating virtual keys to X windows key symbols
+
+try:
+    set
+except NameError:
+    from sets import Set as set
+    
+
+
+validkey =set(['cancel',     'backspace',    'tab',          'clear',
+              'return',      'shift_l',      'control_l',    'alt_l',
+              'pause',       'caps_lock',    'escape',       'space',
+              'prior',       'next',         'end',          'home',
+              'left',        'up',           'right',        'down',
+              'select',      'print',        'execute',      'snapshot',
+              'insert',      'delete',       'help',         'f1',
+              'f2',          'f3',           'f4',           'f5',
+              'f6',          'f7',           'f8',           'f9',
+              'f10',         'f11',          'f12',          'f13',
+              'f14',         'f15',          'f16',          'f17',
+              'f18',         'f19',          'f20',          'f21',
+              'f22',         'f23',          'f24',          'num_lock',
+              'scroll_lock', 'vk_apps',      'vk_processkey','vk_attn',
+              'vk_crsel',    'vk_exsel',     'vk_ereof',     'vk_play',
+              'vk_zoom',     'vk_noname',    'vk_pa1',       'vk_oem_clear',
+              'numpad0',     'numpad1',      'numpad2',      'numpad3',
+              'numpad4',     'numpad5',      'numpad6',      'numpad7',
+              'numpad8',     'numpad9',      'divide',       'multiply',
+              'add',         'subtract',     'vk_decimal'])
+
+escape_sequence_to_special_key={"\\e[a":"up","\\e[b":"down","del":"delete"}
+
+class KeyPress(object):
+    def __init__(self,char="",shift=False,control=False,meta=False,keyname=""):
+        if control or meta or shift:
+            char=char.upper()
+        self.info=dict(char=char,
+                       shift=shift,
+                       control=control,
+                       meta=meta,
+                       keyname=keyname)
+        
+    def create(name):
+        def get(self):
+            return self.info[name]
+        def set(self,value):
+            self.info[name]=value
+        return property(get,set)
+    char=create("char")
+    shift=create("shift")
+    control=create("control")
+    meta=create("meta")
+    keyname=create("keyname")
+        
+    def __repr__(self):
+        return "(%s,%s,%s,%s)"%self.tuple()
+
+    def tuple(self):
+        if self.keyname:
+            return (self.control,self.meta,self.shift,self.keyname)
+        else:
+            if self.control or self.meta or self.shift:
+                return (self.control,self.meta,self.shift,self.char.upper())
+            else:
+                return (self.control,self.meta,self.shift,self.char)
+
+def make_KeyPress_from_keydescr(keydescr):
+    keyinfo=KeyPress()
+    if len(keydescr)>2 and keydescr[:1]=='"' and keydescr[-1:]=='"':
+        keydescr=keydescr[1:-1]
+        
+    while 1:
+        lkeyname = keydescr.lower()
+        if lkeyname.startswith('control-'):
+            keyinfo.control = True
+            keydescr = keydescr[8:]
+        elif lkeyname.startswith('ctrl-'):
+            keyinfo.control = True
+            keydescr = keydescr[5:]
+        elif keydescr.lower().startswith('\\c-'):
+            keyinfo.control = True
+            keydescr = keydescr[3:]
+        elif keydescr.lower().startswith('\\m-'):
+            keyinfo.meta = True
+            keydescr = keydescr[3:]
+        elif keydescr in escape_sequence_to_special_key:
+            keydescr = escape_sequence_to_special_key[keydescr]
+        elif lkeyname.startswith('meta-'):
+            keyinfo.meta = True
+            keydescr = keydescr[5:]
+        elif lkeyname.startswith('alt-'):
+            keyinfo.meta = True
+            keydescr = keydescr[4:]
+        elif lkeyname.startswith('shift-'):
+            keyinfo.shift = True
+            keydescr = keydescr[6:]
+        else:
+            if len(keydescr) > 1:
+                if keydescr.strip().lower() in validkey:
+                    keyinfo.keyname=keydescr.strip().lower()
+                    keyinfo.char=""
+                else:
+                    raise IndexError("Not a valid key: '%s'"%keydescr)
+            else:
+                keyinfo.char=keydescr
+            return keyinfo
+
+if __name__=="__main__":
+    import startup
+    
\ No newline at end of file
diff --git a/windows/fuzzbunch/pyreadline/keysyms/ironpython_keysyms.py b/windows/fuzzbunch/pyreadline/keysyms/ironpython_keysyms.py
new file mode 100644
index 0000000..dc7168a
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/keysyms/ironpython_keysyms.py
@@ -0,0 +1,206 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+import System
+from common import validkey,KeyPress,make_KeyPress_from_keydescr
+#from pyreadline.logger import log_sock
+c32=System.ConsoleKey
+Shift=System.ConsoleModifiers.Shift
+Control=System.ConsoleModifiers.Control
+Alt=System.ConsoleModifiers.Alt
+# table for translating virtual keys to X windows key symbols
+code2sym_map = {#c32.CANCEL: 'Cancel',
+                c32.Backspace:  'BackSpace',
+                c32.Tab:        'Tab',
+                c32.Clear:      'Clear',
+                c32.Enter:     'Return',
+#                c32.Shift:      'Shift_L',
+#                c32.Control:   'Control_L',
+#                c32.Menu:      'Alt_L',
+                c32.Pause:      'Pause',
+#                c32.Capital:    'Caps_Lock',
+                c32.Escape:     'Escape',
+#                c32.Space:      'space',
+                c32.PageUp:      'Prior',
+                c32.PageDown:       'Next',
+                c32.End:        'End',
+                c32.Home:       'Home',
+                c32.LeftArrow:       'Left',
+                c32.UpArrow:         'Up',
+                c32.RightArrow:      'Right',
+                c32.DownArrow:       'Down',
+                c32.Select:     'Select',
+                c32.Print:      'Print',
+                c32.Execute:    'Execute',
+#                c32.Snapshot:   'Snapshot',
+                c32.Insert:     'Insert',
+                c32.Delete:     'Delete',
+                c32.Help:       'Help',
+                c32.F1:         'F1',
+                c32.F2:         'F2',
+                c32.F3:         'F3',
+                c32.F4:         'F4',
+                c32.F5:         'F5',
+                c32.F6:         'F6',
+                c32.F7:         'F7',
+                c32.F8:         'F8',
+                c32.F9:         'F9',
+                c32.F10:        'F10',
+                c32.F11:        'F11',
+                c32.F12:        'F12',
+                c32.F13:        'F13',
+                c32.F14:        'F14',
+                c32.F15:        'F15',
+                c32.F16:        'F16',
+                c32.F17:        'F17',
+                c32.F18:        'F18',
+                c32.F19:        'F19',
+                c32.F20:        'F20',
+                c32.F21:        'F21',
+                c32.F22:        'F22',
+                c32.F23:        'F23',
+                c32.F24:        'F24',
+#                c32.Numlock:    'Num_Lock,',
+#                c32.Scroll:     'Scroll_Lock',
+#                c32.Apps:       'VK_APPS',
+#                c32.ProcesskeY: 'VK_PROCESSKEY',
+#                c32.Attn:       'VK_ATTN',
+#                c32.Crsel:      'VK_CRSEL',
+#                c32.Exsel:      'VK_EXSEL',
+#                c32.Ereof:      'VK_EREOF',
+#                c32.Play:       'VK_PLAY',
+#                c32.Zoom:       'VK_ZOOM',
+#                c32.Noname:     'VK_NONAME',
+#                c32.Pa1:        'VK_PA1',
+                c32.OemClear:  'VK_OEM_CLEAR',
+                c32.NumPad0:    'NUMPAD0',
+                c32.NumPad1:    'NUMPAD1',
+                c32.NumPad2:    'NUMPAD2',
+                c32.NumPad3:    'NUMPAD3',
+                c32.NumPad4:    'NUMPAD4',
+                c32.NumPad5:    'NUMPAD5',
+                c32.NumPad6:    'NUMPAD6',
+                c32.NumPad7:    'NUMPAD7',
+                c32.NumPad8:    'NUMPAD8',
+                c32.NumPad9:    'NUMPAD9',
+                c32.Divide:     'Divide',
+                c32.Multiply:   'Multiply',
+                c32.Add:        'Add',
+                c32.Subtract:   'Subtract',
+                c32.Decimal:    'VK_DECIMAL'
+               }
+
+# function to handle the mapping
+def make_keysym(keycode):
+    try:
+        sym = code2sym_map[keycode]
+    except KeyError:
+        sym = ''
+    return sym
+
+sym2code_map = {}
+for code,sym in code2sym_map.iteritems():
+    sym2code_map[sym.lower()] = code
+
+def key_text_to_keyinfo(keytext):
+    '''Convert a GNU readline style textual description of a key to keycode with modifiers'''
+    if keytext.startswith('"'): # "
+        return keyseq_to_keyinfo(keytext[1:-1])
+    else:
+        return keyname_to_keyinfo(keytext)
+
+
+def char_to_keyinfo(char, control=False, meta=False, shift=False):
+    vk = (ord(char))
+    if vk & 0xffff == 0xffff:
+        print 'VkKeyScan("%s") = %x' % (char, vk)
+        raise ValueError, 'bad key'
+    if vk & 0x100:
+        shift = True
+    if vk & 0x200:
+        control = True
+    if vk & 0x400:
+        meta = True
+    return (control, meta, shift, vk & 0xff)
+
+def keyname_to_keyinfo(keyname):
+    control = False
+    meta = False
+    shift = False
+
+    while 1:
+        lkeyname = keyname.lower()
+        if lkeyname.startswith('control-'):
+            control = True
+            keyname = keyname[8:]
+        elif lkeyname.startswith('ctrl-'):
+            control = True
+            keyname = keyname[5:]
+        elif lkeyname.startswith('meta-'):
+            meta = True
+            keyname = keyname[5:]
+        elif lkeyname.startswith('alt-'):
+            meta = True
+            keyname = keyname[4:]
+        elif lkeyname.startswith('shift-'):
+            shift = True
+            keyname = keyname[6:]
+        else:
+            if len(keyname) > 1:
+                return (control, meta, shift, sym2code_map.get(keyname.lower()," "))
+            else:
+                return char_to_keyinfo(keyname, control, meta, shift)
+
+def keyseq_to_keyinfo(keyseq):
+    res = []
+    control = False
+    meta = False
+    shift = False
+
+    while 1:
+        if keyseq.startswith('\\C-'):
+            control = True
+            keyseq = keyseq[3:]
+        elif keyseq.startswith('\\M-'):
+            meta = True
+            keyseq = keyseq[3:]
+        elif keyseq.startswith('\\e'):
+            res.append(char_to_keyinfo('\033', control, meta, shift))
+            control = meta = shift = False
+            keyseq = keyseq[2:]
+        elif len(keyseq) >= 1:
+            res.append(char_to_keyinfo(keyseq[0], control, meta, shift))
+            control = meta = shift = False
+            keyseq = keyseq[1:]
+        else:
+            return res[0]
+
+def make_keyinfo(keycode, state):
+#    control = (state & (4+8)) != 0
+#    meta = (state & (1+2)) != 0
+#    shift = (state & 0x10) != 0
+    control=False
+    meta=False
+    shift=False
+    return (control, meta, shift, keycode)
+
+
+def make_KeyPress(char,state,keycode):
+
+    shift=bool(int(state)&int(Shift))
+    control=bool(int(state)&int(Control))
+    meta=bool(int(state)&int(Alt))
+    keyname=code2sym_map.get(keycode,"").lower()
+#    log_sock("make key %s %s %s %s"%(shift,control,meta,keycode),"keysyms")
+    if control and meta: #equivalent to altgr so clear flags
+        control=False
+        meta=False    
+    elif control:
+        char=str(keycode)
+    return KeyPress(char,shift,control,meta,keyname)
+
diff --git a/windows/fuzzbunch/pyreadline/keysyms/keysyms.py b/windows/fuzzbunch/pyreadline/keysyms/keysyms.py
new file mode 100644
index 0000000..6d62de7
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/keysyms/keysyms.py
@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+import winconstants as c32
+from ctypes import windll
+import ctypes
+# table for translating virtual keys to X windows key symbols
+
+from common import validkey,KeyPress,make_KeyPress_from_keydescr
+
+code2sym_map = {c32.VK_CANCEL:     'cancel',
+                c32.VK_BACK:       'backspace',
+                c32.VK_TAB:        'tab',
+                c32.VK_CLEAR:      'clear',
+                c32.VK_RETURN:     'return',
+                c32.VK_SHIFT:      'shift_l',
+                c32.VK_CONTROL:    'control_l',
+                c32.VK_MENU:       'alt_l',
+                c32.VK_PAUSE:      'pause',
+                c32.VK_CAPITAL:    'caps_lock',
+                c32.VK_ESCAPE:     'escape',
+                c32.VK_SPACE:      'space',
+                c32.VK_PRIOR:      'prior',
+                c32.VK_NEXT:       'next',
+                c32.VK_END:        'end',
+                c32.VK_HOME:       'home',
+                c32.VK_LEFT:       'left',
+                c32.VK_UP:         'up',
+                c32.VK_RIGHT:      'right',
+                c32.VK_DOWN:       'down',
+                c32.VK_SELECT:     'select',
+                c32.VK_PRINT:      'print',
+                c32.VK_EXECUTE:    'execute',
+                c32.VK_SNAPSHOT:   'snapshot',
+                c32.VK_INSERT:     'insert',
+                c32.VK_DELETE:     'delete',
+                c32.VK_HELP:       'help',
+                c32.VK_F1:         'f1',
+                c32.VK_F2:         'f2',
+                c32.VK_F3:         'f3',
+                c32.VK_F4:         'f4',
+                c32.VK_F5:         'f5',
+                c32.VK_F6:         'f6',
+                c32.VK_F7:         'f7',
+                c32.VK_F8:         'f8',
+                c32.VK_F9:         'f9',
+                c32.VK_F10:        'f10',
+                c32.VK_F11:        'f11',
+                c32.VK_F12:        'f12',
+                c32.VK_F13:        'f13',
+                c32.VK_F14:        'f14',
+                c32.VK_F15:        'f15',
+                c32.VK_F16:        'f16',
+                c32.VK_F17:        'f17',
+                c32.VK_F18:        'f18',
+                c32.VK_F19:        'f19',
+                c32.VK_F20:        'f20',
+                c32.VK_F21:        'f21',
+                c32.VK_F22:        'f22',
+                c32.VK_F23:        'f23',
+                c32.VK_F24:        'f24',
+                c32.VK_NUMLOCK:    'num_lock,',
+                c32.VK_SCROLL:     'scroll_lock',
+                c32.VK_APPS:       'vk_apps',
+                c32.VK_PROCESSKEY: 'vk_processkey',
+                c32.VK_ATTN:       'vk_attn',
+                c32.VK_CRSEL:      'vk_crsel',
+                c32.VK_EXSEL:      'vk_exsel',
+                c32.VK_EREOF:      'vk_ereof',
+                c32.VK_PLAY:       'vk_play',
+                c32.VK_ZOOM:       'vk_zoom',
+                c32.VK_NONAME:     'vk_noname',
+                c32.VK_PA1:        'vk_pa1',
+                c32.VK_OEM_CLEAR   :'vk_oem_clear',
+                c32.VK_NUMPAD0:    'numpad0',
+                c32.VK_NUMPAD1:    'numpad1',
+                c32.VK_NUMPAD2:    'numpad2',
+                c32.VK_NUMPAD3:    'numpad3',
+                c32.VK_NUMPAD4:    'numpad4',
+                c32.VK_NUMPAD5:    'numpad5',
+                c32.VK_NUMPAD6:    'numpad6',
+                c32.VK_NUMPAD7:    'numpad7',
+                c32.VK_NUMPAD8:    'numpad8',
+                c32.VK_NUMPAD9:    'numpad9',
+                c32.VK_DIVIDE:     'divide',
+                c32.VK_MULTIPLY:   'multiply',
+                c32.VK_ADD:        'add',
+                c32.VK_SUBTRACT:   'subtract',
+                c32.VK_DECIMAL:    'vk_decimal'
+               }
+
+VkKeyScan = windll.user32.VkKeyScanA
+
+def char_to_keyinfo(char, control=False, meta=False, shift=False):
+    k=KeyPress()
+    vk = VkKeyScan(ord(char))
+    if vk & 0xffff == 0xffff:
+        print 'VkKeyScan("%s") = %x' % (char, vk)
+        raise ValueError, 'bad key'
+    if vk & 0x100:
+        k.shift = True
+    if vk & 0x200:
+        k.control = True
+    if vk & 0x400:
+        k.meta = True
+    k.char=chr(vk & 0xff)
+    return k
+
+def make_KeyPress(char,state,keycode):
+    control = (state & (4+8)) != 0
+    meta = (state & (1+2)) != 0
+    shift = (state & 0x10) != 0
+    if control and char !="\x00":
+       char = chr(VkKeyScan(ord(char)) & 0xff)
+    elif control:
+        char=chr(keycode)
+    try:
+        keyname=code2sym_map[keycode]
+    except KeyError:
+        keyname=""
+    return KeyPress(char,shift,control,meta,keyname)
+
+if __name__=="__main__":
+    import startup
+    
\ No newline at end of file
diff --git a/windows/fuzzbunch/pyreadline/keysyms/winconstants.py b/windows/fuzzbunch/pyreadline/keysyms/winconstants.py
new file mode 100644
index 0000000..5e0ed63
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/keysyms/winconstants.py
@@ -0,0 +1,171 @@
+#This file contains constants that are normally found in win32all
+#But included here to avoid the dependency
+
+VK_LBUTTON=1
+VK_RBUTTON=2
+VK_CANCEL=3
+VK_MBUTTON=4
+VK_XBUTTON1=5
+VK_XBUTTON2=6
+VK_BACK=8
+VK_TAB=9
+VK_CLEAR=12
+VK_RETURN=13
+VK_SHIFT=16
+VK_CONTROL=17
+VK_MENU=18
+VK_PAUSE=19
+VK_CAPITAL=20
+VK_KANA=0x15
+VK_HANGEUL=0x15
+VK_HANGUL=0x15
+VK_JUNJA=0x17
+VK_FINAL=0x18
+VK_HANJA=0x19
+VK_KANJI=0x19
+VK_ESCAPE=0x1B
+VK_CONVERT=0x1C
+VK_NONCONVERT=0x1D
+VK_ACCEPT=0x1E
+VK_MODECHANGE=0x1F
+VK_SPACE=32
+VK_PRIOR=33
+VK_NEXT=34
+VK_END=35
+VK_HOME=36
+VK_LEFT=37
+VK_UP=38
+VK_RIGHT=39
+VK_DOWN=40
+VK_SELECT=41
+VK_PRINT=42
+VK_EXECUTE=43
+VK_SNAPSHOT=44
+VK_INSERT=45
+VK_DELETE=46
+VK_HELP=47
+VK_LWIN=0x5B
+VK_RWIN=0x5C
+VK_APPS=0x5D
+VK_SLEEP=0x5F
+VK_NUMPAD0=0x60
+VK_NUMPAD1=0x61
+VK_NUMPAD2=0x62
+VK_NUMPAD3=0x63
+VK_NUMPAD4=0x64
+VK_NUMPAD5=0x65
+VK_NUMPAD6=0x66
+VK_NUMPAD7=0x67
+VK_NUMPAD8=0x68
+VK_NUMPAD9=0x69
+VK_MULTIPLY=0x6A
+VK_ADD=0x6B
+VK_SEPARATOR=0x6C
+VK_SUBTRACT=0x6D
+VK_DECIMAL=0x6E
+VK_DIVIDE=0x6F
+VK_F1=0x70
+VK_F2=0x71
+VK_F3=0x72
+VK_F4=0x73
+VK_F5=0x74
+VK_F6=0x75
+VK_F7=0x76
+VK_F8=0x77
+VK_F9=0x78
+VK_F10=0x79
+VK_F11=0x7A
+VK_F12=0x7B
+VK_F13=0x7C
+VK_F14=0x7D
+VK_F15=0x7E
+VK_F16=0x7F
+VK_F17=0x80
+VK_F18=0x81
+VK_F19=0x82
+VK_F20=0x83
+VK_F21=0x84
+VK_F22=0x85
+VK_F23=0x86
+VK_F24=0x87
+VK_NUMLOCK=0x90
+VK_SCROLL=0x91
+VK_LSHIFT=0xA0
+VK_RSHIFT=0xA1
+VK_LCONTROL=0xA2
+VK_RCONTROL=0xA3
+VK_LMENU=0xA4
+VK_RMENU=0xA5
+VK_BROWSER_BACK=0xA6
+VK_BROWSER_FORWARD=0xA7
+VK_BROWSER_REFRESH=0xA8
+VK_BROWSER_STOP=0xA9
+VK_BROWSER_SEARCH=0xAA
+VK_BROWSER_FAVORITES=0xAB
+VK_BROWSER_HOME=0xAC
+VK_VOLUME_MUTE=0xAD
+VK_VOLUME_DOWN=0xAE
+VK_VOLUME_UP=0xAF
+VK_MEDIA_NEXT_TRACK=0xB0
+VK_MEDIA_PREV_TRACK=0xB1
+VK_MEDIA_STOP=0xB2
+VK_MEDIA_PLAY_PAUSE=0xB3
+VK_LAUNCH_MAIL=0xB4
+VK_LAUNCH_MEDIA_SELECT=0xB5
+VK_LAUNCH_APP1=0xB6
+VK_LAUNCH_APP2=0xB7
+VK_OEM_1=0xBA
+VK_OEM_PLUS=0xBB
+VK_OEM_COMMA=0xBC
+VK_OEM_MINUS=0xBD
+VK_OEM_PERIOD=0xBE
+VK_OEM_2=0xBF
+VK_OEM_3=0xC0
+VK_OEM_4=0xDB
+VK_OEM_5=0xDC
+VK_OEM_6=0xDD
+VK_OEM_7=0xDE
+VK_OEM_8=0xDF
+VK_OEM_102=0xE2
+VK_PROCESSKEY=0xE5
+VK_PACKET=0xE7
+VK_ATTN=0xF6
+VK_CRSEL=0xF7
+VK_EXSEL=0xF8
+VK_EREOF=0xF9
+VK_PLAY=0xFA
+VK_ZOOM=0xFB
+VK_NONAME=0xFC
+VK_PA1=0xFD
+VK_OEM_CLEAR=0xFE
+
+CF_TEXT=1
+CF_BITMAP=2
+CF_METAFILEPICT=3
+CF_SYLK=4
+CF_DIF=5
+CF_TIFF=6
+CF_OEMTEXT=7
+CF_DIB=8
+CF_PALETTE=9
+CF_PENDATA=10
+CF_RIFF=11
+CF_WAVE=12
+CF_UNICODETEXT=13
+CF_ENHMETAFILE=14
+CF_HDROP=15
+CF_LOCALE=16
+CF_MAX=17
+CF_OWNERDISPLAY=128
+CF_DSPTEXT=129
+CF_DSPBITMAP=130
+CF_DSPMETAFILEPICT=131
+CF_DSPENHMETAFILE=142
+CF_PRIVATEFIRST=512
+CF_PRIVATELAST=767
+CF_GDIOBJFIRST=768
+CF_GDIOBJLAST=1023
+
+
+GPTR=64
+GHND=66
diff --git a/windows/fuzzbunch/pyreadline/lineeditor/__init__.py b/windows/fuzzbunch/pyreadline/lineeditor/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/windows/fuzzbunch/pyreadline/lineeditor/history.py b/windows/fuzzbunch/pyreadline/lineeditor/history.py
new file mode 100644
index 0000000..a7cfdaa
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/lineeditor/history.py
@@ -0,0 +1,245 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2006  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+import re,operator,string,sys,os
+
+#import wordmatcher
+#import pyreadline.clipboard as clipboard
+if "pyreadline" in sys.modules:
+    pyreadline= sys.modules["pyreadline"]
+else:
+    import pyreadline
+
+import lineobj
+
+import exceptions
+
+class EscapeHistory(exceptions.Exception):
+    pass
+
+from pyreadline.logger import log_sock
+
+class LineHistory(object):
+    def __init__(self):
+        self.history=[]
+        self._history_length=100
+        self._history_cursor=0
+        self.history_filename=os.path.expanduser('~/.history')
+        self.lastcommand=None
+        self.query=""
+
+    def get_history_length(self):
+        value=self._history_length
+        log_sock("get_history_length:%d"%value,"history")
+        return value
+
+    def set_history_length(self,value):
+        log_sock("set_history_length: old:%d new:%d"%(self._history_length,value),"history")
+        self._history_length=value
+
+    def get_history_cursor(self):
+        value=self._history_cursor
+        log_sock("get_history_cursor:%d"%value,"history")
+        return value
+
+    def set_history_cursor(self,value):
+        log_sock("set_history_cursor: old:%d new:%d"%(self._history_cursor,value),"history")
+        self._history_cursor=value
+        
+    history_length=property(get_history_length,set_history_length)
+    history_cursor=property(get_history_cursor,set_history_cursor)
+
+    def clear_history(self):
+        '''Clear readline history.'''
+        self.history[:] = []
+        self.history_cursor = 0
+
+    def read_history_file(self, filename=None): 
+        '''Load a readline history file.'''
+        if filename is None:
+            filename=self.history_filename
+        try:
+            for line in open(filename, 'r'):
+                self.add_history(lineobj.ReadLineTextBuffer(line.rstrip()))
+        except IOError:
+            self.history = []
+            self.history_cursor = 0
+
+    def write_history_file(self, filename=None): 
+        '''Save a readline history file.'''
+        if filename is None:
+            filename=self.history_filename
+        fp = open(filename, 'wb')
+        for line in self.history[-self.history_length:]:
+            fp.write(line.get_line_text())
+            fp.write('\n')
+        fp.close()
+
+
+    def add_history(self, line):
+        '''Append a line to the history buffer, as if it was the last line typed.'''
+        if not line.get_line_text():
+            pass
+        elif len(self.history) > 0 and self.history[-1].get_line_text() == line.get_line_text():
+            pass
+        else:
+            self.history.append(line)
+        self.history_cursor = len(self.history)
+
+    def previous_history(self,current): # (C-p)
+        '''Move back through the history list, fetching the previous command. '''
+        if self.history_cursor==len(self.history):
+            self.history.append(current.copy()) #do not use add_history since we do not want to increment cursor
+            
+        if self.history_cursor > 0:
+            self.history_cursor -= 1
+            current.set_line(self.history[self.history_cursor].get_line_text())
+            current.point=lineobj.EndOfLine
+
+    def next_history(self,current): # (C-n)
+        '''Move forward through the history list, fetching the next command. '''
+        if self.history_cursor < len(self.history)-1:
+            self.history_cursor += 1
+            current.set_line(self.history[self.history_cursor].get_line_text())
+
+    def beginning_of_history(self): # (M-<)
+        '''Move to the first line in the history.'''
+        self.history_cursor = 0
+        if len(self.history) > 0:
+            self.l_buffer = self.history[0]
+
+    def end_of_history(self,current): # (M->)
+        '''Move to the end of the input history, i.e., the line currently
+        being entered.'''
+        self.history_cursor=len(self.history)
+        current.set_line(self.history[-1].get_line_text())
+
+    def reverse_search_history(self,searchfor,startpos=None):
+        if startpos is None:
+            startpos=self.history_cursor
+        res=[(idx,line)  for idx,line in enumerate(self.history[startpos:0:-1]) if line.startswith(searchfor)]
+        if res:
+            self.history_cursor-=res[0][0]
+            return res[0][1].get_line_text()
+        return ""
+        
+    def forward_search_history(self,searchfor,startpos=None):
+        if startpos is None:
+            startpos=self.history_cursor
+        res=[(idx,line) for idx,line in enumerate(self.history[startpos:]) if line.startswith(searchfor)]
+        if res:
+            self.history_cursor+=res[0][0]
+            return res[0][1].get_line_text()
+        return ""
+
+    def _non_i_search(self, direction, current):
+        c = pyreadline.rl.console
+        line = current.get_line_text()
+        query = ''
+        while 1:
+            c.pos(*pyreadline.rl.prompt_end_pos)
+            scroll = c.write_scrolling(":%s" % query)
+            pyreadline.rl._update_prompt_pos(scroll)
+            pyreadline.rl._clear_after()
+
+            event = c.getkeypress()
+            log_sock(str(event),"history")
+            
+            if event.keyinfo.keyname == 'backspace':
+                if len(query) > 0:
+                    query = query[:-1]
+                else:
+                    break
+            elif event.char in string.letters + string.digits + string.punctuation + ' ':
+                query += event.char
+            elif event.keyinfo.keyname == 'return':
+                break
+            else:
+                pyreadline.rl._bell()
+        log_sock(query,"history")
+        res=""
+        if query:
+            if direction==-1:
+                res=self.reverse_search_history(query)
+                
+            else:
+                res=self.forward_search_history(query)
+            log_sock(res,"history")
+        return lineobj.ReadLineTextBuffer(res,point=0)
+        
+    def non_incremental_reverse_search_history(self,current): # (M-p)
+        '''Search backward starting at the current line and moving up
+        through the history as necessary using a non-incremental search for
+        a string supplied by the user.'''
+        return self._non_i_search(-1,current)
+
+    def non_incremental_forward_search_history(self,current): # (M-n)
+        '''Search forward starting at the current line and moving down
+        through the the history as necessary using a non-incremental search
+        for a string supplied by the user.'''
+        return self._non_i_search(1,current)
+
+    def _search(self, direction, partial):
+        try:
+            if (self.lastcommand != self.history_search_forward and
+                    self.lastcommand != self.history_search_backward):
+                self.query = ''.join(partial[0:partial.point].get_line_text())
+            hcstart=max(self.history_cursor,0) 
+            log_sock("hcstart %s"%hcstart,"history")
+            hc = self.history_cursor + direction
+            while (direction < 0 and hc >= 0) or (direction > 0 and hc < len(self.history)):
+                h = self.history[hc]
+                if not self.query:
+                    self.history_cursor = hc
+                    result=lineobj.ReadLineTextBuffer(h,point=len(h.get_line_text()))
+                    return result
+                elif h.get_line_text().startswith(self.query) and h != partial.get_line_text():
+                    self.history_cursor = hc
+                    result=lineobj.ReadLineTextBuffer(h,point=partial.point)
+                    return result
+                hc += direction
+            else:
+                if len(self.history)==0:
+                    pass 
+                elif hc>=len(self.history) and not self.query:
+                    self.history_cursor=len(self.history)
+                    return lineobj.ReadLineTextBuffer("",point=0)
+                elif self.history[max(min(hcstart,len(self.history)-1),0)].get_line_text().startswith(self.query) and self.query:
+                    return lineobj.ReadLineTextBuffer(self.history[max(min(hcstart,len(self.history)-1),0)],point=partial.point)
+                else:                
+                    return lineobj.ReadLineTextBuffer(partial,point=partial.point)
+                return lineobj.ReadLineTextBuffer(self.query,point=min(len(self.query),partial.point))
+        except IndexError:
+            log_sock("hcstart:%s %s"%(hcstart,len(self.history)),"history")
+            raise
+
+    def history_search_forward(self,partial): # ()
+        '''Search forward through the history for the string of characters
+        between the start of the current line and the point. This is a
+        non-incremental search. By default, this command is unbound.'''
+        q= self._search(1,partial)
+        return q
+
+    def history_search_backward(self,partial): # ()
+        '''Search backward through the history for the string of characters
+        between the start of the current line and the point. This is a
+        non-incremental search. By default, this command is unbound.'''
+        
+        q= self._search(-1,partial)
+        return q
+
+
+        
+if __name__=="__main__":
+    q=LineHistory()
+    RL=lineobj.ReadLineTextBuffer
+    q.add_history(RL("aaaa"))
+    q.add_history(RL("aaba"))
+    q.add_history(RL("aaca"))
+    q.add_history(RL("akca"))
+    q.add_history(RL("bbb"))
+    q.add_history(RL("ako"))
diff --git a/windows/fuzzbunch/pyreadline/lineeditor/lineobj.py b/windows/fuzzbunch/pyreadline/lineeditor/lineobj.py
new file mode 100644
index 0000000..c0a1d93
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/lineeditor/lineobj.py
@@ -0,0 +1,790 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2006  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+import re,operator
+
+import wordmatcher
+import pyreadline.clipboard as clipboard
+from pyreadline.logger import  log,log_sock
+class NotAWordError(IndexError):
+    pass
+
+
+def quote_char(c):
+    if ord(c)>0:
+        return c
+
+############## Line positioner ########################
+
+class LinePositioner(object):
+    def __call__(self,line):
+        NotImplementedError("Base class !!!")
+
+class NextChar(LinePositioner):
+    def __call__(self,line):
+        if line.point<len(line.line_buffer):
+            return line.point+1
+        else:
+            return line.point
+NextChar=NextChar()
+
+class PrevChar(LinePositioner):
+    def __call__(self,line):
+        if line.point>0:
+            return line.point-1
+        else:
+            return line.point
+PrevChar=PrevChar()
+
+class NextWordStart(LinePositioner):
+    def __call__(self,line):
+        return line.next_start_segment(line.line_buffer,line.is_word_token)[line.point]
+NextWordStart=NextWordStart()
+
+class NextWordEnd(LinePositioner):
+    def __call__(self,line):
+        return line.next_end_segment(line.line_buffer,line.is_word_token)[line.point]
+NextWordEnd=NextWordEnd()
+
+class PrevWordStart(LinePositioner):
+    def __call__(self,line):
+        return line.prev_start_segment(line.line_buffer,line.is_word_token)[line.point]
+PrevWordStart=PrevWordStart()
+
+
+class WordStart(LinePositioner):
+    def __call__(self,line):
+        if line.is_word_token(line.get_line_text()[Point(line):Point(line)+1]):
+            if Point(line)>0 and line.is_word_token(line.get_line_text()[Point(line)-1:Point(line)]):
+                return PrevWordStart(line)
+            else:
+                return line.point
+        else:   
+            raise NotAWordError("Point is not in a word")
+WordStart=WordStart()
+
+class WordEnd(LinePositioner):
+    def __call__(self,line):
+        if line.is_word_token(line.get_line_text()[Point(line):Point(line)+1]):
+            if line.is_word_token(line.get_line_text()[Point(line)+1:Point(line)+2]):
+                return NextWordEnd(line)
+            else:
+                return line.point
+        else:   
+            raise NotAWordError("Point is not in a word")
+WordEnd=WordEnd()
+
+class PrevWordEnd(LinePositioner):
+    def __call__(self,line):
+        return line.prev_end_segment(line.line_buffer,line.is_word_token)[line.point]
+PrevWordEnd=PrevWordEnd()
+
+class PrevSpace(LinePositioner):
+    def __call__(self,line):
+        point=line.point
+        if line[point-1:point].get_line_text()==" ":
+            while point>0 and line[point-1:point].get_line_text()==" ":
+                point-=1
+        while point>0 and line[point-1:point].get_line_text()!=" ":
+            point-=1
+        return point
+PrevSpace=PrevSpace()
+
+
+class StartOfLine(LinePositioner):
+    def __call__(self,line):
+        return 0
+StartOfLine=StartOfLine()
+
+class EndOfLine(LinePositioner):
+    def __call__(self,line):
+        return len(line.line_buffer)
+EndOfLine=EndOfLine()
+
+class Point(LinePositioner):
+    def __call__(self,line):
+        return line.point
+Point=Point()
+
+class Mark(LinePositioner):
+    def __call__(self,line):
+        return line.mark
+Mark=Mark()
+
+all_positioners=[(value.__class__.__name__,value) for key,value in globals().items() if isinstance(value,LinePositioner)]
+all_positioners.sort()
+
+############### LineSlice #################
+
+class LineSlice(object):
+    def __call__(self,line):
+        NotImplementedError("Base class !!!")
+
+
+class CurrentWord(LineSlice):
+    def __call__(self,line):
+        return slice(WordStart(line),WordEnd(line),None)
+CurrentWord=CurrentWord()
+
+class NextWord(LineSlice):
+    def __call__(self,line):
+        work=TextLine(line)
+        work.point=NextWordStart
+        start=work.point
+        stop=NextWordEnd(work)
+        return slice(start,stop)
+NextWord=NextWord()
+
+class PrevWord(LineSlice):
+    def __call__(self,line):
+        work=TextLine(line)
+        work.point=PrevWordEnd
+        stop=work.point
+        start=PrevWordStart(work)
+        return slice(start,stop)
+PrevWord=PrevWord()
+
+class PointSlice(LineSlice):
+    def __call__(self,line):
+        return slice(Point(line),Point(line)+1,None)
+PointSlice=PointSlice()
+
+
+###############  TextLine  ######################
+
+class TextLine(object):
+    def __init__(self,txtstr,point=None,mark=None):
+        self.line_buffer=[]
+        self._point=0
+        self.mark=-1
+        self.undo_stack=[]
+        self.overwrite=False
+        if isinstance(txtstr,TextLine): #copy 
+            self.line_buffer=txtstr.line_buffer[:]
+            if point is None:
+                self.point=txtstr.point
+            else:                
+                self.point=point
+            if mark is None:
+                self.mark=txtstr.mark
+            else:
+                self.mark=mark
+        else:            
+            self._insert_text(txtstr)
+            if point is None:
+                self.point=0
+            else:
+                self.point=point
+            if mark is None:
+                self.mark=-1
+            else:
+                self.mark=mark
+
+        self.is_word_token=wordmatcher.is_word_token
+        self.next_start_segment=wordmatcher.next_start_segment
+        self.next_end_segment=wordmatcher.next_end_segment
+        self.prev_start_segment=wordmatcher.prev_start_segment
+        self.prev_end_segment=wordmatcher.prev_end_segment
+        
+    def push_undo(self):
+        ltext = self.get_line_text()
+        if self.undo_stack and ltext == self.undo_stack[-1].get_line_text():
+            self.undo_stack[-1].point = self.point
+        else:
+            self.undo_stack.append(self.copy())
+
+    def pop_undo(self):
+        if len(self.undo_stack) >= 2:
+            self.undo_stack.pop()
+            self.set_top_undo()
+            self.undo_stack.pop()
+        else:
+            self.reset_line()
+            self.undo_stack = []
+
+    def set_top_undo(self):
+        if self.undo_stack:
+            undo=self.undo_stack[-1]
+            self.line_buffer=undo.line_buffer
+            self.point=undo.point
+            self.mark=undo.mark
+        else:
+            pass
+        
+    def __repr__(self):
+        return 'TextLine("%s",point=%s,mark=%s)'%(self.line_buffer,self.point,self.mark)
+
+    def copy(self):
+        return self.__class__(self)
+
+    def set_point(self,value):
+        if isinstance(value,LinePositioner):
+            value=value(self)
+        assert  (value <= len(self.line_buffer))           
+        if value>len(self.line_buffer):
+            value=len(self.line_buffer)
+        self._point=value
+    def get_point(self):
+        return self._point
+    point=property(get_point,set_point)
+
+
+    def visible_line_width(self,position=Point):
+        """Return the visible width of the text in line buffer up to position."""
+        return len(self[:position].quoted_text())+self[:position].line_buffer.count("\t")*7
+
+    def quoted_text(self):
+        quoted = [ quote_char(c) for c in self.line_buffer ]
+        self.line_char_width = [ len(c) for c in quoted ]
+        return ''.join(quoted)
+
+    def get_line_text(self):
+        return ''.join(self.line_buffer)
+
+    def set_line(self, text, cursor=None):
+        self.line_buffer = [ c for c in str(text) ]
+        if cursor is None:
+            self.point = len(self.line_buffer)
+        else:
+            self.point = cursor
+
+    def reset_line(self):
+        self.line_buffer = []
+        self.point = 0
+
+    def end_of_line(self):
+        self.point = len(self.line_buffer)
+
+    def _insert_text(self, text):
+        if self.overwrite:
+            for c in text:
+                #if self.point:
+                self.line_buffer[self.point]= c
+                self.point += 1
+        else:            
+            for c in text:
+                self.line_buffer.insert(self.point, c)
+                self.point += 1
+    
+    def __getitem__(self,key):
+        #Check if key is LineSlice, convert to regular slice
+        #and continue processing
+        if isinstance(key,LineSlice): 
+            key=key(self)
+        if isinstance(key,slice):
+            if key.step is None:
+                pass
+            else:
+                raise Error
+            if key.start is None:
+                start=StartOfLine(self)
+            elif isinstance(key.start,LinePositioner):
+                start=key.start(self)
+            else:
+                start=key.start
+            if key.stop is None:                   
+                stop=EndOfLine(self)
+            elif isinstance(key.stop,LinePositioner):
+                stop=key.stop(self)
+            else:
+                stop=key.stop
+            return self.__class__(self.line_buffer[start:stop],point=0)
+        elif isinstance(key,LinePositioner):
+            return self.line_buffer[key(self)]
+        elif isinstance(key,tuple):
+            raise IndexError("Cannot use step in line buffer indexing") #Multiple slice not allowed
+        else:
+            # return TextLine(self.line_buffer[key])
+            return self.line_buffer[key]
+
+    def __delitem__(self,key):
+        point=self.point
+        if isinstance(key,LineSlice):
+            key=key(self)
+        if isinstance(key,slice):
+            start=key.start
+            stop=key.stop
+            if isinstance(start,LinePositioner):
+                start=start(self)
+            elif start is None:
+                start=0
+            if isinstance(stop,LinePositioner):
+                stop=stop(self)
+            elif stop is None:
+                stop=EndOfLine(self)
+        elif isinstance(key,LinePositioner):
+            start=key(self)
+            stop=start+1
+        else:
+            start=key
+            stop=key+1
+        prev=self.line_buffer[:start]
+        rest=self.line_buffer[stop:]
+        self.line_buffer=prev+rest
+        if point>stop:
+            self.point=point-(stop-start)
+        elif point>=start and point <=stop:
+            self.point=start
+
+
+    def __setitem__(self,key,value):
+        if isinstance(key,LineSlice):
+            key=key(self)
+        if isinstance(key,slice):
+            start=key.start
+            stop=key.stop
+        elif isinstance(key,LinePositioner):
+            start=key(self)
+            stop=start+1
+        else:
+            start=key
+            stop=key+1
+        prev=self.line_buffer[:start]
+        value=self.__class__(value).line_buffer
+        rest=self.line_buffer[stop:]
+        out=prev+value+rest
+        if len(out)>=len(self):
+            self.point=len(self)
+        self.line_buffer=out
+
+    def __len__(self):
+        return len(self.line_buffer)
+
+    def upper(self):
+        self.line_buffer=[x.upper() for x in self.line_buffer]
+        return self
+
+    def lower(self):
+        self.line_buffer=[x.lower() for x in self.line_buffer]
+        return self
+        
+    def capitalize(self):
+        self.set_line(self.get_line_text().capitalize(),self.point)
+        return self
+        
+    def startswith(self,txt):
+        return self.get_line_text().startswith(txt)
+
+    def endswith(self,txt):
+        return self.get_line_text().endswith(txt)
+
+    def __contains__(self,txt):
+        return txt in self.get_line_text()
+
+
+lines=[TextLine("abc"),
+       TextLine("abc def"),
+       TextLine("abc def  ghi"),
+       TextLine("  abc  def  "),
+      ]
+l=lines[2]
+l.point=5
+
+
+
+class ReadLineTextBuffer(TextLine):
+    def __init__(self,txtstr,point=None,mark=None):
+        super(ReadLineTextBuffer,self).__init__(txtstr,point,mark)
+        self.enable_win32_clipboard=True
+        self.selection_mark=-1
+        self.enable_selection=True
+        self.kill_ring=[]
+    def __repr__(self):
+        return 'ReadLineTextBuffer("%s",point=%s,mark=%s,selection_mark=%s)'%(self.line_buffer,self.point,self.mark,self.selection_mark)
+
+
+    def insert_text(self,char):
+        self.delete_selection()
+        self.selection_mark=-1
+        self._insert_text(char)
+    
+    def to_clipboard(self):
+        if self.enable_win32_clipboard:
+                clipboard.set_clipboard_text(self.get_line_text())
+    
+######### Movement
+
+    def beginning_of_line(self):
+        self.selection_mark=-1
+        self.point=StartOfLine
+        
+    def end_of_line(self):
+        self.selection_mark=-1
+        self.point=EndOfLine
+
+    def forward_char(self,argument=1):
+        if argument<0:
+            self.backward_char(-argument)
+        self.selection_mark=-1
+        for x in range(argument):
+            self.point=NextChar
+        
+    def backward_char(self,argument=1):
+        if argument<0:
+            self.forward_char(-argument)
+        self.selection_mark=-1
+        for x in range(argument):
+            self.point=PrevChar
+        
+    def forward_word(self,argument=1):
+        if argument<0:
+            self.backward_word(-argument)
+        self.selection_mark=-1
+        for x in range(argument):
+            self.point=NextWordStart
+       
+    def backward_word(self,argument=1):
+        if argument<0:
+            self.forward_word(-argument)
+        self.selection_mark=-1
+        for x in range(argument):
+            self.point=PrevWordStart
+
+    def forward_word_end(self,argument=1):
+        if argument<0:
+            self.backward_word_end(-argument)
+        self.selection_mark=-1
+        for x in range(argument):
+            self.point=NextWordEnd
+
+    def backward_word_end(self,argument=1):
+        if argument<0:
+            self.forward_word_end(-argument)
+        self.selection_mark=-1
+        for x in range(argument):
+            self.point=NextWordEnd
+
+######### Movement select
+    def beginning_of_line_extend_selection(self):
+        if self.enable_selection and self.selection_mark<0:
+            self.selection_mark=self.point
+        self.point=StartOfLine
+        
+    def end_of_line_extend_selection(self):
+        if self.enable_selection and self.selection_mark<0:
+            self.selection_mark=self.point
+        self.point=EndOfLine
+
+    def forward_char_extend_selection(self,argument=1):
+        if argument<0:
+            self.backward_char_extend_selection(-argument)
+        if self.enable_selection and self.selection_mark<0:
+            self.selection_mark=self.point
+        for x in range(argument):
+            self.point=NextChar
+        
+    def backward_char_extend_selection(self,argument=1):
+        if argument<0:
+            self.forward_char_extend_selection(-argument)
+        if self.enable_selection and self.selection_mark<0:
+            self.selection_mark=self.point
+        for x in range(argument):
+            self.point=PrevChar
+        
+    def forward_word_extend_selection(self,argument=1):
+        if argument<0:
+            self.backward_word_extend_selection(-argument)
+        if self.enable_selection and self.selection_mark<0:
+            self.selection_mark=self.point
+        for x in range(argument):
+            self.point=NextWordStart
+       
+    def backward_word_extend_selection(self,argument=1):
+        if argument<0:
+            self.forward_word_extend_selection(-argument)
+        if self.enable_selection and self.selection_mark<0:
+            self.selection_mark=self.point
+        for x in range(argument):
+            self.point=PrevWordStart
+
+       
+    def forward_word_end_extend_selection(self,argument=1):
+        if argument<0:
+            self.backward_word_end_extend_selection(-argument)
+        if self.enable_selection and self.selection_mark<0:
+            self.selection_mark=self.point
+        for x in range(argument):
+            self.point=NextWordEnd
+
+    def backward_word_end_extend_selection(self,argument=1):
+        if argument<0:
+            self.forward_word_end_extend_selection(-argument)
+        if self.enable_selection and self.selection_mark<0:
+            self.selection_mark=self.point
+        for x in range(argument):
+            self.point=PrevWordEnd
+
+
+######### delete       
+
+    def delete_selection(self):
+        if self.enable_selection and self.selection_mark>=0:
+            if self.selection_mark<self.point:
+                del self[self.selection_mark:self.point]
+                self.selection_mark=-1
+            else:                
+                del self[self.point:self.selection_mark]
+                self.selection_mark=-1
+            return True
+        else:
+            self.selection_mark=-1
+            return False
+
+    def delete_char(self,argument=1):
+        if argument<0:
+            self.backward_delete_char(-argument)
+        if self.delete_selection():
+            argument-=1
+        for x in range(argument):
+            del self[Point]
+        
+    def backward_delete_char(self,argument=1):
+        if argument<0:
+            self.delete_char(-argument)
+        if self.delete_selection():
+            argument-=1
+        for x in range(argument):
+            if self.point>0:
+                self.backward_char()
+                self.delete_char()
+
+    def forward_delete_word(self,argument=1):
+        if argument<0:
+            self.backward_delete_word(-argument)
+        if self.delete_selection():
+            argument-=1
+        for x in range(argument):
+            del self[Point:NextWordStart]
+
+    def backward_delete_word(self,argument=1):
+        if argument<0:
+            self.forward_delete_word(-argument)
+        if self.delete_selection():
+            argument-=1
+        for x in range(argument):
+            del self[PrevWordStart:Point]
+
+    def delete_current_word(self):
+        if not self.delete_selection():
+            del self[CurrentWord]
+        self.selection_mark=-1
+        
+    def delete_horizontal_space(self):
+        if self[Point] in " \t":
+            del self[PrevWordEnd:NextWordStart]
+        self.selection_mark=-1
+######### Case
+
+    def upcase_word(self):
+        p=self.point
+        try:
+            self[CurrentWord]=self[CurrentWord].upper()
+            self.point=p
+        except NotAWordError:
+            pass
+        
+    def downcase_word(self):
+        p=self.point
+        try:
+            self[CurrentWord]=self[CurrentWord].lower()
+            self.point=p
+        except NotAWordError:
+            pass
+        
+    def capitalize_word(self):
+        p=self.point
+        try:
+            self[CurrentWord]=self[CurrentWord].capitalize()
+            self.point=p
+        except NotAWordError:
+            pass
+########### Transpose
+    def transpose_chars(self):
+        p2=Point(self)
+        if p2==0:
+            return
+        elif p2==len(self):
+            p2=p2-1
+        p1=p2-1
+        self[p2],self[p1]=self[p1],self[p2]
+        self.point=p2+1
+
+    def transpose_words(self):
+        word1=TextLine(self)
+        word2=TextLine(self)
+        if self.point==len(self):
+            word2.point=PrevWordStart
+            word1.point=PrevWordStart(word2)
+        else:
+            word1.point=PrevWordStart
+            word2.point=NextWordStart
+        stop1=NextWordEnd(word1)
+        stop2=NextWordEnd(word2)
+        start1=word1.point
+        start2=word2.point
+        self[start2:stop2]=word1[Point:NextWordEnd]
+        self[start1:stop1]=word2[Point:NextWordEnd]
+        self.point=stop2
+        
+
+############ Kill
+
+    def kill_line(self):
+        #self[self.point:].to_clipboard()
+        self.add_to_kill_ring(self[self.point:])
+        del self.line_buffer[self.point:]
+    
+    def kill_whole_line(self):
+        #self[:].to_clipboard()
+        self.add_to_kill_ring(self[:])
+        del self[:]
+    
+    def backward_kill_line(self):
+        #self[StartOfLine:Point].to_clipboard()
+        del self[StartOfLine:Point]
+        
+    def unix_line_discard(self):
+        del self[StartOfLine:Point]
+        pass
+
+    def kill_word(self):
+        """Kills to next word ending"""
+        #self[Point:NextWordEnd].to_clipboard()
+        del self[Point:NextWordEnd]
+
+    def backward_kill_word(self):
+        """Kills to next word ending"""
+        #self[PrevWordStart:Point].to_clipboard()
+        if not self.delete_selection():
+            del self[PrevWordStart:Point]
+        self.selection_mark=-1
+
+    def forward_kill_word(self):
+        """Kills to next word ending"""
+        #self[Point:NextWordEnd].to_clipboard()
+        if not self.delete_selection():
+            del self[Point:NextWordEnd]
+        self.selection_mark=-1
+
+    def unix_word_rubout(self):
+        if not self.delete_selection():
+            del self[PrevSpace:Point]
+        self.selection_mark=-1
+
+    def kill_region(self):
+        pass
+
+    def copy_region_as_kill(self):
+        pass
+
+    def copy_backward_word(self):
+        pass
+
+    def copy_forward_word(self):
+        pass
+        
+
+    def yank(self):
+        self.paste_from_kill_ring()
+
+    def yank_pop(self):
+        pass
+
+##############  Mark 
+
+    def set_mark(self):
+        self.mark=self.point
+        
+    def exchange_point_and_mark(self):
+        pass
+
+
+    def copy_region_to_clipboard(self): # ()
+        '''Copy the text in the region to the windows clipboard.'''
+        if self.enable_win32_clipboard:
+                mark=min(self.mark,len(self.line_buffer))
+                cursor=min(self.point,len(self.line_buffer))
+                if self.mark==-1:
+                        return
+                begin=min(cursor,mark)
+                end=max(cursor,mark)
+                toclipboard="".join(self.line_buffer[begin:end])
+                clipboard.SetClipboardText(str(toclipboard))
+
+    def copy_selection_to_clipboard(self): # ()
+        '''Copy the text in the region to the windows clipboard.'''
+        if self.enable_win32_clipboard and self.enable_selection and self.selection_mark>=0:
+                selection_mark=min(self.selection_mark,len(self.line_buffer))
+                cursor=min(self.point,len(self.line_buffer))
+                if self.selection_mark==-1:
+                        return
+                begin=min(cursor,selection_mark)
+                end=max(cursor,selection_mark)
+                toclipboard="".join(self.line_buffer[begin:end])
+                clipboard.SetClipboardText(str(toclipboard))
+
+
+    def cut_selection_to_clipboard(self): # ()
+        self.copy_selection_to_clipboard()
+        self.delete_selection()
+##############  Paste
+
+
+############## Kill ring
+    def add_to_kill_ring(self,txt):
+        self.kill_ring=[txt]
+        
+
+    def paste_from_kill_ring(self):
+        if self.kill_ring:
+            self.insert_text(self.kill_ring[0])
+
+
+##################################################################
+q=ReadLineTextBuffer("asff asFArw  ewrWErhg",point=8)
+q=TextLine("asff asFArw  ewrWErhg",point=8)
+
+def show_pos(buff,pos,chr="."):
+    l=len(buff.line_buffer)
+    def choice(bool):
+        if bool:
+            return chr
+        else:
+            return " "
+    return "".join([choice(pos==idx) for idx in range(l+1)])
+
+
+def test_positioner(buff,points,positioner):
+    print (" %s "%positioner.__class__.__name__).center(40,"-")
+    buffstr=buff.line_buffer
+    
+    print '"%s"'%(buffstr)
+    for point in points:
+        b=TextLine(buff,point=point)
+        out=[" "]*(len(buffstr)+1)
+        pos=positioner(b)
+        if pos==point:
+            out[pos]="&"
+        else:
+            out[point]="."
+            out[pos]="^"
+        print '"%s"'%("".join(out))
+    
+if __name__=="__main__":
+    import startup
+
+    print '%-15s "%s"'%("Position",q.get_line_text())
+    print '%-15s "%s"'%("Point",show_pos(q,q.point))
+
+
+    for name,positioner in all_positioners:
+        pos=positioner(q)
+        []
+        print '%-15s "%s"'%(name,show_pos(q,pos,"^"))
+
+    l=ReadLineTextBuffer("kjjk asads   asad")
+    l.point=EndOfLine
\ No newline at end of file
diff --git a/windows/fuzzbunch/pyreadline/lineeditor/wordmatcher.py b/windows/fuzzbunch/pyreadline/lineeditor/wordmatcher.py
new file mode 100644
index 0000000..fa41a46
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/lineeditor/wordmatcher.py
@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2006  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+import re,operator
+
+
+def str_find_all(str,ch):
+    result=[]
+    index=0
+    while index>=0:
+        index=str.find(ch,index)
+        if index>=0:
+            result.append(index)
+            index+=1
+    return result
+        
+
+word_pattern=re.compile("(x*)")
+
+def markwords(str,iswordfun):
+    markers={True:"x",False:"o"}
+    return "".join([markers[iswordfun(ch)] for ch in str])
+
+def split_words(str,iswordfun):
+    return [x for x in word_pattern.split(markwords(str,iswordfun)) if x !=""]
+
+def mark_start_segment(str,is_segment):
+    def mark_start(s):
+        if s[0:1]=="x":
+            return "s"+s[1:]
+        else:
+            return s
+    return "".join(map(mark_start,split_words(str,is_segment)))
+
+def mark_end_segment(str,is_segment):
+    def mark_start(s):
+        if s[0:1]=="x":
+            return s[:-1]+"s"
+        else:
+            return s
+    return "".join(map(mark_start,split_words(str,is_segment)))
+    
+def mark_start_segment_index(str,is_segment):
+    return str_find_all(mark_start_segment(str,is_segment),"s")
+
+def mark_end_segment_index(str,is_segment):
+    return [x+1 for x in str_find_all(mark_end_segment(str,is_segment),"s")]
+
+
+################  Following are used in lineobj  ###########################
+
+def is_word_token(str):
+    return not is_non_word_token(str)
+    
+def is_non_word_token(str):
+    if len(str)!=1 or str in " \t\n":
+        return True
+    else:
+        return False
+
+def next_start_segment(str,is_segment):
+    str="".join(str)
+    result=[]
+    for start in mark_start_segment_index(str,is_segment):
+        result[len(result):start]=[start for x in range(start-len(result))]
+    result[len(result):len(str)]=[len(str) for x in range(len(str)-len(result)+1)]            
+    return result
+    
+def next_end_segment(str,is_segment):
+    str="".join(str)
+    result=[]
+    for start in mark_end_segment_index(str,is_segment):
+        result[len(result):start]=[start for x in range(start-len(result))]
+    result[len(result):len(str)]=[len(str) for x in range(len(str)-len(result)+1)]            
+    return result    
+
+
+def prev_start_segment(str,is_segment):
+    str="".join(str)
+    result=[]
+    prev=0
+    for start in mark_start_segment_index(str,is_segment):
+        result[len(result):start+1]=[prev for x in range(start-len(result)+1)]
+        prev=start
+    result[len(result):len(str)]=[prev for x in range(len(str)-len(result)+1)]            
+    return result
+
+def prev_end_segment(str,is_segment):
+    str="".join(str)
+    result=[]
+    prev=0
+    for start in mark_end_segment_index(str,is_segment):
+        result[len(result):start+1]=[prev for x in range(start-len(result)+1)]
+        prev=start
+    result[len(result):len(str)]=[len(str) for x in range(len(str)-len(result)+1)]            
+    return result    
+
+
diff --git a/windows/fuzzbunch/pyreadline/logger.py b/windows/fuzzbunch/pyreadline/logger.py
new file mode 100644
index 0000000..b3eef06
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/logger.py
@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2006  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+import socket
+_logfile=False
+
+def start_log(on,filename):
+    global _logfile
+    if on=="on":
+        _logfile=open(filename,"w")
+    else:
+        _logfile=False
+        
+def log(s):
+    if _logfile:
+        print >>_logfile, s
+        _logfile.flush()
+
+
+host="localhost"
+port=8081
+logsocket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
+
+show_event=["keypress","bound_function","bind_key","console"]
+show_event=["bound_function"]
+
+sock_silent=True
+
+def log_sock(s,event_type=None):
+    if sock_silent:
+        pass
+    else:
+        if event_type is None:
+            logsocket.sendto(s,(host,port))
+        elif event_type in show_event:
+            logsocket.sendto(s,(host,port))
+        else:
+            pass
+
+    
diff --git a/windows/fuzzbunch/pyreadline/logserver.py b/windows/fuzzbunch/pyreadline/logserver.py
new file mode 100644
index 0000000..65f260d
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/logserver.py
@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2006  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+import socket
+
+
+try:
+    import msvcrt
+except ImportError:
+    msvcrt=None
+    print "problem"
+        
+
+
+port =8081
+
+s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
+
+s.bind(("",port))
+s.settimeout(0.05)
+
+print "Starting logserver on port:",port
+print "Press q to quit logserver",port
+singleline=False
+
+
+def check_key():
+    if msvcrt is None:
+        return False
+    else:
+        if msvcrt.kbhit()!=0:
+            q=msvcrt.getch()
+            
+            return q in "q" 
+        else:
+            return False
+
+
+while 1:
+    try:
+        data,addr=s.recvfrom(1024)
+    except socket.timeout:
+        if check_key():
+            print "Quitting logserver"
+            break
+        else:
+            continue
+    if data.startswith("@@"):
+        continue
+    if singleline:
+        print "\r"," "*78,"\r",data,#,addr
+    else:
+        print data
+    
+    
+
diff --git a/windows/fuzzbunch/pyreadline/modes/__init__.py b/windows/fuzzbunch/pyreadline/modes/__init__.py
new file mode 100644
index 0000000..3309d95
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/modes/__init__.py
@@ -0,0 +1,5 @@
+__all__=["fuzzbunch", "emacs","notemacs","vi"]
+import fuzzbunch,emacs,notemacs,vi
+editingmodes=[fuzzbunch.FuzzbunchMode,emacs.EmacsMode,notemacs.NotEmacsMode,vi.ViMode]
+
+#add check to ensure all modes have unique mode names
diff --git a/windows/fuzzbunch/pyreadline/modes/basemode.py b/windows/fuzzbunch/pyreadline/modes/basemode.py
new file mode 100644
index 0000000..f12b630
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/modes/basemode.py
@@ -0,0 +1,457 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+import os,re,math,glob,sys
+import pyreadline.logger as logger
+from   pyreadline.logger import log,log_sock
+from   pyreadline.keysyms.common import make_KeyPress_from_keydescr
+import pyreadline.lineeditor.lineobj as lineobj
+import pyreadline.lineeditor.history as history
+import pyreadline.clipboard as clipboard
+from pyreadline.error import ReadlineError,GetSetError
+in_ironpython="IronPython" in sys.version
+
+class BaseMode(object):
+    mode="base"
+    def __init__(self,rlobj):
+        self.rlobj=rlobj
+        self.exit_dispatch = {}
+        self.key_dispatch = {}
+        self.argument=1
+        self.prevargument=None
+        
+    def __repr__(self):
+        return "<BaseMode>"
+
+    def _gs(x):
+        def g(self):
+            return getattr(self.rlobj,x)
+        def s(self,q):
+            setattr(self.rlobj,x,q)
+        return g,s
+        
+    def _g(x):
+        def g(self):
+            return getattr(self.rlobj,x)
+        return g
+
+    def _argreset(self):
+        val=self.argument
+        self.argument=1
+        return val
+    argument_reset=property(_argreset)
+        
+    ctrl_c_tap_time_interval=property(*_gs("ctrl_c_tap_time_interval"))
+    allow_ctrl_c=property(*_gs("allow_ctrl_c"))
+    l_buffer=property(*_gs("l_buffer"))
+    next_meta=property(*_gs("next_meta"))
+    first_prompt=property(*_gs("first_prompt"))
+    prompt=property(*_gs("prompt"))
+    paste_line_buffer=property(*_gs("paste_line_buffer"))
+    completer_delims=property(*_gs("completer_delims"))
+    show_all_if_ambiguous=property(*_gs("show_all_if_ambiguous"))
+    mark_directories=property(*_gs("mark_directories"))
+    completer=property(*_gs("completer"))
+    begidx=property(*_gs("begidx"))
+    startup_hook=property(*_gs("startup_hook"))
+    pre_input_hook=property(*_gs("pre_input_hook"))
+    endidx=property(*_gs("endidx"))
+    
+    console=property(_g("console"))
+    insert_text=property(_g("insert_text"))
+    _print_prompt=property(_g("_print_prompt"))
+    _update_line=property(_g("_update_line"))
+    add_history=property(_g("add_history"))
+    _bell=property(_g("_bell"))
+    _clear_after=property(_g("_clear_after"))
+    _set_cursor=property(_g("_set_cursor"))
+    _update_prompt_pos=property(_g("_update_prompt_pos"))
+    _update_line=property(_g("_update_line"))
+    enable_win32_clipboard=property(_g("enable_win32_clipboard"))
+    enable_ipython_paste_list_of_lists=property(_g("enable_ipython_paste_list_of_lists"))
+    enable_ipython_paste_for_paths=property(_g("enable_ipython_paste_for_paths"))
+    _bell=property(_g("_bell"))
+    _history=property(_g("_history"))
+    prompt_end_pos=property(_g("prompt_end_pos"))
+    prompt_begin_pos=property(_g("prompt_begin_pos"))
+
+    rl_settings_to_string=property(_g("rl_settings_to_string"))
+
+    def _readline_from_keyboard(self):
+        raise NotImplementedError
+
+    def readline(self, prompt=''):
+        raise NotImplementedError
+
+    #Create key bindings:
+
+    def _bind_key(self, key, func):
+        '''setup the mapping from key to call the function.'''
+        if type(func) != type(self._bind_key):
+            print "Trying to bind non method to keystroke:%s,%s"%(key,func)
+            raise PyreadlineError("Trying to bind non method to keystroke:%s,%s,%s,%s"%(key,func,type(func),type(self._bind_key)))
+        keyinfo = make_KeyPress_from_keydescr(key.lower()).tuple()
+        log(">>>%s -> %s<<<"%(keyinfo,func.__name__))
+        self.key_dispatch[keyinfo] = func
+
+    def _bind_exit_key(self, key):
+        '''setup the mapping from key to call the function.'''
+        keyinfo = make_KeyPress_from_keydescr(key.lower()).tuple()
+        self.exit_dispatch[keyinfo] = None
+
+    def init_editing_mode(self, e): # (C-e)
+        '''When in vi command mode, this causes a switch to emacs editing
+        mode.'''
+
+        raise NotImplementedError
+#completion commands    
+    
+    def _get_completions(self):
+       
+        '''Return a list of possible completions for the string ending at the point.
+
+        Also set begidx and endidx in the process.'''
+        completions = []
+        self.begidx = self.l_buffer.point
+        self.endidx = self.l_buffer.point
+        buf=self.l_buffer.line_buffer
+        if self.completer:
+            # get the string to complete
+            while self.begidx > 0:
+                self.begidx -= 1
+                if buf[self.begidx] in self.completer_delims:
+                    self.begidx += 1
+                    break
+            text = ''.join(buf[self.begidx:self.endidx])
+            log('complete text="%s"' % text)
+            i = 0
+            while 1:
+                try:
+                    r = self.completer(text, i)
+                except:
+                    break
+                i += 1
+                if r and r not in completions:
+                    completions.append(r)
+                else:
+                    break
+            log('text completions=%s' % completions)
+        if not completions:
+            # get the filename to complete
+            while self.begidx > 0:
+                self.begidx -= 1
+                if buf[self.begidx] in ' \t\n':
+                    self.begidx += 1
+                    break
+            text = ''.join(buf[self.begidx:self.endidx])
+            log('file complete text="%s"' % text)
+            completions = glob.glob(os.path.expanduser(text) + '*')
+            if self.mark_directories == 'on':
+                mc = []
+                for f in completions:
+                    if os.path.isdir(f):
+                        mc.append(f + os.sep)
+                    else:
+                        mc.append(f)
+                completions = mc
+            log('fnames=%s' % completions)
+        return completions
+
+       
+    def _display_completions(self, completions):
+        if not completions:
+            return
+        self.console.write('\n')
+        wmax = max(map(len, completions))
+        w, h = self.console.size()
+        cols = max(1, int((w-1) / (wmax+1)))
+        rows = int(math.ceil(float(len(completions)) / cols))
+        for row in range(rows):
+            s = ''
+            for col in range(cols):
+                i = col*rows + row
+                if i < len(completions):
+                    self.console.write(completions[i].ljust(wmax+1))
+            self.console.write('\n')
+        if in_ironpython:
+            self.prompt=sys.ps1
+        self._print_prompt()
+
+    def complete(self, e): # (TAB)
+        '''Attempt to perform completion on the text before point. The
+        actual completion performed is application-specific. The default is
+        filename completion.'''
+        completions = self._get_completions()
+        if completions:
+            cprefix = commonprefix(completions)
+            rep = [ c for c in cprefix ]
+            point=self.l_buffer.point
+            self.l_buffer[self.begidx:self.endidx] = rep
+            self.l_buffer.point = point + len(rep) - (self.endidx - self.begidx)
+            if len(completions) > 1:
+                if self.show_all_if_ambiguous == 'on':
+                    self._display_completions(completions)
+                else:
+                    self._bell()
+        else:
+            self._bell()
+
+    def possible_completions(self, e): # (M-?)
+        '''List the possible completions of the text before point. '''
+        completions = self._get_completions()
+        self._display_completions(completions)
+
+    def insert_completions(self, e): # (M-*)
+        '''Insert all completions of the text before point that would have
+        been generated by possible-completions.'''
+        completions = self._get_completions()
+        b = self.begidx
+        e = self.endidx
+        for comp in completions:
+            rep = [ c for c in comp ]
+            rep.append(' ')
+            self.l_buffer[b:e] = rep
+            b += len(rep)
+            e = b
+        self.line_cursor = b    
+
+    def menu_complete(self, e): # ()
+        '''Similar to complete, but replaces the word to be completed with a
+        single match from the list of possible completions. Repeated
+        execution of menu-complete steps through the list of possible
+        completions, inserting each match in turn. At the end of the list of
+        completions, the bell is rung (subject to the setting of bell-style)
+        and the original text is restored. An argument of n moves n
+        positions forward in the list of matches; a negative argument may be
+        used to move backward through the list. This command is intended to
+        be bound to TAB, but is unbound by default.'''
+        pass
+
+    ### Methods below here are bindable emacs functions
+
+    def beginning_of_line(self, e): # (C-a)
+        '''Move to the start of the current line. '''
+        self.l_buffer.beginning_of_line()
+
+    def end_of_line(self, e): # (C-e)
+        '''Move to the end of the line. '''
+        self.l_buffer.end_of_line()
+
+    def forward_char(self, e): # (C-f)
+        '''Move forward a character. '''
+        self.l_buffer.forward_char(self.argument_reset)
+
+    def backward_char(self, e): # (C-b)
+        '''Move back a character. '''
+        self.l_buffer.backward_char(self.argument_reset)
+
+    def forward_word(self, e): # (M-f)
+        '''Move forward to the end of the next word. Words are composed of
+        letters and digits.'''
+        self.l_buffer.forward_word(self.argument_reset)
+
+    def backward_word(self, e): # (M-b)
+        '''Move back to the start of the current or previous word. Words are
+        composed of letters and digits.'''
+        self.l_buffer.backward_word(self.argument_reset)
+
+    def forward_word_end(self, e): # ()
+        '''Move forward to the end of the next word. Words are composed of
+        letters and digits.'''
+        self.l_buffer.forward_word_end(self.argument_reset)
+
+    def backward_word_end(self, e): # ()
+        '''Move forward to the end of the next word. Words are composed of
+        letters and digits.'''
+        self.l_buffer.backward_word_end(self.argument_reset)
+
+### Movement with extend selection
+    def beginning_of_line_extend_selection(self, e): # 
+        '''Move to the start of the current line. '''
+        self.l_buffer.beginning_of_line_extend_selection()
+
+    def end_of_line_extend_selection(self, e): # 
+        '''Move to the end of the line. '''
+        self.l_buffer.end_of_line_extend_selection()
+
+    def forward_char_extend_selection(self, e): # 
+        '''Move forward a character. '''
+        self.l_buffer.forward_char_extend_selection(self.argument_reset)
+
+    def backward_char_extend_selection(self, e): #
+        '''Move back a character. '''
+        self.l_buffer.backward_char_extend_selection(self.argument_reset)
+
+    def forward_word_extend_selection(self, e): # 
+        '''Move forward to the end of the next word. Words are composed of
+        letters and digits.'''
+        self.l_buffer.forward_word_extend_selection(self.argument_reset)
+
+    def backward_word_extend_selection(self, e): # 
+        '''Move back to the start of the current or previous word. Words are
+        composed of letters and digits.'''
+        self.l_buffer.backward_word_extend_selection(self.argument_reset)
+
+    def forward_word_end_extend_selection(self, e): # 
+        '''Move forward to the end of the next word. Words are composed of
+        letters and digits.'''
+        self.l_buffer.forward_word_end_extend_selection(self.argument_reset)
+
+    def backward_word_end_extend_selection(self, e): # 
+        '''Move forward to the end of the next word. Words are composed of
+        letters and digits.'''
+        self.l_buffer.forward_word_end_extend_selection(self.argument_reset)
+
+
+######## Change case
+
+    def upcase_word(self, e): # (M-u)
+        '''Uppercase the current (or following) word. With a negative
+        argument, uppercase the previous word, but do not move the cursor.'''
+        self.l_buffer.upcase_word()
+
+    def downcase_word(self, e): # (M-l)
+        '''Lowercase the current (or following) word. With a negative
+        argument, lowercase the previous word, but do not move the cursor.'''
+        self.l_buffer.downcase_word()
+
+    def capitalize_word(self, e): # (M-c)
+        '''Capitalize the current (or following) word. With a negative
+        argument, capitalize the previous word, but do not move the cursor.'''
+        self.l_buffer.capitalize_word()
+
+
+########
+    def clear_screen(self, e): # (C-l)
+        '''Clear the screen and redraw the current line, leaving the current
+        line at the top of the screen.'''
+        self.console.page()
+
+    def redraw_current_line(self, e): # ()
+        '''Refresh the current line. By default, this is unbound.'''
+        pass
+
+    def accept_line(self, e): # (Newline or Return)
+        '''Accept the line regardless of where the cursor is. If this line
+        is non-empty, it may be added to the history list for future recall
+        with add_history(). If this line is a modified history line, the
+        history line is restored to its original state.'''
+        return True
+
+
+    def delete_char(self, e): # (C-d)
+        '''Delete the character at point. If point is at the beginning of
+        the line, there are no characters in the line, and the last
+        character typed was not bound to delete-char, then return EOF.'''
+        self.l_buffer.delete_char(self.argument_reset)
+
+    def backward_delete_char(self, e): # (Rubout)
+        '''Delete the character behind the cursor. A numeric argument means
+        to kill the characters instead of deleting them.'''
+        self.l_buffer.backward_delete_char(self.argument_reset)
+
+    def backward_delete_word(self, e): # (Control-Rubout)
+        '''Delete the character behind the cursor. A numeric argument means
+        to kill the characters instead of deleting them.'''
+        self.l_buffer.backward_delete_word(self.argument_reset)
+
+    def forward_delete_word(self, e): # (Control-Delete)
+        '''Delete the character behind the cursor. A numeric argument means
+        to kill the characters instead of deleting them.'''
+        self.l_buffer.forward_delete_word(self.argument_reset)
+
+    def delete_horizontal_space(self, e): # ()
+        '''Delete all spaces and tabs around point. By default, this is unbound. '''
+        self.l_buffer.delete_horizontal_space()
+
+    def self_insert(self, e): # (a, b, A, 1, !, ...)
+        '''Insert yourself. '''
+        
+        if e.char and ord(e.char)!=0: #don't insert null character in buffer, can happen with dead keys.
+            self.insert_text(e.char)
+
+
+#   Paste from clipboard
+
+    def paste(self,e):
+        '''Paste windows clipboard.
+        Assume single line strip other lines and end of line markers and trailing spaces''' #(Control-v)
+        if self.enable_win32_clipboard:
+                txt=clipboard.get_clipboard_text_and_convert(False)
+                txt=txt.split("\n")[0].strip("\r").strip("\n")
+                log("paste: >%s<"%map(ord,txt))
+                self.insert_text(txt)
+
+    def paste_mulitline_code(self,e):
+        '''Paste windows clipboard as multiline code.
+        Removes any empty lines in the code'''
+        reg=re.compile("\r?\n")
+        if self.enable_win32_clipboard:
+                txt=clipboard.get_clipboard_text_and_convert(False)
+                t=reg.split(txt)
+                t=[row for row in t if row.strip()!=""] #remove empty lines
+                if t!=[""]:
+                    self.insert_text(t[0])
+                    self.add_history(self.l_buffer.copy())
+                    self.paste_line_buffer=t[1:]
+                    log("multi: %s"%self.paste_line_buffer)
+                    return True
+                else:
+                    return False
+        
+    def ipython_paste(self,e):
+        '''Paste windows clipboard. If enable_ipython_paste_list_of_lists is 
+        True then try to convert tabseparated data to repr of list of lists or 
+        repr of array.
+        If enable_ipython_paste_for_paths==True then change \\ to / and spaces to \space'''
+        if self.enable_win32_clipboard:
+                txt=clipboard.get_clipboard_text_and_convert(
+                                                self.enable_ipython_paste_list_of_lists)
+                if self.enable_ipython_paste_for_paths:
+                        if len(txt)<300 and ("\t" not in txt) and ("\n" not in txt):
+                                txt=txt.replace("\\","/").replace(" ",r"\ ")
+                self.insert_text(txt)
+
+
+    def copy_region_to_clipboard(self, e): # ()
+        '''Copy the text in the region to the windows clipboard.'''
+        self.l_buffer.copy_region_to_clipboard()
+
+    def copy_selection_to_clipboard(self, e): # ()
+        '''Copy the text in the region to the windows clipboard.'''
+        self.l_buffer.copy_selection_to_clipboard()
+
+    def cut_selection_to_clipboard(self, e): # ()
+        '''Copy the text in the region to the windows clipboard.'''
+        self.l_buffer.cut_selection_to_clipboard()
+
+
+    def dump_functions(self, e): # ()
+        '''Print all of the functions and their key bindings to the Readline
+        output stream. If a numeric argument is supplied, the output is
+        formatted in such a way that it can be made part of an inputrc
+        file. This command is unbound by default.'''
+        print
+        txt="\n".join(self.rl_settings_to_string())
+        print txt
+        self._print_prompt()
+
+
+
+
+def commonprefix(m):
+    "Given a list of pathnames, returns the longest common leading component"
+    if not m: return ''
+    prefix = m[0]
+    for item in m:
+        for i in range(len(prefix)):
+            if prefix[:i+1].lower() != item[:i+1].lower():
+                prefix = prefix[:i]
+                if i == 0: return ''
+                break
+    return prefix
diff --git a/windows/fuzzbunch/pyreadline/modes/emacs.py b/windows/fuzzbunch/pyreadline/modes/emacs.py
new file mode 100644
index 0000000..b5f97b3
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/modes/emacs.py
@@ -0,0 +1,626 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+import os,sys,time
+import pyreadline.logger as logger
+from   pyreadline.logger import log,log_sock
+from pyreadline.lineeditor.lineobj import Point
+import pyreadline.lineeditor.lineobj as lineobj
+import pyreadline.lineeditor.history as history
+import basemode
+import string
+def format(keyinfo):
+    if len(keyinfo[-1])!=1:
+        k=keyinfo+(-1,)
+    else:
+        k=keyinfo+(ord(keyinfo[-1]),)
+    
+    return "(%s,%s,%s,%s,%x)"%k
+in_ironpython="IronPython" in sys.version
+
+
+class EmacsMode(basemode.BaseMode):
+    mode="emacs"
+    def __init__(self,rlobj):
+        super(EmacsMode,self).__init__(rlobj)
+        self._keylog=(lambda x,y: None)
+        self.previous_func=None
+        self.prompt=">>>"
+    def __repr__(self):
+        return "<EmacsMode>"
+
+    def add_key_logger(self,logfun):
+        """logfun should be function that takes disp_fun and line_buffer object """
+        self._keylog=logfun
+        
+    def _readline_from_keyboard(self):
+        c=self.console
+        def nop(e):
+            pass
+        while 1:
+            self._update_line()
+            try:
+                event = c.getkeypress()
+            except KeyboardInterrupt:
+                from pyreadline.keysyms.common import KeyPress
+                from pyreadline.console.event import Event
+                event=Event(0,0)
+                event.char="c"
+                event.keyinfo=KeyPress("c",shift=False,control=True,meta=False,keyname=None)
+                log_sock("KBDIRQ")
+                if self.allow_ctrl_c:
+                    now=time.time()
+                    if (now-self.ctrl_c_timeout)<self.ctrl_c_tap_time_interval:
+                        raise
+                    else:
+                        self.ctrl_c_timeout=now
+                    pass
+                else:
+                    raise
+            if self.next_meta:
+                self.next_meta = False
+                control, meta, shift, code = event.keyinfo
+                event.keyinfo = (control, True, shift, code)
+
+            #Process exit keys. Only exit on empty line
+            keyinfo=event.keyinfo.tuple()
+            if keyinfo in self.exit_dispatch:
+                if lineobj.EndOfLine(self.l_buffer) == 0:
+                    raise EOFError
+            if len(keyinfo[-1])>1:
+                default=nop
+            else:
+                default=self.self_insert
+            dispatch_func = self.key_dispatch.get(keyinfo,default)
+            
+            log("readline from keyboard:%s,%s"%(keyinfo,dispatch_func))
+            log_sock("%s|%s"%(format(keyinfo),dispatch_func.__name__),"bound_function")
+            r = None
+            if dispatch_func:
+                r = dispatch_func(event)
+                self._keylog(dispatch_func,self.l_buffer)
+                self.l_buffer.push_undo()
+
+            self.previous_func = dispatch_func
+            if r:
+                self._update_line()
+                break
+
+    def readline(self, prompt=''):
+        '''Try to act like GNU readline.'''
+        # handle startup_hook
+        self.ctrl_c_timeout=time.time()
+        self.l_buffer.selection_mark=-1
+        if self.first_prompt:
+            self.first_prompt = False
+            if self.startup_hook:
+                try:
+                    self.startup_hook()
+                except:
+                    print 'startup hook failed'
+                    traceback.print_exc()
+
+        c = self.console
+        self.l_buffer.reset_line()
+        self.prompt = prompt
+        self._print_prompt()
+
+        if self.pre_input_hook:
+            try:
+                self.pre_input_hook()
+            except:
+                print 'pre_input_hook failed'
+                traceback.print_exc()
+                self.pre_input_hook = None
+
+        log("in readline: %s"%self.paste_line_buffer)
+        if len(self.paste_line_buffer)>0:
+            self.l_buffer=lineobj.ReadLineTextBuffer(self.paste_line_buffer[0])
+            self._update_line()
+            self.paste_line_buffer=self.paste_line_buffer[1:]
+            c.write('\r\n')
+        else:
+            self._readline_from_keyboard()
+            c.write('\r\n')
+
+        self.add_history(self.l_buffer.copy())
+
+        log('returning(%s)' % self.l_buffer.get_line_text())
+        return self.l_buffer.get_line_text() + '\n'
+
+#########  History commands
+    def previous_history(self, e): # (C-p)
+        '''Move back through the history list, fetching the previous command. '''
+        self._history.previous_history(self.l_buffer)
+        self.l_buffer.point=lineobj.EndOfLine
+        
+    def next_history(self, e): # (C-n)
+        '''Move forward through the history list, fetching the next command. '''
+        self._history.next_history(self.l_buffer)
+
+    def beginning_of_history(self, e): # (M-<)
+        '''Move to the first line in the history.'''
+        self._history.beginning_of_history()
+
+    def end_of_history(self, e): # (M->)
+        '''Move to the end of the input history, i.e., the line currently
+        being entered.'''
+        self._history.end_of_history(self.l_buffer)
+
+    def _i_search(self, searchfun, direction, init_event):
+        c = self.console
+        line = self.l_buffer.get_line_text()
+        log_sock(str(line))
+        query = ''
+        if (self.previous_func != self.history_search_forward and
+                self.previous_func != self.history_search_backward):
+            self.query = ''.join(self.l_buffer[0:Point].get_line_text())
+        hc_start = self._history.history_cursor #+ direction
+        while 1:
+            x, y = self.prompt_end_pos
+            c.pos(0, y)
+            if direction < 0:
+                prompt = 'reverse-i-search'
+            else:
+                prompt = 'forward-i-search'
+
+            scroll = c.write_scrolling("%s`%s': %s" % (prompt, query, line))
+            self._update_prompt_pos(scroll)
+            self._clear_after()
+
+            event = c.getkeypress()
+            if event.keyinfo.keyname == 'backspace':
+                query = query[:-1]
+                if len(query) > 0:
+                    #self._history.history_cursor = hc_start  #forces search to restart when search empty
+                    line=searchfun(query)                
+                else:
+                    self._bell()
+                    line=""   #empty query means no search result
+            elif event.char in string.letters + string.digits + string.punctuation + ' ':
+                #self._history.history_cursor = hc_start
+                query += event.char
+                line=searchfun(query)
+            elif event.keyinfo == init_event.keyinfo:
+                self._history.history_cursor += direction
+                line=searchfun(query)                
+            else:
+                if event.keyinfo.keyname != 'return':
+                    self._bell()
+                break
+
+        px, py = self.prompt_begin_pos
+        c.pos(0, py)
+        self.l_buffer.set_line(line)
+        self._print_prompt()
+        self._history.history_cursor=len(self._history.history)
+
+    def reverse_search_history(self, e): # (C-r)
+        '''Search backward starting at the current line and moving up
+        through the history as necessary. This is an incremental search.'''
+        self._i_search(self._history.reverse_search_history, -1, e)
+
+    def forward_search_history(self, e): # (C-s)
+        '''Search forward starting at the current line and moving down
+        through the the history as necessary. This is an incremental search.'''
+        self._i_search(self._history.forward_search_history, 1, e)
+
+
+    def non_incremental_reverse_search_history(self, e): # (M-p)
+        '''Search backward starting at the current line and moving up
+        through the history as necessary using a non-incremental search for
+        a string supplied by the user.'''
+        q=self._history.non_incremental_reverse_search_history(self.l_buffer)
+        self.l_buffer=q
+
+    def non_incremental_forward_search_history(self, e): # (M-n)
+        '''Search forward starting at the current line and moving down
+        through the the history as necessary using a non-incremental search
+        for a string supplied by the user.'''
+        q=self._history.non_incremental_reverse_search_history(self.l_buffer)
+        self.l_buffer=q
+
+    def history_search_forward(self, e): # ()
+        '''Search forward through the history for the string of characters
+        between the start of the current line and the point. This is a
+        non-incremental search. By default, this command is unbound.'''
+        if self.previous_func and hasattr(self._history,self.previous_func.__name__):
+            self._history.lastcommand=getattr(self._history,self.previous_func.__name__)
+        else:
+            self._history.lastcommand=None
+        q=self._history.history_search_forward(self.l_buffer)
+        self.l_buffer=q
+        self.l_buffer.point=q.point
+
+    def history_search_backward(self, e): # ()
+        '''Search backward through the history for the string of characters
+        between the start of the current line and the point. This is a
+        non-incremental search. By default, this command is unbound.'''
+        if self.previous_func and hasattr(self._history,self.previous_func.__name__):
+            self._history.lastcommand=getattr(self._history,self.previous_func.__name__)
+        else:
+            self._history.lastcommand=None
+        q=self._history.history_search_backward(self.l_buffer)
+        self.l_buffer=q
+        self.l_buffer.point=q.point
+
+
+    def yank_nth_arg(self, e): # (M-C-y)
+        '''Insert the first argument to the previous command (usually the
+        second word on the previous line) at point. With an argument n,
+        insert the nth word from the previous command (the words in the
+        previous command begin with word 0). A negative argument inserts the
+        nth word from the end of the previous command.'''
+        pass
+
+    def yank_last_arg(self, e): # (M-. or M-_)
+        '''Insert last argument to the previous command (the last word of
+        the previous history entry). With an argument, behave exactly like
+        yank-nth-arg. Successive calls to yank-last-arg move back through
+        the history list, inserting the last argument of each line in turn.'''
+        pass
+
+    def forward_backward_delete_char(self, e): # ()
+        '''Delete the character under the cursor, unless the cursor is at
+        the end of the line, in which case the character behind the cursor
+        is deleted. By default, this is not bound to a key.'''
+        pass
+
+    def quoted_insert(self, e): # (C-q or C-v)
+        '''Add the next character typed to the line verbatim. This is how to
+        insert key sequences like C-q, for example.'''
+        e = self.console.getkeypress()
+        self.insert_text(e.char)
+
+    def tab_insert(self, e): # (M-TAB)
+        '''Insert a tab character. '''
+        ws = ' ' * (self.tabstop - (self.line_cursor%self.tabstop))
+        self.insert_text(ws)
+
+    def transpose_chars(self, e): # (C-t)
+        '''Drag the character before the cursor forward over the character
+        at the cursor, moving the cursor forward as well. If the insertion
+        point is at the end of the line, then this transposes the last two
+        characters of the line. Negative arguments have no effect.'''
+        self.l_buffer.transpose_chars()
+
+    def transpose_words(self, e): # (M-t)
+        '''Drag the word before point past the word after point, moving
+        point past that word as well. If the insertion point is at the end
+        of the line, this transposes the last two words on the line.'''
+        self.l_buffer.transpose_words()
+
+    def overwrite_mode(self, e): # ()
+        '''Toggle overwrite mode. With an explicit positive numeric
+        argument, switches to overwrite mode. With an explicit non-positive
+        numeric argument, switches to insert mode. This command affects only
+        emacs mode; vi mode does overwrite differently. Each call to
+        readline() starts in insert mode. In overwrite mode, characters
+        bound to self-insert replace the text at point rather than pushing
+        the text to the right. Characters bound to backward-delete-char
+        replace the character before point with a space.'''
+        pass
+        
+    def kill_line(self, e): # (C-k)
+        '''Kill the text from point to the end of the line. '''
+        self.l_buffer.kill_line()
+        
+    def backward_kill_line(self, e): # (C-x Rubout)
+        '''Kill backward to the beginning of the line. '''
+        self.l_buffer.backward_kill_line()
+
+    def unix_line_discard(self, e): # (C-u)
+        '''Kill backward from the cursor to the beginning of the current line. '''
+        # how is this different from backward_kill_line?
+        self.l_buffer.unix_line_discard()
+
+    def kill_whole_line(self, e): # ()
+        '''Kill all characters on the current line, no matter where point
+        is. By default, this is unbound.'''
+        self.l_buffer.kill_whole_line()
+
+    def kill_word(self, e): # (M-d)
+        '''Kill from point to the end of the current word, or if between
+        words, to the end of the next word. Word boundaries are the same as
+        forward-word.'''
+        self.l_buffer.kill_word()
+    forward_kill_word=kill_word
+    
+    def backward_kill_word(self, e): # (M-DEL)
+        '''Kill the word behind point. Word boundaries are the same as
+        backward-word. '''
+        self.l_buffer.backward_kill_word()
+
+    def unix_word_rubout(self, e): # (C-w)
+        '''Kill the word behind point, using white space as a word
+        boundary. The killed text is saved on the kill-ring.'''
+        self.l_buffer.unix_word_rubout()
+
+    def kill_region(self, e): # ()
+        '''Kill the text in the current region. By default, this command is unbound. '''
+        pass
+
+    def copy_region_as_kill(self, e): # ()
+        '''Copy the text in the region to the kill buffer, so it can be
+        yanked right away. By default, this command is unbound.'''
+        pass
+
+    def copy_backward_word(self, e): # ()
+        '''Copy the word before point to the kill buffer. The word
+        boundaries are the same as backward-word. By default, this command
+        is unbound.'''
+        pass
+
+    def copy_forward_word(self, e): # ()
+        '''Copy the word following point to the kill buffer. The word
+        boundaries are the same as forward-word. By default, this command is
+        unbound.'''
+        pass
+
+
+    def yank(self, e): # (C-y)
+        '''Yank the top of the kill ring into the buffer at point. '''
+        self.l_buffer.yank()
+
+    def yank_pop(self, e): # (M-y)
+        '''Rotate the kill-ring, and yank the new top. You can only do this
+        if the prior command is yank or yank-pop.'''
+        self.l_buffer.yank_pop()
+
+
+    def digit_argument(self, e): # (M-0, M-1, ... M--)
+        '''Add this digit to the argument already accumulating, or start a
+        new argument. M-- starts a negative argument.'''
+        args=e.char
+
+        c = self.console
+        line = self.l_buffer.get_line_text()
+        oldprompt=self.prompt
+        def nop(e):
+            pass
+        while 1:
+            x, y = self.prompt_end_pos
+            c.pos(0, y)
+            self.prompt="(arg: %s) "%args
+            self._print_prompt()
+            self._update_line()
+
+            event = c.getkeypress()
+            if event.keyinfo.keyname == 'enter':
+                break
+            elif event.char in "0123456789":
+                args+=event.char
+            else:
+                self.argument=int(args)
+                keyinfo=event.keyinfo.tuple()
+                if len(keyinfo[-1])>1:
+                    default=nop
+                else:
+                    default=self.self_insert
+                dispatch_func = self.key_dispatch.get(keyinfo,default)
+                log_sock("%s|%s"%(dispatch_func,str(keyinfo)))
+                dispatch_func(event)
+                break
+        log_sock("END arg=%s"%(self.argument))
+        self.prompt=oldprompt
+        x, y = self.prompt_end_pos
+        c.pos(0, y)
+        self._print_prompt()
+        self._update_line()
+
+            
+
+
+    def universal_argument(self, e): # ()
+        '''This is another way to specify an argument. If this command is
+        followed by one or more digits, optionally with a leading minus
+        sign, those digits define the argument. If the command is followed
+        by digits, executing universal-argument again ends the numeric
+        argument, but is otherwise ignored. As a special case, if this
+        command is immediately followed by a character that is neither a
+        digit or minus sign, the argument count for the next command is
+        multiplied by four. The argument count is initially one, so
+        executing this function the first time makes the argument count
+        four, a second time makes the argument count sixteen, and so on. By
+        default, this is not bound to a key.'''
+        pass
+
+    def delete_char_or_list(self, e): # ()
+        '''Deletes the character under the cursor if not at the beginning or
+        end of the line (like delete-char). If at the end of the line,
+        behaves identically to possible-completions. This command is unbound
+        by default.'''
+        pass
+
+    def start_kbd_macro(self, e): # (C-x ()
+        '''Begin saving the characters typed into the current keyboard macro. '''
+        pass
+
+    def end_kbd_macro(self, e): # (C-x ))
+        '''Stop saving the characters typed into the current keyboard macro
+        and save the definition.'''
+        pass
+
+    def call_last_kbd_macro(self, e): # (C-x e)
+        '''Re-execute the last keyboard macro defined, by making the
+        characters in the macro appear as if typed at the keyboard.'''
+        pass
+
+    def re_read_init_file(self, e): # (C-x C-r)
+        '''Read in the contents of the inputrc file, and incorporate any
+        bindings or variable assignments found there.'''
+        pass
+
+    def abort(self, e): # (C-g)
+        '''Abort the current editing command and ring the terminals bell
+             (subject to the setting of bell-style).'''
+        self._bell()
+
+    def do_uppercase_version(self, e): # (M-a, M-b, M-x, ...)
+        '''If the metafied character x is lowercase, run the command that is
+        bound to the corresponding uppercase character.'''
+        pass
+
+    def prefix_meta(self, e): # (ESC)
+        '''Metafy the next character typed. This is for keyboards without a
+        meta key. Typing ESC f is equivalent to typing M-f. '''
+        self.next_meta = True
+
+    def undo(self, e): # (C-_ or C-x C-u)
+        '''Incremental undo, separately remembered for each line.'''
+        self.l_buffer.pop_undo()
+
+    def revert_line(self, e): # (M-r)
+        '''Undo all changes made to this line. This is like executing the
+        undo command enough times to get back to the beginning.'''
+        pass
+
+    def tilde_expand(self, e): # (M-~)
+        '''Perform tilde expansion on the current word.'''
+        pass
+
+    def set_mark(self, e): # (C-@)
+        '''Set the mark to the point. If a numeric argument is supplied, the
+        mark is set to that position.'''
+        self.l_buffer.set_mark()
+
+    def exchange_point_and_mark(self, e): # (C-x C-x)
+        '''Swap the point with the mark. The current cursor position is set
+        to the saved position, and the old cursor position is saved as the
+        mark.'''
+        pass
+
+    def character_search(self, e): # (C-])
+        '''A character is read and point is moved to the next occurrence of
+        that character. A negative count searches for previous occurrences.'''
+        pass
+
+    def character_search_backward(self, e): # (M-C-])
+        '''A character is read and point is moved to the previous occurrence
+        of that character. A negative count searches for subsequent
+        occurrences.'''
+        pass
+
+    def insert_comment(self, e): # (M-#)
+        '''Without a numeric argument, the value of the comment-begin
+        variable is inserted at the beginning of the current line. If a
+        numeric argument is supplied, this command acts as a toggle: if the
+        characters at the beginning of the line do not match the value of
+        comment-begin, the value is inserted, otherwise the characters in
+        comment-begin are deleted from the beginning of the line. In either
+        case, the line is accepted as if a newline had been typed.'''
+        pass
+
+    def dump_variables(self, e): # ()
+        '''Print all of the settable variables and their values to the
+        Readline output stream. If a numeric argument is supplied, the
+        output is formatted in such a way that it can be made part of an
+        inputrc file. This command is unbound by default.'''
+        pass
+
+    def dump_macros(self, e): # ()
+        '''Print all of the Readline key sequences bound to macros and the
+        strings they output. If a numeric argument is supplied, the output
+        is formatted in such a way that it can be made part of an inputrc
+        file. This command is unbound by default.'''
+        pass
+
+
+    #Create key bindings:
+
+    def init_editing_mode(self, e): # (C-e)
+        '''When in vi command mode, this causes a switch to emacs editing
+        mode.'''
+        self._bind_exit_key('Control-d')
+        self._bind_exit_key('Control-z')
+
+        # I often accidentally hold the shift or control while typing space
+        self._bind_key('space',       self.self_insert)
+        self._bind_key('Shift-space',       self.self_insert)
+        self._bind_key('Control-space',     self.self_insert)
+        self._bind_key('Return',            self.accept_line)
+        self._bind_key('Left',              self.backward_char)
+        self._bind_key('Control-b',         self.backward_char)
+        self._bind_key('Right',             self.forward_char)
+        self._bind_key('Control-f',         self.forward_char)
+        self._bind_key('BackSpace',         self.backward_delete_char)
+        self._bind_key('Control-BackSpace', self.backward_delete_word)
+        
+        self._bind_key('Home',              self.beginning_of_line)
+        self._bind_key('End',               self.end_of_line)
+        self._bind_key('Delete',            self.delete_char)
+        self._bind_key('Control-d',         self.delete_char)
+        self._bind_key('Clear',             self.clear_screen)
+        self._bind_key('Alt-f',             self.forward_word)
+        self._bind_key('Alt-b',             self.backward_word)
+        self._bind_key('Control-l',         self.clear_screen)
+        self._bind_key('Control-p',         self.previous_history)
+        self._bind_key('Up',                self.history_search_backward)
+        self._bind_key('Control-n',         self.next_history)
+        self._bind_key('Down',              self.history_search_forward)
+        self._bind_key('Control-a',         self.beginning_of_line)
+        self._bind_key('Control-e',         self.end_of_line)
+        self._bind_key('Alt-<',             self.beginning_of_history)
+        self._bind_key('Alt->',             self.end_of_history)
+        self._bind_key('Control-r',         self.reverse_search_history)
+        self._bind_key('Control-s',         self.forward_search_history)
+        self._bind_key('Alt-p',             self.non_incremental_reverse_search_history)
+        self._bind_key('Alt-n',             self.non_incremental_forward_search_history)
+        self._bind_key('Control-z',         self.undo)
+        self._bind_key('Control-_',         self.undo)
+        self._bind_key('Escape',            self.kill_whole_line)
+        self._bind_key('Meta-d',            self.kill_word)
+        self._bind_key('Control-Delete',       self.forward_delete_word)
+        self._bind_key('Control-w',         self.unix_word_rubout)
+        #self._bind_key('Control-Shift-v',   self.quoted_insert)
+        self._bind_key('Control-v',         self.paste)
+        self._bind_key('Alt-v',             self.ipython_paste)
+        self._bind_key('Control-y',         self.yank)
+        self._bind_key('Control-k',         self.kill_line)
+        self._bind_key('Control-m',         self.set_mark)
+        self._bind_key('Control-q',         self.copy_region_to_clipboard)
+#        self._bind_key('Control-shift-k',  self.kill_whole_line)
+        self._bind_key('Control-Shift-v',   self.paste_mulitline_code)
+        self._bind_key("Control-Right",     self.forward_word_end)
+        self._bind_key("Control-Left",      self.backward_word)
+        self._bind_key("Shift-Right",       self.forward_char_extend_selection)
+        self._bind_key("Shift-Left",        self.backward_char_extend_selection)
+        self._bind_key("Shift-Control-Right",     self.forward_word_end_extend_selection)
+        self._bind_key("Shift-Control-Left",     self.backward_word_extend_selection)
+        self._bind_key("Shift-Home",        self.beginning_of_line_extend_selection)
+        self._bind_key("Shift-End",         self.end_of_line_extend_selection)
+        self._bind_key("numpad0",           self.self_insert)
+        self._bind_key("numpad1",           self.self_insert)
+        self._bind_key("numpad2",           self.self_insert)
+        self._bind_key("numpad3",           self.self_insert)
+        self._bind_key("numpad4",           self.self_insert)
+        self._bind_key("numpad5",           self.self_insert)
+        self._bind_key("numpad6",           self.self_insert)
+        self._bind_key("numpad7",           self.self_insert)
+        self._bind_key("numpad8",           self.self_insert)
+        self._bind_key("numpad9",           self.self_insert)
+        self._bind_key("add",               self.self_insert)
+        self._bind_key("subtract",          self.self_insert)
+        self._bind_key("multiply",          self.self_insert)
+        self._bind_key("divide",            self.self_insert)
+        self._bind_key("vk_decimal",        self.self_insert)
+        log("RUNNING INIT EMACS")
+
+# make it case insensitive
+def commonprefix(m):
+    "Given a list of pathnames, returns the longest common leading component"
+    if not m: return ''
+    prefix = m[0]
+    for item in m:
+        for i in range(len(prefix)):
+            if prefix[:i+1].lower() != item[:i+1].lower():
+                prefix = prefix[:i]
+                if i == 0: return ''
+                break
+    return prefix
+
diff --git a/windows/fuzzbunch/pyreadline/modes/fuzzbunch.py b/windows/fuzzbunch/pyreadline/modes/fuzzbunch.py
new file mode 100644
index 0000000..9282ead
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/modes/fuzzbunch.py
@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+import os,sys,time
+import pyreadline.logger as logger
+from   pyreadline.logger import log,log_sock
+from pyreadline.lineeditor.lineobj import Point
+import pyreadline.lineeditor.lineobj as lineobj
+import pyreadline.lineeditor.history as history
+import emacs 
+import string
+
+class FuzzbunchMode(emacs.EmacsMode):
+    mode="fuzzbunch"
+    def __init__(self,rlobj):
+        super(FuzzbunchMode,self).__init__(rlobj)
+        self._keylog=(lambda x,y: None)
+        self.previous_func=None
+        self.prompt=">>>"
+    def __repr__(self):
+        return "<FuzzbunchMode>"
+
+    def _get_completions(self):
+        '''Return a list of possible completions for the string ending at the point.
+
+        Also set begidx and endidx in the process.'''
+        completions = []
+        self.begidx = self.l_buffer.point
+        self.endidx = self.l_buffer.point
+        buf=self.l_buffer.line_buffer
+        if self.completer:
+            # get the string to complete
+            while self.begidx > 0:
+                self.begidx -= 1
+                if buf[self.begidx] in self.completer_delims:
+                    self.begidx += 1
+                    break
+            text = ''.join(buf[self.begidx:self.endidx])
+            log('complete text="%s"' % text)
+            i = 0
+            while 1:
+                try:
+                    r = self.completer(text, i)
+                except:
+                    break
+                i += 1
+                if r and r not in completions:
+                    completions.append(r)
+                else:
+                    break
+            if len(completions) == 1:
+                completions[0] = completions[0] + " "
+            log('text completions=%s' % completions)
+        return completions
+
+
diff --git a/windows/fuzzbunch/pyreadline/modes/notemacs.py b/windows/fuzzbunch/pyreadline/modes/notemacs.py
new file mode 100644
index 0000000..4043a5c
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/modes/notemacs.py
@@ -0,0 +1,601 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+import os
+import pyreadline.logger as logger
+from   pyreadline.logger import log
+import pyreadline.lineeditor.lineobj as lineobj
+import pyreadline.lineeditor.history as history
+import basemode
+
+class NotEmacsMode(basemode.BaseMode):
+    mode="notemacs"
+    def __init__(self,rlobj):
+        super(NotEmacsMode,self).__init__(rlobj)
+
+    def __repr__(self):
+        return "<NotEmacsMode>"
+
+    def _readline_from_keyboard(self):
+        c=self.console
+        while 1:
+            self._update_line()
+            event = c.getkeypress()
+            if self.next_meta:
+                self.next_meta = False
+                control, meta, shift, code = event.keyinfo
+                event.keyinfo = (control, True, shift, code)
+
+            #Process exit keys. Only exit on empty line
+            if event.keyinfo in self.exit_dispatch:
+                if lineobj.EndOfLine(self.l_buffer) == 0:
+                    raise EOFError
+
+            dispatch_func = self.key_dispatch.get(event.keyinfo,self.self_insert)
+            log("readline from keyboard:%s"%(event.keyinfo,))
+            r = None
+            if dispatch_func:
+                r = dispatch_func(event)
+                self.l_buffer.push_undo()
+
+            self.previous_func = dispatch_func
+            if r:
+                self._update_line()
+                break
+
+    def readline(self, prompt=''):
+        '''Try to act like GNU readline.'''
+        # handle startup_hook
+        if self.first_prompt:
+            self.first_prompt = False
+            if self.startup_hook:
+                try:
+                    self.startup_hook()
+                except:
+                    print 'startup hook failed'
+                    traceback.print_exc()
+
+        c = self.console
+        self.l_buffer.reset_line()
+        self.prompt = prompt
+        self._print_prompt()
+
+        if self.pre_input_hook:
+            try:
+                self.pre_input_hook()
+            except:
+                print 'pre_input_hook failed'
+                traceback.print_exc()
+                self.pre_input_hook = None
+
+        log("in readline: %s"%self.paste_line_buffer)
+        if len(self.paste_line_buffer)>0:
+            self.l_buffer=lineobj.ReadlineTextBuffer(self.paste_line_buffer[0])
+            self._update_line()
+            self.paste_line_buffer=self.paste_line_buffer[1:]
+            c.write('\r\n')
+        else:
+            self._readline_from_keyboard()
+            c.write('\r\n')
+
+        self.add_history(self.l_buffer.copy())
+
+        log('returning(%s)' % self.l_buffer.get_line_text())
+        return self.l_buffer.get_line_text() + '\n'
+
+    ### Methods below here are bindable emacs functions
+
+    def beginning_of_line(self, e): # (C-a)
+        '''Move to the start of the current line. '''
+        self.l_buffer.beginning_of_line()
+
+    def end_of_line(self, e): # (C-e)
+        '''Move to the end of the line. '''
+        self.l_buffer.end_of_line()
+
+    def forward_char(self, e): # (C-f)
+        '''Move forward a character. '''
+        self.l_buffer.forward_char()
+
+    def backward_char(self, e): # (C-b)
+        '''Move back a character. '''
+        self.l_buffer.backward_char()
+
+    def forward_word(self, e): # (M-f)
+        '''Move forward to the end of the next word. Words are composed of
+        letters and digits.'''
+        self.l_buffer.forward_word()
+
+    def backward_word(self, e): # (M-b)
+        '''Move back to the start of the current or previous word. Words are
+        composed of letters and digits.'''
+        self.l_buffer.backward_word()
+
+    def clear_screen(self, e): # (C-l)
+        '''Clear the screen and redraw the current line, leaving the current
+        line at the top of the screen.'''
+        self.console.page()
+
+    def redraw_current_line(self, e): # ()
+        '''Refresh the current line. By default, this is unbound.'''
+        pass
+
+    def accept_line(self, e): # (Newline or Return)
+        '''Accept the line regardless of where the cursor is. If this line
+        is non-empty, it may be added to the history list for future recall
+        with add_history(). If this line is a modified history line, the
+        history line is restored to its original state.'''
+        return True
+
+#########  History commands
+    def previous_history(self, e): # (C-p)
+        '''Move back through the history list, fetching the previous command. '''
+        self._history.previous_history(self.l_buffer)
+
+    def next_history(self, e): # (C-n)
+        '''Move forward through the history list, fetching the next command. '''
+        self._history.next_history(self.l_buffer)
+
+    def beginning_of_history(self, e): # (M-<)
+        '''Move to the first line in the history.'''
+        self._history.beginning_of_history()
+
+    def end_of_history(self, e): # (M->)
+        '''Move to the end of the input history, i.e., the line currently
+        being entered.'''
+        self._history.end_of_history(self.l_buffer)
+
+    def _i_search(self, searchfun, direction, init_event):
+        c = self.console
+        line = self.get_line_buffer()
+        query = ''
+        hc_start = self._history.history_cursor #+ direction
+        while 1:
+            x, y = self.prompt_end_pos
+            c.pos(0, y)
+            if direction < 0:
+                prompt = 'reverse-i-search'
+            else:
+                prompt = 'forward-i-search'
+
+            scroll = c.write_scrolling("%s`%s': %s" % (prompt, query, line))
+            self._update_prompt_pos(scroll)
+            self._clear_after()
+
+            event = c.getkeypress()
+            if event.keysym == 'BackSpace':
+                if len(query) > 0:
+                    query = query[:-1]
+                    self._history.history_cursor = hc_start
+                else:
+                    self._bell()
+            elif event.char in string.letters + string.digits + string.punctuation + ' ':
+                self._history.history_cursor = hc_start
+                query += event.char
+            elif event.keyinfo == init_event.keyinfo:
+                self._history.history_cursor += direction
+                line=searchfun(query)                
+                pass
+            else:
+                if event.keysym != 'Return':
+                    self._bell()
+                break
+            line=searchfun(query)
+
+        px, py = self.prompt_begin_pos
+        c.pos(0, py)
+        self.l_buffer.set_line(line)
+        self._print_prompt()
+        self._history.history_cursor=len(self._history.history)
+
+    def reverse_search_history(self, e): # (C-r)
+        '''Search backward starting at the current line and moving up
+        through the history as necessary. This is an incremental search.'''
+#        print "HEJ"
+#        self.console.bell()
+        self._i_search(self._history.reverse_search_history, -1, e)
+
+    def forward_search_history(self, e): # (C-s)
+        '''Search forward starting at the current line and moving down
+        through the the history as necessary. This is an incremental search.'''
+#        print "HEJ"
+#        self.console.bell()
+        self._i_search(self._history.forward_search_history, 1, e)
+
+
+    def non_incremental_reverse_search_history(self, e): # (M-p)
+        '''Search backward starting at the current line and moving up
+        through the history as necessary using a non-incremental search for
+        a string supplied by the user.'''
+        self._history.non_incremental_reverse_search_history(self.l_buffer)
+
+    def non_incremental_forward_search_history(self, e): # (M-n)
+        '''Search forward starting at the current line and moving down
+        through the the history as necessary using a non-incremental search
+        for a string supplied by the user.'''
+        self._history.non_incremental_reverse_search_history(self.l_buffer)
+
+    def history_search_forward(self, e): # ()
+        '''Search forward through the history for the string of characters
+        between the start of the current line and the point. This is a
+        non-incremental search. By default, this command is unbound.'''
+        self.l_buffer=self._history.history_search_forward(self.l_buffer)
+
+    def history_search_backward(self, e): # ()
+        '''Search backward through the history for the string of characters
+        between the start of the current line and the point. This is a
+        non-incremental search. By default, this command is unbound.'''
+        self.l_buffer=self._history.history_search_backward(self.l_buffer)
+
+    def yank_nth_arg(self, e): # (M-C-y)
+        '''Insert the first argument to the previous command (usually the
+        second word on the previous line) at point. With an argument n,
+        insert the nth word from the previous command (the words in the
+        previous command begin with word 0). A negative argument inserts the
+        nth word from the end of the previous command.'''
+        pass
+
+    def yank_last_arg(self, e): # (M-. or M-_)
+        '''Insert last argument to the previous command (the last word of
+        the previous history entry). With an argument, behave exactly like
+        yank-nth-arg. Successive calls to yank-last-arg move back through
+        the history list, inserting the last argument of each line in turn.'''
+        pass
+
+    def delete_char(self, e): # (C-d)
+        '''Delete the character at point. If point is at the beginning of
+        the line, there are no characters in the line, and the last
+        character typed was not bound to delete-char, then return EOF.'''
+        self.l_buffer.delete_char()
+
+    def backward_delete_char(self, e): # (Rubout)
+        '''Delete the character behind the cursor. A numeric argument means
+        to kill the characters instead of deleting them.'''
+        self.l_buffer.backward_delete_char()
+
+    def forward_backward_delete_char(self, e): # ()
+        '''Delete the character under the cursor, unless the cursor is at
+        the end of the line, in which case the character behind the cursor
+        is deleted. By default, this is not bound to a key.'''
+        pass
+
+    def quoted_insert(self, e): # (C-q or C-v)
+        '''Add the next character typed to the line verbatim. This is how to
+        insert key sequences like C-q, for example.'''
+        e = self.console.getkeypress()
+        self.insert_text(e.char)
+
+    def tab_insert(self, e): # (M-TAB)
+        '''Insert a tab character. '''
+        ws = ' ' * (self.tabstop - (self.line_cursor%self.tabstop))
+        self.insert_text(ws)
+
+    def self_insert(self, e): # (a, b, A, 1, !, ...)
+        '''Insert yourself. '''
+        if ord(e.char)!=0: #don't insert null character in buffer, can happen with dead keys.
+            self.insert_text(e.char)
+
+    def transpose_chars(self, e): # (C-t)
+        '''Drag the character before the cursor forward over the character
+        at the cursor, moving the cursor forward as well. If the insertion
+        point is at the end of the line, then this transposes the last two
+        characters of the line. Negative arguments have no effect.'''
+        self.l_buffer.transpose_chars()
+
+    def transpose_words(self, e): # (M-t)
+        '''Drag the word before point past the word after point, moving
+        point past that word as well. If the insertion point is at the end
+        of the line, this transposes the last two words on the line.'''
+        self.l_buffer.transpose_words()
+
+    def upcase_word(self, e): # (M-u)
+        '''Uppercase the current (or following) word. With a negative
+        argument, uppercase the previous word, but do not move the cursor.'''
+        self.l_buffer.upcase_word()
+
+    def downcase_word(self, e): # (M-l)
+        '''Lowercase the current (or following) word. With a negative
+        argument, lowercase the previous word, but do not move the cursor.'''
+        self.l_buffer.downcase_word()
+
+    def capitalize_word(self, e): # (M-c)
+        '''Capitalize the current (or following) word. With a negative
+        argument, capitalize the previous word, but do not move the cursor.'''
+        self.l_buffer.capitalize_word()
+
+    def overwrite_mode(self, e): # ()
+        '''Toggle overwrite mode. With an explicit positive numeric
+        argument, switches to overwrite mode. With an explicit non-positive
+        numeric argument, switches to insert mode. This command affects only
+        emacs mode; vi mode does overwrite differently. Each call to
+        readline() starts in insert mode. In overwrite mode, characters
+        bound to self-insert replace the text at point rather than pushing
+        the text to the right. Characters bound to backward-delete-char
+        replace the character before point with a space.'''
+        pass
+        
+    def kill_line(self, e): # (C-k)
+        '''Kill the text from point to the end of the line. '''
+        self.l_buffer.kill_line()
+        
+    def backward_kill_line(self, e): # (C-x Rubout)
+        '''Kill backward to the beginning of the line. '''
+        self.l_buffer.backward_kill_line()
+
+    def unix_line_discard(self, e): # (C-u)
+        '''Kill backward from the cursor to the beginning of the current line. '''
+        # how is this different from backward_kill_line?
+        self.l_buffer.unix_line_discard()
+
+    def kill_whole_line(self, e): # ()
+        '''Kill all characters on the current line, no matter where point
+        is. By default, this is unbound.'''
+        self.l_buffer.kill_whole_line()
+
+    def kill_word(self, e): # (M-d)
+        '''Kill from point to the end of the current word, or if between
+        words, to the end of the next word. Word boundaries are the same as
+        forward-word.'''
+        self.l_buffer.kill_word()
+
+    def backward_kill_word(self, e): # (M-DEL)
+        '''Kill the word behind point. Word boundaries are the same as
+        backward-word. '''
+        self.l_buffer.backward_kill_word()
+
+    def unix_word_rubout(self, e): # (C-w)
+        '''Kill the word behind point, using white space as a word
+        boundary. The killed text is saved on the kill-ring.'''
+        self.l_buffer.unix_word_rubout()
+
+    def delete_horizontal_space(self, e): # ()
+        '''Delete all spaces and tabs around point. By default, this is unbound. '''
+        pass
+
+    def kill_region(self, e): # ()
+        '''Kill the text in the current region. By default, this command is unbound. '''
+        pass
+
+    def copy_region_as_kill(self, e): # ()
+        '''Copy the text in the region to the kill buffer, so it can be
+        yanked right away. By default, this command is unbound.'''
+        pass
+
+    def copy_region_to_clipboard(self, e): # ()
+        '''Copy the text in the region to the windows clipboard.'''
+        if self.enable_win32_clipboard:
+                mark=min(self.l_buffer.mark,len(self.l_buffer.line_buffer))
+                cursor=min(self.l_buffer.point,len(self.l_buffer.line_buffer))
+                if self.l_buffer.mark==-1:
+                        return
+                begin=min(cursor,mark)
+                end=max(cursor,mark)
+                toclipboard="".join(self.l_buffer.line_buffer[begin:end])
+                clipboard.SetClipboardText(str(toclipboard))
+
+    def copy_backward_word(self, e): # ()
+        '''Copy the word before point to the kill buffer. The word
+        boundaries are the same as backward-word. By default, this command
+        is unbound.'''
+        pass
+
+    def copy_forward_word(self, e): # ()
+        '''Copy the word following point to the kill buffer. The word
+        boundaries are the same as forward-word. By default, this command is
+        unbound.'''
+        pass
+
+    def paste(self,e):
+        '''Paste windows clipboard'''
+        if self.enable_win32_clipboard:
+                txt=clipboard.get_clipboard_text_and_convert(False)
+                self.insert_text(txt)
+
+    def paste_mulitline_code(self,e):
+        '''Paste windows clipboard'''
+        reg=re.compile("\r?\n")
+        if self.enable_win32_clipboard:
+                txt=clipboard.get_clipboard_text_and_convert(False)
+                t=reg.split(txt)
+                t=[row for row in t if row.strip()!=""] #remove empty lines
+                if t!=[""]:
+                    self.insert_text(t[0])
+                    self.add_history(self.l_buffer.copy())
+                    self.paste_line_buffer=t[1:]
+                    log("multi: %s"%self.paste_line_buffer)
+                    return True
+                else:
+                    return False
+        
+    def ipython_paste(self,e):
+        '''Paste windows clipboard. If enable_ipython_paste_list_of_lists is 
+        True then try to convert tabseparated data to repr of list of lists or 
+        repr of array'''
+        if self.enable_win32_clipboard:
+                txt=clipboard.get_clipboard_text_and_convert(
+                                                self.enable_ipython_paste_list_of_lists)
+                if self.enable_ipython_paste_for_paths:
+                        if len(txt)<300 and ("\t" not in txt) and ("\n" not in txt):
+                                txt=txt.replace("\\","/").replace(" ",r"\ ")
+                self.insert_text(txt)
+
+    def yank(self, e): # (C-y)
+        '''Yank the top of the kill ring into the buffer at point. '''
+        pass
+
+    def yank_pop(self, e): # (M-y)
+        '''Rotate the kill-ring, and yank the new top. You can only do this
+        if the prior command is yank or yank-pop.'''
+        pass
+
+
+    def digit_argument(self, e): # (M-0, M-1, ... M--)
+        '''Add this digit to the argument already accumulating, or start a
+        new argument. M-- starts a negative argument.'''
+        pass
+
+    def universal_argument(self, e): # ()
+        '''This is another way to specify an argument. If this command is
+        followed by one or more digits, optionally with a leading minus
+        sign, those digits define the argument. If the command is followed
+        by digits, executing universal-argument again ends the numeric
+        argument, but is otherwise ignored. As a special case, if this
+        command is immediately followed by a character that is neither a
+        digit or minus sign, the argument count for the next command is
+        multiplied by four. The argument count is initially one, so
+        executing this function the first time makes the argument count
+        four, a second time makes the argument count sixteen, and so on. By
+        default, this is not bound to a key.'''
+        pass
+
+    def delete_char_or_list(self, e): # ()
+        '''Deletes the character under the cursor if not at the beginning or
+        end of the line (like delete-char). If at the end of the line,
+        behaves identically to possible-completions. This command is unbound
+        by default.'''
+        pass
+
+    def start_kbd_macro(self, e): # (C-x ()
+        '''Begin saving the characters typed into the current keyboard macro. '''
+        pass
+
+    def end_kbd_macro(self, e): # (C-x ))
+        '''Stop saving the characters typed into the current keyboard macro
+        and save the definition.'''
+        pass
+
+    def call_last_kbd_macro(self, e): # (C-x e)
+        '''Re-execute the last keyboard macro defined, by making the
+        characters in the macro appear as if typed at the keyboard.'''
+        pass
+
+    def re_read_init_file(self, e): # (C-x C-r)
+        '''Read in the contents of the inputrc file, and incorporate any
+        bindings or variable assignments found there.'''
+        pass
+
+    def abort(self, e): # (C-g)
+        '''Abort the current editing command and ring the terminals bell
+             (subject to the setting of bell-style).'''
+        self._bell()
+
+    def do_uppercase_version(self, e): # (M-a, M-b, M-x, ...)
+        '''If the metafied character x is lowercase, run the command that is
+        bound to the corresponding uppercase character.'''
+        pass
+
+    def prefix_meta(self, e): # (ESC)
+        '''Metafy the next character typed. This is for keyboards without a
+        meta key. Typing ESC f is equivalent to typing M-f. '''
+        self.next_meta = True
+
+    def undo(self, e): # (C-_ or C-x C-u)
+        '''Incremental undo, separately remembered for each line.'''
+        self.l_buffer.pop_undo()
+
+    def revert_line(self, e): # (M-r)
+        '''Undo all changes made to this line. This is like executing the
+        undo command enough times to get back to the beginning.'''
+        pass
+
+    def tilde_expand(self, e): # (M-~)
+        '''Perform tilde expansion on the current word.'''
+        pass
+
+    def set_mark(self, e): # (C-@)
+        '''Set the mark to the point. If a numeric argument is supplied, the
+        mark is set to that position.'''
+        self.l_buffer.set_mark()
+
+    def exchange_point_and_mark(self, e): # (C-x C-x)
+        '''Swap the point with the mark. The current cursor position is set
+        to the saved position, and the old cursor position is saved as the
+        mark.'''
+        pass
+
+    def character_search(self, e): # (C-])
+        '''A character is read and point is moved to the next occurrence of
+        that character. A negative count searches for previous occurrences.'''
+        pass
+
+    def character_search_backward(self, e): # (M-C-])
+        '''A character is read and point is moved to the previous occurrence
+        of that character. A negative count searches for subsequent
+        occurrences.'''
+        pass
+
+    def insert_comment(self, e): # (M-#)
+        '''Without a numeric argument, the value of the comment-begin
+        variable is inserted at the beginning of the current line. If a
+        numeric argument is supplied, this command acts as a toggle: if the
+        characters at the beginning of the line do not match the value of
+        comment-begin, the value is inserted, otherwise the characters in
+        comment-begin are deleted from the beginning of the line. In either
+        case, the line is accepted as if a newline had been typed.'''
+        pass
+
+    def dump_functions(self, e): # ()
+        '''Print all of the functions and their key bindings to the Readline
+        output stream. If a numeric argument is supplied, the output is
+        formatted in such a way that it can be made part of an inputrc
+        file. This command is unbound by default.'''
+        pass
+
+    def dump_variables(self, e): # ()
+        '''Print all of the settable variables and their values to the
+        Readline output stream. If a numeric argument is supplied, the
+        output is formatted in such a way that it can be made part of an
+        inputrc file. This command is unbound by default.'''
+        pass
+
+    def dump_macros(self, e): # ()
+        '''Print all of the Readline key sequences bound to macros and the
+        strings they output. If a numeric argument is supplied, the output
+        is formatted in such a way that it can be made part of an inputrc
+        file. This command is unbound by default.'''
+        pass
+
+
+    #Create key bindings:
+
+    def init_editing_mode(self, e): # (C-e)
+        '''When in vi command mode, this causes a switch to emacs editing
+        mode.'''
+
+        self._bind_exit_key('Control-d')
+        self._bind_exit_key('Control-z')
+
+        # I often accidentally hold the shift or control while typing space
+        self._bind_key('Shift-space',       self.self_insert)
+        self._bind_key('Control-space',     self.self_insert)
+        self._bind_key('Return',            self.accept_line)
+        self._bind_key('Left',              self.backward_char)
+        self._bind_key('Control-b',         self.backward_char)
+        self._bind_key('Right',             self.forward_char)
+        self._bind_key('Control-f',         self.forward_char)
+        self._bind_key('BackSpace',         self.backward_delete_char)
+        self._bind_key('Home',              self.beginning_of_line)
+        self._bind_key('End',               self.end_of_line)
+        self._bind_key('Delete',            self.delete_char)
+        self._bind_key('Control-d',         self.delete_char)
+        self._bind_key('Clear',             self.clear_screen)
+
+
+# make it case insensitive
+def commonprefix(m):
+    "Given a list of pathnames, returns the longest common leading component"
+    if not m: return ''
+    prefix = m[0]
+    for item in m:
+        for i in range(len(prefix)):
+            if prefix[:i+1].lower() != item[:i+1].lower():
+                prefix = prefix[:i]
+                if i == 0: return ''
+                break
+    return prefix
+
diff --git a/windows/fuzzbunch/pyreadline/modes/vi.py b/windows/fuzzbunch/pyreadline/modes/vi.py
new file mode 100644
index 0000000..5542fda
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/modes/vi.py
@@ -0,0 +1,1219 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006  Michael Graz. <mgraz@plan10.com>
+#       Copyright (C) 2006  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+import os
+import pyreadline.logger as logger
+from   pyreadline.logger import log,log_sock
+import pyreadline.lineeditor.lineobj as lineobj
+import pyreadline.lineeditor.history as history
+import basemode
+
+class ViMode(basemode.BaseMode):
+    mode="vi"
+    def __init__(self,rlobj):
+        super(ViMode,self).__init__(rlobj)
+        self.__vi_insert_mode = None
+
+    def __repr__(self):
+        return "<ViMode>"
+
+    def _readline_from_keyboard(self):
+        c=self.console
+        while 1:
+            self._update_line()
+            event = c.getkeypress()
+            if self.next_meta:
+                self.next_meta = False
+                control, meta, shift, code = event.keyinfo
+                event.keyinfo = (control, True, shift, code)
+
+            #Process exit keys. Only exit on empty line
+            if event.keyinfo in self.exit_dispatch:
+                if lineobj.EndOfLine(self.l_buffer) == 0:
+                    raise EOFError
+
+            dispatch_func = self.key_dispatch.get(event.keyinfo.tuple(),self.vi_key)
+            log("readline from keyboard:%s->%s"%(event.keyinfo.tuple(),dispatch_func))
+            r = None
+            if dispatch_func:
+                r = dispatch_func(event)
+                self.l_buffer.push_undo()
+
+            self.previous_func = dispatch_func
+            if r:
+                self._update_line()
+                break
+
+    def readline(self, prompt=''):
+        '''Try to act like GNU readline.'''
+        # handle startup_hook
+        if self.first_prompt:
+            self.first_prompt = False
+            if self.startup_hook:
+                try:
+                    self.startup_hook()
+                except:
+                    print 'startup hook failed'
+                    traceback.print_exc()
+
+        c = self.console
+        self.l_buffer.reset_line()
+        self.prompt = prompt
+        self._print_prompt()
+
+        if self.pre_input_hook:
+            try:
+                self.pre_input_hook()
+            except:
+                print 'pre_input_hook failed'
+                traceback.print_exc()
+                self.pre_input_hook = None
+
+        log("in readline: %s"%self.paste_line_buffer)
+        if len(self.paste_line_buffer)>0:
+            self.l_buffer=lineobj.ReadlineTextBuffer(self.paste_line_buffer[0])
+            self._update_line()
+            self.paste_line_buffer=self.paste_line_buffer[1:]
+            c.write('\r\n')
+        else:
+            self._readline_from_keyboard()
+            c.write('\r\n')
+
+        self.add_history(self.l_buffer.copy())
+
+        log('returning(%s)' % self.l_buffer.get_line_text())
+        return self.l_buffer.get_line_text() + '\n'
+
+    ### Methods below here are bindable emacs functions
+
+    def init_editing_mode(self, e): # (M-C-j)
+        '''Initialize vi editingmode'''
+        self.show_all_if_ambiguous = 'on'
+        self.key_dispatch = {}
+        self.__vi_insert_mode = None
+        self._vi_command = None
+        self._vi_command_edit = None
+        self._vi_key_find_char = None
+        self._vi_key_find_direction = True
+        self._vi_yank_buffer = None
+        self._vi_multiplier1 = ''
+        self._vi_multiplier2 = ''
+        self._vi_undo_stack = []
+        self._vi_undo_cursor = -1
+        self._vi_current = None
+        self._vi_search_text = ''
+        self.vi_save_line ()
+        self.vi_set_insert_mode (True)
+        # make ' ' to ~ self insert
+        for c in range(ord(' '), 127):
+            self._bind_key('%s' % chr(c), self.vi_key)
+        self._bind_key('BackSpace', self.vi_backspace)
+        self._bind_key('Escape', self.vi_escape)
+        self._bind_key('Return', self.vi_accept_line)
+
+        self._bind_key('Left', self.backward_char)
+        self._bind_key('Right', self.forward_char)
+        self._bind_key('Home', self.beginning_of_line)
+        self._bind_key('End', self.end_of_line)
+        self._bind_key('Delete', self.delete_char)
+
+        self._bind_key('Control-d', self.vi_eof)
+        self._bind_key('Control-z', self.vi_eof)
+        self._bind_key('Control-r', self.vi_redo)
+        self._bind_key('Up', self.vi_arrow_up)
+        self._bind_key('Control-p', self.vi_up)
+        self._bind_key('Down', self.vi_arrow_down)
+        self._bind_key('Control-n', self.vi_down)
+        self._bind_key('Tab', self.vi_complete)
+#        self._bind_key('Control-e', self.emacs)
+
+    def vi_key (self, e):
+        if not self._vi_command:
+            self._vi_command = ViCommand (self)
+        elif self._vi_command.is_end:
+            if self._vi_command.is_edit:
+                self._vi_command_edit = self._vi_command
+            self._vi_command = ViCommand (self)
+        self._vi_command.add_char (e.char)
+
+    def vi_error (self):
+        self._bell ()
+
+    def vi_get_is_insert_mode (self):
+        return self.__vi_insert_mode
+    vi_is_insert_mode = property (vi_get_is_insert_mode)
+
+    def vi_escape (self, e):
+        if self.vi_is_insert_mode:
+            if self._vi_command:
+                self._vi_command.add_char (e.char)
+            else:
+                self._vi_command = ViCommand (self)
+            self.vi_set_insert_mode (False)
+#            if self.line_cursor > 0:
+#                self.line_cursor -= 1
+            self.l_buffer.point=lineobj.PrevChar
+        elif self._vi_command and self._vi_command.is_replace_one:
+            self._vi_command.add_char (e.char)
+        else:
+            self.vi_error ()
+
+    def vi_backspace (self, e):
+        if self._vi_command:
+            self._vi_command.add_char (e.char)
+        else:
+            self._vi_do_backspace (self._vi_command)
+
+    def _vi_do_backspace (self, vi_cmd):
+        if self.vi_is_insert_mode or (self._vi_command and self._vi_command.is_search):
+            if self.l_buffer.point > 0:
+                self.l_buffer.point -= 1
+                if self.l_buffer.overwrite:
+                    try:
+                        prev = self._vi_undo_stack [self._vi_undo_cursor][1][self.l_buffer.point ]
+                        self.l_buffer.line_buffer [self.l_buffer.point] = prev
+                    except IndexError:
+                        del self.l_buffer.line_buffer [self.l_buffer.point ]
+                else:
+                    self.vi_save_line ()
+                    del self.l_buffer.line_buffer [self.l_buffer.point ]
+
+    def vi_accept_line (self, e):
+        if self._vi_command and self._vi_command.is_search:
+            self._vi_command.do_search ()
+            return False
+        self._vi_command = None
+        self.vi_set_insert_mode (True)
+        self._vi_undo_stack = []
+        self._vi_undo_cursor = -1
+        self._vi_current = None
+        return self.accept_line (e)
+
+    def vi_eof (self, e):
+        raise EOFError
+
+    def vi_set_insert_mode (self, value):
+        if self.__vi_insert_mode == value:
+            return
+        self.__vi_insert_mode = value
+        if value:
+            self.vi_save_line ()
+            self.console.cursor (size=25)
+        else:
+            self.console.cursor (size=100)
+
+    def vi_undo_restart (self):
+        tpl_undo = (self.l_buffer.point, self.l_buffer.line_buffer[:], )
+        self._vi_undo_stack = [tpl_undo]
+        self._vi_undo_cursor = 0
+
+    def vi_save_line (self):
+        if self._vi_undo_stack and self._vi_undo_cursor >= 0:
+            del self._vi_undo_stack [self._vi_undo_cursor + 1 : ]
+        # tpl_undo = (self.l_buffer.point, self.l_buffer[:], )
+        tpl_undo = (self.l_buffer.point, self.l_buffer.line_buffer[:], )
+        if not self._vi_undo_stack or self._vi_undo_stack[self._vi_undo_cursor][1] != tpl_undo[1]:
+            self._vi_undo_stack.append (tpl_undo)
+            self._vi_undo_cursor += 1
+
+    def vi_undo_prepare (self):
+        if self._vi_undo_cursor == len(self._vi_undo_stack)-1:
+            self.vi_save_line ()
+
+    def vi_undo (self, do_pop=True):
+        self.vi_undo_prepare ()
+        if not self._vi_undo_stack or self._vi_undo_cursor <= 0:
+            self.vi_error ()
+            return
+        self._vi_undo_cursor -= 1
+        self.vi_undo_assign ()
+
+    def vi_undo_all (self):
+        self.vi_undo_prepare ()
+        if self._vi_undo_cursor > 0:
+            self._vi_undo_cursor = 0
+            self.vi_undo_assign ()
+        else:
+            self.vi_error ()
+
+    def vi_undo_assign (self):
+        tpl_undo = self._vi_undo_stack [self._vi_undo_cursor]
+        self.l_buffer.line_buffer = tpl_undo [1][:]
+        self.l_buffer.point = tpl_undo [0]
+
+    def vi_redo (self, e):
+        if self._vi_undo_cursor >= len(self._vi_undo_stack)-1:
+            self.vi_error ()
+            return
+        self._vi_undo_cursor += 1
+        self.vi_undo_assign ()
+
+    def vi_search (self, rng):
+        for i in rng:
+            line_history = self._history.history [i]
+            pos = line_history.get_line_text().find (self._vi_search_text)
+            if pos >= 0:
+                self._history.history_cursor = i
+                self.l_buffer.line_buffer = list (line_history.line_buffer)
+                self.l_buffer.point = pos
+                self.vi_undo_restart ()
+                return True
+        self._bell ()
+        return False
+
+    def vi_search_first (self):
+        text = ''.join (self.l_buffer.line_buffer [1:])
+        if text:
+            self._vi_search_text = text
+            position = len (self._history.history) - 1
+        elif self._vi_search_text:
+            position = self._history.history_cursor - 1
+        else:
+            self.vi_error ()
+            self.vi_undo ()
+            return
+        if not self.vi_search (range (position, -1, -1)):
+            # Here: search text not found
+            self.vi_undo ()
+
+    def vi_search_again_backward (self):
+        self.vi_search (range (self._history.history_cursor-1, -1, -1))
+
+    def vi_search_again_forward (self):
+        self.vi_search (range (self._history.history_cursor+1, len(self._history.history)))
+
+    def vi_up (self, e):
+        if self._history.history_cursor == len(self._history.history):
+            self._vi_current = self.l_buffer.line_buffer [:]
+        # self._history.previous_history (e)
+        self._history.previous_history (self.l_buffer)
+        if self.vi_is_insert_mode:
+            self.end_of_line (e)
+        else:
+            self.beginning_of_line (e)
+        self.vi_undo_restart ()
+
+    def vi_down (self, e):
+        if self._history.history_cursor >= len(self._history.history):
+            self.vi_error ()
+            return
+        if self._history.history_cursor < len(self._history.history) - 1:
+            # self._history.next_history (e)
+            self._history.next_history (self.l_buffer)
+            if self.vi_is_insert_mode:
+                self.end_of_line (e)
+            else:
+                self.beginning_of_line (e)
+            self.vi_undo_restart ()
+        elif self._vi_current is not None:
+            self._history.history_cursor = len(self._history.history)
+            self.l_buffer.line_buffer = self._vi_current
+            self.end_of_line (e)
+            if not self.vi_is_insert_mode and self.l_buffer.point > 0:
+                self.l_buffer.point -= 1
+            self._vi_current = None
+        else:
+            self.vi_error ()
+            return
+
+    def vi_arrow_up (self, e):
+        self.vi_set_insert_mode (True)
+        self.vi_up (e)
+        self.vi_save_line ()
+
+    def vi_arrow_down (self, e):
+        self.vi_set_insert_mode (True)
+        self.vi_down (e)
+        self.vi_save_line ()
+
+    def vi_complete (self, e):
+        text = self.l_buffer.get_line_text ()
+        if text and not text.isspace ():
+            return self.complete (e)
+        else:
+            return self.vi_key (e)
+
+# vi input states
+# sequence of possible states are in the order below
+_VI_BEGIN           = 'vi_begin'
+_VI_MULTI1          = 'vi_multi1'
+_VI_ACTION          = 'vi_action'
+_VI_MULTI2          = 'vi_multi2'
+_VI_MOTION          = 'vi_motion'
+_VI_MOTION_ARGUMENT = 'vi_motion_argument'
+_VI_REPLACE_ONE     = 'vi_replace_one'
+_VI_TEXT            = 'vi_text'
+_VI_SEARCH          = 'vi_search'
+_VI_END             = 'vi_end'
+
+# vi helper class
+class ViCommand:
+    def __init__ (self, readline):
+        self.readline = readline
+        self.lst_char = []
+        self.state = _VI_BEGIN
+        self.action = self.movement
+        self.motion = None
+        self.motion_argument = None
+        self.text = None
+        self.pos_motion = None
+        self.is_edit = False
+        self.is_overwrite = False
+        self.is_error = False
+        self.is_star = False
+        self.delete_left = 0
+        self.delete_right = 0
+        self.readline._vi_multiplier1 = ''
+        self.readline._vi_multiplier2 = ''
+        self.set_override_multiplier (0)
+        self.skip_multipler = False
+        self.dct_fcn = {
+            ord('$') : self.key_dollar,
+            ord('^') : self.key_hat,
+            ord(';') : self.key_semicolon,
+            ord(',') : self.key_comma,
+            ord('%') : self.key_percent,
+            ord('.') : self.key_dot,
+            ord('/') : self.key_slash,
+            ord('*') : self.key_star,
+            ord('|') : self.key_bar,
+            ord('~') : self.key_tilde,
+            8 : self.key_backspace,
+        }
+
+    def add_char (self, char):
+        self.lst_char.append (char)
+        if self.state == _VI_BEGIN and self.readline.vi_is_insert_mode:
+            self.readline.vi_save_line ()
+            self.state = _VI_TEXT
+        if self.state == _VI_SEARCH:
+            if char == '\x08':  # backspace
+                self.key_backspace (char)
+            else:
+                self.set_text (char)
+            return
+        if self.state == _VI_TEXT:
+            if char == '\x1b':  # escape
+                self.escape (char)
+            elif char == '\x09':  # tab
+                ts = self.readline.tabstop
+                ws = ' ' * (ts - (self.readline.l_buffer.point%ts))
+                self.set_text (ws)
+            elif char == '\x08':  # backspace
+                self.key_backspace (char)
+            else:
+                self.set_text (char)
+            return
+        if self.state == _VI_MOTION_ARGUMENT:
+            self.set_motion_argument (char)
+            return
+        if self.state == _VI_REPLACE_ONE:
+            self.replace_one (char)
+            return
+        try:
+            fcn_instance = self.dct_fcn [ord(char)]
+        except:
+            fcn_instance = getattr (self, 'key_%s' % char, None)
+        if fcn_instance:
+            fcn_instance (char)
+            return
+        if char.isdigit ():
+            self.key_digit (char)
+            return
+        # Here: could not process key
+        self.error ()
+
+    def set_text (self, text):
+        if self.text is None:
+            self.text = text
+        else:
+            self.text += text
+        self.set_buffer (text)
+
+    def set_buffer (self, text):
+        for char in text:
+            if not self.char_isprint (char):
+                continue
+#             self.readline.l_buffer.insert_text(char)
+#             continue
+#             #overwrite in l_buffer obj
+            if self.is_overwrite:
+                if self.readline.l_buffer.point < len (self.readline.l_buffer.line_buffer):
+                    # self.readline.l_buffer[self.l_buffer.point]=char
+                    self.readline.l_buffer.line_buffer [self.readline.l_buffer.point] = char
+                else:
+                    # self.readline.l_buffer.insert_text(char)
+                    self.readline.l_buffer.line_buffer.append (char)
+            else:
+                # self.readline.l_buffer.insert_text(char)
+                self.readline.l_buffer.line_buffer.insert (self.readline.l_buffer.point, char)
+            self.readline.l_buffer.point += 1
+
+    def replace_one (self, char):
+        if char == '\x1b':  # escape
+            self.end ()
+            return
+        self.is_edit = True
+        self.readline.vi_save_line ()
+        times = self.get_multiplier ()
+        cursor = self.readline.l_buffer.point
+        self.readline.l_buffer.line_buffer [cursor : cursor + times] = char * times
+        if times > 1:
+            self.readline.l_buffer.point += (times - 1)
+        self.end ()
+
+    def char_isprint (self, char):
+        return ord(char) >= ord(' ') and ord(char) <= ord('~')
+
+    def key_dollar (self, char):
+        self.motion = self.motion_end_in_line
+        self.delete_right = 1
+        self.state = _VI_MOTION
+        self.apply ()
+
+    def key_hat (self, char):
+        self.motion = self.motion_beginning_of_line
+        self.state = _VI_MOTION
+        self.apply ()
+
+    def key_0 (self, char):
+        if self.state in [_VI_BEGIN, _VI_ACTION]:
+            self.key_hat (char)
+        else:
+            self.key_digit (char)
+
+    def key_digit (self, char):
+        if self.state in [_VI_BEGIN, _VI_MULTI1]:
+            self.readline._vi_multiplier1 += char
+            self.readline._vi_multiplier2 = ''
+            self.state = _VI_MULTI1
+        elif self.state in [_VI_ACTION, _VI_MULTI2]:
+            self.readline._vi_multiplier2 += char
+            self.state = _VI_MULTI2
+
+    def key_w (self, char):
+        if self.action == self.change:
+            self.key_e (char)
+            return
+        self.motion = self.motion_word_short
+        self.state = _VI_MOTION
+        self.apply ()
+
+    def key_W (self, char):
+        if self.action == self.change:
+            self.key_E (char)
+            return
+        self.motion = self.motion_word_long
+        self.state = _VI_MOTION
+        self.apply ()
+
+    def key_e (self, char):
+        self.motion = self.motion_end_short
+        self.state = _VI_MOTION
+        self.delete_right = 1
+        self.apply ()
+
+    def key_E (self, char):
+        self.motion = self.motion_end_long
+        self.state = _VI_MOTION
+        self.delete_right = 1
+        self.apply ()
+
+    def key_b (self, char):
+        self.motion = self.motion_back_short
+        self.state = _VI_MOTION
+        self.apply ()
+
+    def key_B (self, char):
+        self.motion = self.motion_back_long
+        self.state = _VI_MOTION
+        self.apply ()
+
+    def key_f (self, char):
+        self.readline._vi_key_find_direction = True
+        self.motion = self.motion_find_char_forward
+        self.delete_right = 1
+        self.state = _VI_MOTION_ARGUMENT
+
+    def key_F (self, char):
+        self.readline._vi_key_find_direction = False
+        self.motion = self.motion_find_char_backward
+        self.delete_left = 1
+        self.state = _VI_MOTION_ARGUMENT
+
+    def key_t (self, char):
+        self.motion = self.motion_to_char_forward
+        self.delete_right = 1
+        self.state = _VI_MOTION_ARGUMENT
+
+    def key_T (self, char):
+        self.motion = self.motion_to_char_backward
+        self.state = _VI_MOTION_ARGUMENT
+
+    def key_j (self, char):
+        self.readline.vi_down (ViEvent (char))
+        self.state = _VI_END
+
+    def key_k (self, char):
+        self.readline.vi_up (ViEvent (char))
+        self.state = _VI_END
+
+    def key_semicolon (self, char):
+        if self.readline._vi_key_find_char is None:
+            self.error ()
+            return
+        if self.readline._vi_key_find_direction:
+            self.motion = self.motion_find_char_forward
+        else:
+            self.motion = self.motion_find_char_backward
+        self.set_motion_argument (self.readline._vi_key_find_char)
+
+    def key_comma (self, char):
+        if self.readline._vi_key_find_char is None:
+            self.error ()
+            return
+        if self.readline._vi_key_find_direction:
+            self.motion = self.motion_find_char_backward
+        else:
+            self.motion = self.motion_find_char_forward
+        self.set_motion_argument (self.readline._vi_key_find_char)
+
+    def key_percent (self, char):
+        '''find matching <([{}])>'''
+        self.motion = self.motion_matching
+        self.delete_right = 1
+        self.state = _VI_MOTION
+        self.apply ()
+
+    def key_dot (self, char):
+        vi_cmd_edit = self.readline._vi_command_edit
+        if not vi_cmd_edit:
+            return
+        if vi_cmd_edit.is_star:
+            self.key_star (char)
+            return
+        if self.has_multiplier ():
+            count = self.get_multiplier ()
+        else:
+            count = 0
+        # Create the ViCommand object after getting multipler from self
+        # Side effect of the ViCommand creation is resetting of global multipliers
+        vi_cmd = ViCommand (self.readline)
+        if count >= 1:
+            vi_cmd.set_override_multiplier (count)
+            vi_cmd_edit.set_override_multiplier (count)
+        elif vi_cmd_edit.override_multiplier:
+            vi_cmd.set_override_multiplier (vi_cmd_edit.override_multiplier)
+        for char in vi_cmd_edit.lst_char:
+            vi_cmd.add_char (char)
+        if vi_cmd_edit.is_overwrite and self.readline.l_buffer.point > 0:
+            self.readline.l_buffer.point -= 1
+        self.readline.vi_set_insert_mode (False)
+        self.end ()
+
+    def key_slash (self, char):
+        self.readline.vi_save_line ()
+        self.readline.l_buffer.line_buffer=['/']
+        self.readline.l_buffer.point= 1
+        self.state = _VI_SEARCH
+
+    def key_star (self, char):
+        self.is_star = True
+        self.is_edit = True
+        self.readline.vi_save_line ()
+        completions = self.readline._get_completions()
+        if completions:
+            text = ' '.join (completions) + ' '
+            self.readline.l_buffer.line_buffer [self.readline.begidx : self.readline.endidx + 1] = list (text)
+            prefix_len = self.readline.endidx - self.readline.begidx
+            self.readline.l_buffer.point += len(text) - prefix_len
+            self.readline.vi_set_insert_mode (True)
+        else:
+            self.error ()
+        self.state = _VI_TEXT
+
+    def key_bar (self, char):
+        self.motion = self.motion_column
+        self.state = _VI_MOTION
+        self.apply ()
+
+    def key_tilde (self, char):
+        self.is_edit = True
+        self.readline.vi_save_line ()
+        for i in range (self.get_multiplier()):
+            try:
+                c = self.readline.l_buffer.line_buffer [self.readline.l_buffer.point]
+                if c.isupper ():
+                    self.readline.l_buffer.line_buffer [self.readline.l_buffer.point] = c.lower()
+                elif c.islower ():
+                    self.readline.l_buffer.line_buffer [self.readline.l_buffer.point] = c.upper()
+                self.readline.l_buffer.point += 1
+            except IndexError:
+                break
+        self.end ()
+
+    def key_h (self, char):
+        self.motion = self.motion_left
+        self.state = _VI_MOTION
+        self.apply ()
+
+    def key_backspace (self, char):
+        if self.state in [_VI_TEXT, _VI_SEARCH]:
+            if self.text and len(self.text):
+                self.text = self.text [:-1]
+                try:
+                    # Remove backspaces for potential dot command
+                    self.lst_char.pop ()
+                    self.lst_char.pop ()
+                except IndexError:
+                    pass
+        else:
+            self.key_h (char)
+        self.readline._vi_do_backspace (self)
+        if self.state == _VI_SEARCH and not (self.readline.l_buffer.line_buffer):
+            self.state = _VI_BEGIN
+
+    def key_l (self, char):
+        self.motion = self.motion_right
+        self.state = _VI_MOTION
+        self.apply ()
+
+    def key_i (self, char):
+        self.is_edit = True
+        self.state = _VI_TEXT
+        self.readline.vi_set_insert_mode (True)
+
+    def key_I (self, char):
+        self.is_edit = True
+        self.state = _VI_TEXT
+        self.readline.vi_set_insert_mode (True)
+        self.readline.l_buffer.point = 0
+
+    def key_a (self, char):
+        self.is_edit = True
+        self.state = _VI_TEXT
+        self.readline.vi_set_insert_mode (True)
+        if len (self.readline.l_buffer.line_buffer):
+            self.readline.l_buffer.point += 1
+
+    def key_A (self, char):
+        self.is_edit = True
+        self.state = _VI_TEXT
+        self.readline.vi_set_insert_mode (True)
+        self.readline.l_buffer.point = len (self.readline.l_buffer.line_buffer)
+
+    def key_d (self, char):
+        self.is_edit = True
+        self.state = _VI_ACTION
+        self.action = self.delete
+
+    def key_D (self, char):
+        self.is_edit = True
+        self.state = _VI_ACTION
+        self.action = self.delete_end_of_line
+        self.apply ()
+
+    def key_x (self, char):
+        self.is_edit = True
+        self.state = _VI_ACTION
+        self.action = self.delete_char
+        self.apply ()
+
+    def key_X (self, char):
+        self.is_edit = True
+        self.state = _VI_ACTION
+        self.action = self.delete_prev_char
+        self.apply ()
+
+    def key_s (self, char):
+        self.is_edit = True
+        i1 = self.readline.l_buffer.point
+        i2 = self.readline.l_buffer.point + self.get_multiplier ()
+        self.skip_multipler = True
+        self.readline.vi_set_insert_mode (True)
+        del self.readline.l_buffer.line_buffer [i1 : i2]
+        self.state = _VI_TEXT
+
+    def key_S (self, char):
+        self.is_edit = True
+        self.readline.vi_set_insert_mode (True)
+        self.readline.l_buffer.line_buffer = []
+        self.readline.l_buffer.point = 0
+        self.state = _VI_TEXT
+
+    def key_c (self, char):
+        self.is_edit = True
+        self.state = _VI_ACTION
+        self.action = self.change
+
+    def key_C (self, char):
+        self.is_edit = True
+        self.readline.vi_set_insert_mode (True)
+        del self.readline.l_buffer.line_buffer [self.readline.l_buffer.point : ]
+        self.state = _VI_TEXT
+
+    def key_r (self, char):
+        self.state = _VI_REPLACE_ONE
+
+    def key_R (self, char):
+        self.is_edit = True
+        self.is_overwrite = True
+        self.readline.l_buffer.overwrite=True
+        self.readline.vi_set_insert_mode (True)
+        self.state = _VI_TEXT
+
+    def key_y (self, char):
+        self._state = _VI_ACTION
+        self.action = self.yank
+
+    def key_Y (self, char):
+        self.readline._vi_yank_buffer = self.readline.l_buffer.get_line_text()
+        self.end ()
+
+    def key_p (self, char):
+        if not self.readline._vi_yank_buffer:
+            return
+        self.is_edit = True
+        self.readline.vi_save_line ()
+        self.readline.l_buffer.point += 1
+        self.readline.l_buffer.insert_text (self.readline._vi_yank_buffer * self.get_multiplier ())
+        self.readline.l_buffer.point -= 1
+        self.state = _VI_END
+
+    def key_P (self, char):
+        if not self.readline._vi_yank_buffer:
+            return
+        self.is_edit = True
+        self.readline.vi_save_line ()
+        self.readline.l_buffer.insert_text (self.readline._vi_yank_buffer * self.get_multiplier ())
+        self.readline.l_buffer.point -= 1
+        self.state = _VI_END
+
+    def key_u (self, char):
+        self.readline.vi_undo ()
+        self.state = _VI_END
+
+    def key_U (self, char):
+        self.readline.vi_undo_all ()
+        self.state = _VI_END
+
+    def key_v (self, char):
+        editor = ViExternalEditor (self.readline.l_buffer.line_buffer)
+        self.readline.l_buffer.line_buffer = list (editor.result)
+        self.readline.l_buffer.point = 0
+        self.is_edit = True
+        self.state = _VI_END
+
+    def error (self):
+        self.readline._bell ()
+        self.is_error = True
+
+    def state_is_end (self):
+        return self.state == _VI_END
+    is_end = property (state_is_end)
+
+    def state_is_search (self):
+        return self.state == _VI_SEARCH
+    is_search = property (state_is_search)
+
+    def state_is_replace_one (self):
+        return self.state == _VI_REPLACE_ONE
+    is_replace_one = property (state_is_replace_one)
+
+    def do_search (self):
+        self.readline.vi_search_first ()
+        self.state = _VI_END
+
+    def key_n (self, char):
+        self.readline.vi_search_again_backward ()
+        self.state = _VI_END
+
+    def key_N (self, char):
+        self.readline.vi_search_again_forward ()
+        self.state = _VI_END
+
+    def motion_beginning_of_line (self, line, index=0, count=1, **kw):
+        return 0
+
+    def motion_end_in_line (self, line, index=0, count=1, **kw):
+        return max (0, len (self.readline.l_buffer.line_buffer)-1)
+
+    def motion_word_short (self, line, index=0, count=1, **kw):
+        return vi_pos_word_short (line, index, count)
+
+    def motion_word_long (self, line, index=0, count=1, **kw):
+        return vi_pos_word_long (line, index, count)
+
+    def motion_end_short (self, line, index=0, count=1, **kw):
+        return vi_pos_end_short (line, index, count)
+
+    def motion_end_long (self, line, index=0, count=1, **kw):
+        return vi_pos_end_long (line, index, count)
+
+    def motion_back_short (self, line, index=0, count=1, **kw):
+        return vi_pos_back_short (line, index, count)
+
+    def motion_back_long (self, line, index=0, count=1, **kw):
+        return vi_pos_back_long (line, index, count)
+
+    def motion_find_char_forward (self, line, index=0, count=1, char=None):
+        self.readline._vi_key_find_char = char
+        return vi_pos_find_char_forward (line, char, index, count)
+
+    def motion_find_char_backward (self, line, index=0, count=1, char=None):
+        self.readline._vi_key_find_char = char
+        return vi_pos_find_char_backward (line, char, index, count)
+
+    def motion_to_char_forward  (self, line, index=0, count=1, char=None):
+        return vi_pos_to_char_forward (line, char, index, count)
+
+    def motion_to_char_backward  (self, line, index=0, count=1, char=None):
+        return vi_pos_to_char_backward (line, char, index, count)
+
+    def motion_left (self, line, index=0, count=1, char=None):
+        return max (0, index - count)
+
+    def motion_right (self, line, index=0, count=1, char=None):
+        return min (len(line), index + count)
+
+    def motion_matching (self, line, index=0, count=1, char=None):
+        return vi_pos_matching (line, index)
+
+    def motion_column (self, line, index=0, count=1, char=None):
+        return max (0, count-1)
+
+    def has_multiplier (self):
+        return self.override_multiplier or self.readline._vi_multiplier1 or self.readline._vi_multiplier2
+
+    def get_multiplier (self):
+        if self.override_multiplier:
+            return int (self.override_multiplier)
+        if self.readline._vi_multiplier1 == '': m1 = 1
+        else: m1 = int(self.readline._vi_multiplier1)
+        if self.readline._vi_multiplier2 == '': m2 = 1
+        else: m2 = int(self.readline._vi_multiplier2)
+        return m1 * m2
+
+    def set_override_multiplier (self, count):
+        self.override_multiplier = count
+
+    def apply (self):
+        if self.motion:
+            self.pos_motion = self.motion (self.readline.l_buffer.line_buffer, self.readline.l_buffer.point,
+                    self.get_multiplier(), char=self.motion_argument)
+            if self.pos_motion < 0:
+                self.error ()
+                return
+        self.action ()
+        if self.state != _VI_TEXT:
+            self.end ()
+
+    def movement (self):
+        if self.pos_motion <= len(self.readline.l_buffer.line_buffer):
+            self.readline.l_buffer.point = self.pos_motion
+        else:
+            self.readline.l_buffer.point = len(self.readline.l_buffer.line_buffer) - 1
+
+    def yank (self):
+        if self.pos_motion > self.readline.l_buffer.point:
+            s = self.readline.l_buffer.line_buffer [self.readline.l_buffer.point : self.pos_motion + self.delete_right]
+        else:
+            index = max (0, self.pos_motion - self.delete_left)
+            s = self.readline.l_buffer.line_buffer [index : self.readline.l_buffer.point + self.delete_right]
+        self.readline._vi_yank_buffer = s
+
+    def delete (self):
+        self.readline.vi_save_line ()
+        self.yank ()
+#         point=lineobj.Point(self.readline.l_buffer)
+#         pm=self.pos_motion
+#         del self.readline.l_buffer[point:pm]
+#         return
+        if self.pos_motion > self.readline.l_buffer.point:
+            del self.readline.l_buffer.line_buffer [self.readline.l_buffer.point : self.pos_motion + self.delete_right]
+            if self.readline.l_buffer.point > len (self.readline.l_buffer.line_buffer):
+                self.readline.l_buffer.point = len (self.readline.l_buffer.line_buffer)
+        else:
+            index = max (0, self.pos_motion - self.delete_left)
+            del self.readline.l_buffer.line_buffer [index : self.readline.l_buffer.point + self.delete_right]
+            self.readline.l_buffer.point = index
+
+    def delete_end_of_line (self):
+        self.readline.vi_save_line ()
+        # del self.readline.l_buffer [self.readline.l_buffer.point : ]
+        line_text = self.readline.l_buffer.get_line_text ()
+        line_text = line_text [ : self.readline.l_buffer.point]
+        self.readline.l_buffer.set_line (line_text)
+        if self.readline.l_buffer.point > 0:
+            self.readline.l_buffer.point -= 1
+
+    def delete_char (self):
+#         point=lineobj.Point(self.readline.l_buffer)
+#         del self.readline.l_buffer[point:point+self.get_multiplier ()]
+#         return
+        self.pos_motion = self.readline.l_buffer.point + self.get_multiplier ()
+        self.delete ()
+        end = max (0, len (self.readline.l_buffer) - 1)
+        if self.readline.l_buffer.point > end:
+            self.readline.l_buffer.point = end
+
+    def delete_prev_char (self):
+        self.pos_motion = self.readline.l_buffer.point - self.get_multiplier ()
+        self.delete ()
+
+    def change (self):
+        self.readline.vi_set_insert_mode (True)
+        self.delete ()
+        self.skip_multipler = True
+        self.state = _VI_TEXT
+
+    def escape (self, char):
+        if self.state == _VI_TEXT:
+            if not self.skip_multipler:
+                times = self.get_multiplier ()
+                if times > 1 and self.text:
+                    extra = self.text * (times - 1)
+                    self.set_buffer (extra)
+        self.state = _VI_END
+
+    def set_motion_argument (self, char):
+        self.motion_argument = char
+        self.apply ()
+
+    def end (self):
+        self.state = _VI_END
+        if self.readline.l_buffer.point >= len(self.readline.l_buffer.line_buffer):
+            self.readline.l_buffer.point = max (0, len(self.readline.l_buffer.line_buffer) - 1)
+
+class ViExternalEditor:
+    def __init__ (self, line):
+        if type(line) is type([]):
+            line = ''.join (line)
+        file_tmp = self.get_tempfile ()
+        fp_tmp = self.file_open (file_tmp, 'w')
+        fp_tmp.write (line)
+        fp_tmp.close ()
+        self.run_editor (file_tmp)
+        fp_tmp = self.file_open (file_tmp, 'r')
+        self.result = fp_tmp.read ()
+        fp_tmp.close ()
+        self.file_remove (file_tmp)
+
+    def get_tempfile (self):
+        import tempfile
+        return tempfile.mktemp (prefix='readline-', suffix='.py')
+
+    def file_open (self, filename, mode):
+        return file (filename, mode)
+
+    def file_remove (self, filename):
+        os.remove (filename)
+
+    def get_editor (self):
+        try:
+            return os.environ ['EDITOR']
+        except KeyError:
+            return 'notepad'  # ouch
+
+    def run_editor (self, filename):
+        cmd = '%s %s' % (self.get_editor(), filename, )
+        self.run_command (cmd)
+
+    def run_command (self, command):
+        os.system (command)
+
+class ViEvent:
+    def __init__ (self, char):
+        self.char = char
+
+# vi standalone functions
+def vi_is_word (char):
+    log ('xx vi_is_word: type(%s), %s' % (type(char), char, ))
+    return char.isalpha() or char.isdigit() or char == '_'
+
+def vi_is_space (char):
+    return char.isspace ()
+
+def vi_is_word_or_space (char):
+    return vi_is_word (char) or vi_is_space (char)
+
+def vi_pos_word_short (line, index=0, count=1):
+    try:
+        for i in range(count):
+            in_word = vi_is_word (line[index])
+            if not in_word:
+                while not vi_is_word (line[index]):
+                    index += 1
+            else:
+                while vi_is_word (line[index]):
+                    index += 1
+            while vi_is_space (line[index]):
+                index += 1
+        return index
+    except IndexError:
+        return len(line)
+
+def vi_pos_word_long (line, index=0, count=1):
+    try:
+        for i in range(count):
+            in_space = vi_is_space (line[index])
+            if not in_space:
+                while not vi_is_space (line[index]):
+                    index += 1
+            while vi_is_space (line[index]):
+                index += 1
+        return index
+    except IndexError:
+        return len(line)
+
+def vi_pos_end_short (line, index=0, count=1):
+    try:
+        for i in range(count):
+            index += 1
+            while vi_is_space (line[index]):
+                index += 1
+            in_word = vi_is_word (line[index])
+            if not in_word:
+                while not vi_is_word_or_space (line[index]):
+                    index += 1
+            else:
+                while vi_is_word (line[index]):
+                    index += 1
+        return index - 1
+    except IndexError:
+        return max (0, len(line)-1)
+
+def vi_pos_end_long (line, index=0, count=1):
+    try:
+        for i in range(count):
+            index += 1
+            while vi_is_space (line[index]):
+                index += 1
+            while not vi_is_space (line[index]):
+                index += 1
+        return index - 1
+    except IndexError:
+        return max (0, len(line)-1)
+
+class vi_list (list):
+    '''This is a list that cannot have a negative index'''
+    def __getitem__ (self, key):
+        try:
+            if int(key) < 0:
+                raise IndexError
+        except ValueError:
+            pass
+        return list.__getitem__ (self, key)
+
+def vi_pos_back_short (line, index=0, count=1):
+    line = vi_list (line)
+    try:
+        for i in range(count):
+            index -= 1
+            while vi_is_space (line[index]):
+                index -= 1
+            in_word = vi_is_word (line[index])
+            if in_word:
+                while vi_is_word (line[index]):
+                    index -= 1
+            else:
+                while not vi_is_word_or_space (line[index]):
+                    index -= 1
+        return index + 1
+    except IndexError:
+        return 0
+
+def vi_pos_back_long (line, index=0, count=1):
+    line = vi_list (line)
+    try:
+        for i in range(count):
+            index -= 1
+            while vi_is_space (line[index]):
+                index -= 1
+            while not vi_is_space (line[index]):
+                index -= 1
+        return index + 1
+    except IndexError:
+        return 0
+
+def vi_pos_find_char_forward (line, char, index=0, count=1):
+    try:
+        for i in range(count):
+            index += 1
+            while line [index] != char:
+                index += 1
+        return index
+    except IndexError:
+        return -1
+
+def vi_pos_find_char_backward (line, char, index=0, count=1):
+    try:
+        for i in range(count):
+            index -= 1
+            while 1:
+                if index < 0:
+                    return -1
+                if line[index] == char:
+                    break
+                index -= 1
+        return index
+    except IndexError:
+        return -1
+
+def vi_pos_to_char_forward (line, char, index=0, count=1):
+    index = vi_pos_find_char_forward (line, char, index, count)
+    if index > 0:
+        return index - 1
+    return index
+
+def vi_pos_to_char_backward (line, char, index=0, count=1):
+    index = vi_pos_find_char_backward (line, char, index, count)
+    if index >= 0:
+        return index + 1
+    return index
+
+_vi_dct_matching = {
+    '<': ('>', +1), '>': ('<', -1),
+    '(': (')', +1), ')': ('(', -1),
+    '[': (']', +1), ']': ('[', -1),
+    '{': ('}', +1), '}': ('{', -1),
+}
+
+def vi_pos_matching (line, index=0):
+    '''find matching <([{}])>'''
+    anchor = None
+    target = None
+    delta = 1
+    count = 0
+    try:
+        while 1:
+            if anchor is None:
+                # first find anchor
+                try:
+                    target, delta = _vi_dct_matching [line [index]]
+                    anchor = line [index]
+                    count = 1
+                except KeyError:
+                    index += 1
+                    continue
+            else:
+                # Here the anchor has been found
+                # Need to get corresponding target
+                if index < 0:
+                    return -1
+                if line [index] == anchor:
+                    count += 1
+                elif line [index] == target:
+                    count -= 1
+                    if count == 0:
+                        return index
+            index += delta
+    except IndexError:
+        return -1
+
diff --git a/windows/fuzzbunch/pyreadline/release.py b/windows/fuzzbunch/pyreadline/release.py
new file mode 100644
index 0000000..d1bc3ed
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/release.py
@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+"""Release data for the pyreadline project.
+
+$Id: release.py 2411 2007-05-29 21:14:28Z jstenar $"""
+
+#*****************************************************************************
+#       Copyright (C) 2006  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+# Name of the package for release purposes.  This is the name which labels
+# the tarballs and RPMs made by distutils, so it's best to lowercase it.
+name = 'pyreadline'
+
+# For versions with substrings (like 0.6.16.svn), use an extra . to separate
+# the new substring.  We have to avoid using either dashes or underscores,
+# because bdist_rpm does not accept dashes (an RPM) convention, and
+# bdist_deb does not accept underscores (a Debian convention).
+
+branch = ''
+
+version = '1.4.4'
+
+revision = '$Revision: 2411 $'
+
+description = "A python implmementation of GNU readline."
+
+long_description = \
+"""
+The pyreadline package is a python implementation of GNU readline functionality
+it is based on the ctypes based UNC readline package by Gary Bishop. 
+It is not complete. It has been tested for use with windows 2000 and windows xp.
+
+Features:
+ *  NEW: keyboard text selection and copy/paste
+ *  Shift-arrowkeys for text selection
+ *  Control-c can be used for copy activate with allow_ctrl_c(True) is config file
+ *  Double tapping ctrl-c will raise a KeyboardInterrupt, use ctrl_c_tap_time_interval(x)
+    where x is your preferred tap time window, default 0.3 s.
+ *  paste pastes first line of content on clipboard. 
+ *  ipython_paste, pastes tab-separated data as list of lists or numpy array if all data is numeric
+ *  paste_mulitline_code  pastes multi line code, removing any empty lines.
+ *  Experimental support for ironpython. At this time Ironpython has to be patched for it to work.
+ 
+ 
+ The latest development version is always available at the IPython subversion
+ repository_.
+
+.. _repository: http://ipython.scipy.org/svn/ipython/pyreadline/trunk#egg=pyreadline-dev
+ """
+
+license = 'BSD'
+
+authors = {'Jorgen' : ('Jorgen Stenarson','jorgen.stenarson@bostream.nu'),
+           'Gary':    ('Gary Bishop', ''),         
+           'Jack':    ('Jack Trainor', ''),         
+           }
+
+url = 'http://ipython.scipy.org/moin/PyReadline/Intro'
+
+download_url = ''
+
+platforms = ['Windows XP/2000/NT','Windows 95/98/ME']
+
+keywords = ['readline','pyreadline']
+
+classifiers = ['Development Status :: 4 - Beta',
+               'Environment :: Console',
+               'Operating System :: Microsoft :: Windows',]
+               
+               
diff --git a/windows/fuzzbunch/pyreadline/rlmain.py b/windows/fuzzbunch/pyreadline/rlmain.py
new file mode 100644
index 0000000..88bf5fe
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/rlmain.py
@@ -0,0 +1,460 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+''' an attempt to implement readline for Python in Python using ctypes'''
+import sys,os,re
+from glob import glob
+
+import clipboard,logger,console
+from   logger import log,log_sock
+from error import ReadlineError,GetSetError
+from   pyreadline.keysyms.common import make_KeyPress_from_keydescr
+
+import pyreadline.lineeditor.lineobj as lineobj
+import pyreadline.lineeditor.history as history
+import release
+
+from modes import editingmodes
+
+in_ironpython="IronPython" in sys.version
+if in_ironpython:#ironpython does not provide a prompt string to readline
+    import System    
+    default_prompt=">>> "
+else:
+    default_prompt=""
+    import pdb
+
+
+def quote_char(c):
+    if ord(c)>0:
+        return c
+
+def inword(buffer,point):
+    return buffer[point:point+1] in [A-Za-z0-9]
+
+
+class Readline(object):
+    def __init__(self):
+        self.startup_hook = None
+        self.pre_input_hook = None
+        self.completer = None
+        self.completer_delims = " \t\n\"\\'`@$><=;|&{("
+        self.console = console.Console()
+        self.size = self.console.size()
+        self.prompt_color = None
+        self.command_color = None
+        self.selection_color = self.console.saveattr<<4
+        self.key_dispatch = {}
+        self.previous_func = None
+        self.first_prompt = True
+        self.next_meta = False # True to force meta on next character
+        self.tabstop = 4
+        self.allow_ctrl_c=False
+        self.ctrl_c_tap_time_interval=0.3
+
+        self.begidx = 0
+        self.endidx = 0
+
+        # variables you can control with parse_and_bind
+        self.show_all_if_ambiguous = 'off'
+        self.mark_directories = 'on'
+        self.bell_style = 'none'
+        self.mark=-1
+        self.l_buffer=lineobj.ReadLineTextBuffer("")
+        self._history=history.LineHistory()
+
+        # this code needs to follow l_buffer and history creation
+        self.editingmodes=[mode(self) for mode in editingmodes]
+        for mode in self.editingmodes:
+            mode.init_editing_mode(None)
+        self.mode=self.editingmodes[0]
+
+        self.read_inputrc()
+        log("\n".join(self.rl_settings_to_string()))
+
+        #Paste settings    
+        #assumes data on clipboard is path if shorter than 300 characters and doesn't contain \t or \n
+        #and replace \ with / for easier use in ipython
+        self.enable_ipython_paste_for_paths=True
+
+        #automatically convert tabseparated data to list of lists or array constructors
+        self.enable_ipython_paste_list_of_lists=True
+        self.enable_win32_clipboard=True
+
+        self.paste_line_buffer=[]
+
+    #Below is for refactoring, raise errors when using old style attributes 
+    #that should be refactored out
+    def _g(x):
+        def g(self):
+            raise GetSetError("GET %s"%x)
+        def s(self,q):
+            raise GetSetError("SET %s"%x)
+        return g,s
+    line_buffer=property(*_g("line_buffer"))
+    line_cursor=property(*_g("line_buffer"))
+    undo_stack =property(*_g("undo_stack")) # each entry is a tuple with cursor_position and line_text
+    history_length =property(*_g("history_length")) # each entry is a tuple with cursor_position and line_text
+    history =property(*_g("history")) # each entry is a tuple with cursor_position and line_text
+    history_cursor =property(*_g("history_cursor")) # each entry is a tuple with cursor_position and line_text
+
+
+#  To export as readline interface
+
+    def parse_and_bind(self, string):
+        '''Parse and execute single line of a readline init file.'''
+        try:
+            log('parse_and_bind("%s")' % string)
+            if string.startswith('#'):
+                return
+            if string.startswith('set'):
+                m = re.compile(r'set\s+([-a-zA-Z0-9]+)\s+(.+)\s*$').match(string)
+                if m:
+                    var_name = m.group(1)
+                    val = m.group(2)
+                    try:
+                        setattr(self, var_name.replace('-','_'), val)
+                    except AttributeError:
+                        log('unknown var="%s" val="%s"' % (var_name, val))
+                else:
+                    log('bad set "%s"' % string)
+                return
+            m = re.compile(r'\s*(.+)\s*:\s*([-a-zA-Z]+)\s*$').match(string)
+            if m:
+                key = m.group(1)
+                func_name = m.group(2)
+                py_name = func_name.replace('-', '_')
+                try:
+                    func = getattr(self.mode, py_name)
+                except AttributeError:
+                    log('unknown func key="%s" func="%s"' % (key, func_name))
+                    print 'unknown function to bind: "%s"' % func_name
+                self.mode._bind_key(key, func)
+        except:
+            log('error')
+            raise
+
+    def get_line_buffer(self):
+        '''Return the current contents of the line buffer.'''
+        return self.l_buffer.get_line_text()
+
+    def insert_text(self, string):
+        '''Insert text into the command line.'''
+        self.l_buffer.insert_text(string)
+        
+    def read_init_file(self, filename=None): 
+        '''Parse a readline initialization file. The default filename is the last filename used.'''
+        log('read_init_file("%s")' % filename)
+
+    #History file book keeping methods (non-bindable)
+    
+    def add_history(self, line):
+        '''Append a line to the history buffer, as if it was the last line typed.'''
+        self._history.add_history(line)
+
+    def get_history_length(self ):
+        '''Return the desired length of the history file.
+
+        Negative values imply unlimited history file size.'''
+        return self._history.get_history_length()
+
+    def set_history_length(self, length): 
+        '''Set the number of lines to save in the history file.
+
+        write_history_file() uses this value to truncate the history file
+        when saving. Negative values imply unlimited history file size.
+        '''
+        self._history.set_history_length(length)
+
+    def clear_history(self):
+        '''Clear readline history'''
+        self._history.clear_history()
+
+    def read_history_file(self, filename=None): 
+        '''Load a readline history file. The default filename is ~/.history.'''
+        self._history.read_history_file(filename)
+
+    def write_history_file(self, filename=None): 
+        '''Save a readline history file. The default filename is ~/.history.'''
+        self._history.write_history_file(filename)
+
+    #Completer functions
+
+    def set_completer(self, function=None): 
+        '''Set or remove the completer function.
+
+        If function is specified, it will be used as the new completer
+        function; if omitted or None, any completer function already
+        installed is removed. The completer function is called as
+        function(text, state), for state in 0, 1, 2, ..., until it returns a
+        non-string value. It should return the next possible completion
+        starting with text.
+        '''
+        log('set_completer')
+        self.completer = function
+
+    def get_completer(self): 
+        '''Get the completer function. 
+        ''' 
+
+        log('get_completer') 
+        return self.completer 
+
+    def get_begidx(self):
+        '''Get the beginning index of the readline tab-completion scope.'''
+        return self.begidx
+
+    def get_endidx(self):
+        '''Get the ending index of the readline tab-completion scope.'''
+        return self.endidx
+
+    def set_completer_delims(self, string):
+        '''Set the readline word delimiters for tab-completion.'''
+        self.completer_delims = string
+
+    def get_completer_delims(self):
+        '''Get the readline word delimiters for tab-completion.'''
+        return self.completer_delims
+
+    def set_startup_hook(self, function=None): 
+        '''Set or remove the startup_hook function.
+
+        If function is specified, it will be used as the new startup_hook
+        function; if omitted or None, any hook function already installed is
+        removed. The startup_hook function is called with no arguments just
+        before readline prints the first prompt.
+
+        '''
+        self.startup_hook = function
+
+    def set_pre_input_hook(self, function=None):
+        '''Set or remove the pre_input_hook function.
+
+        If function is specified, it will be used as the new pre_input_hook
+        function; if omitted or None, any hook function already installed is
+        removed. The pre_input_hook function is called with no arguments
+        after the first prompt has been printed and just before readline
+        starts reading input characters.
+
+        '''
+        self.pre_input_hook = function
+
+##  Internal functions
+
+    def rl_settings_to_string(self):
+        out=["%-20s: %s"%("show all if ambigous",self.show_all_if_ambiguous)]
+        out.append("%-20s: %s"%("mark_directories",self.mark_directories))
+        out.append("%-20s: %s"%("bell_style",self.bell_style))
+        out.append("%-20s: %s"%("mark_directories",self.mark_directories))
+        out.append("------------- key bindings ------------")
+        tablepat="%-7s %-7s %-7s %-15s %-15s "
+        out.append(tablepat%("Control","Meta","Shift","Keycode/char","Function"))
+        bindings=[(k[0],k[1],k[2],k[3],v.__name__) for k,v in self.mode.key_dispatch.iteritems()]
+        bindings.sort()
+        for key in bindings:
+            out.append(tablepat%(key))
+        return out
+    
+    def _bell(self):
+        '''ring the bell if requested.'''
+        if self.bell_style == 'none':
+            pass
+        elif self.bell_style == 'visible':
+            raise NotImplementedError("Bellstyle visible is not implemented yet.")
+        elif self.bell_style == 'audible':
+            self.console.bell()
+        else:
+            raise ReadlineError("Bellstyle %s unknown."%self.bell_style)
+
+    def _clear_after(self):
+        c = self.console
+        x, y = c.pos()
+        w, h = c.size()
+        c.rectangle((x, y, w+1, y+1))
+        c.rectangle((0, y+1, w, min(y+3,h)))
+
+    def _set_cursor(self):
+        c = self.console
+        xc, yc = self.prompt_end_pos
+        w, h = c.size()
+        xc += self.l_buffer.visible_line_width()
+        while(xc >= w):
+            xc -= w
+            yc += 1
+        c.pos(xc, yc)
+
+    def _print_prompt(self):
+        c = self.console
+        x, y = c.pos()
+        
+        n = c.write_scrolling(self.prompt, self.prompt_color)
+        self.prompt_begin_pos = (x, y - n)
+        self.prompt_end_pos = c.pos()
+        self.size = c.size()
+
+    def _update_prompt_pos(self, n):
+        if n != 0:
+            bx, by = self.prompt_begin_pos
+            ex, ey = self.prompt_end_pos
+            self.prompt_begin_pos = (bx, by - n)
+            self.prompt_end_pos = (ex, ey - n)
+
+    def _update_line(self):
+        c=self.console
+        c.pos(*self.prompt_end_pos)
+        ltext = self.l_buffer.quoted_text()
+        if self.l_buffer.enable_selection and self.l_buffer.selection_mark>=0:
+            start=len(self.l_buffer[:self.l_buffer.selection_mark].quoted_text())
+            stop=len(self.l_buffer[:self.l_buffer.point].quoted_text())
+            if start>stop:
+                stop,start=start,stop
+            n = c.write_scrolling(ltext[:start], self.command_color)
+            n = c.write_scrolling(ltext[start:stop], self.selection_color)
+            n = c.write_scrolling(ltext[stop:], self.command_color)
+        else:
+            n = c.write_scrolling(ltext, self.command_color)
+        self._update_prompt_pos(n)
+        if hasattr(c,"clear_to_end_of_window"): #Work around function for ironpython due 
+            c.clear_to_end_of_window()          #to System.Console's lack of FillFunction
+        else:
+            self._clear_after()
+        self._set_cursor()
+    
+    def readline(self, prompt=''):
+        return self.mode.readline(prompt)
+
+    def read_inputrc(self,inputrcpath=os.path.expanduser("~/pyreadlineconfig.ini")):
+        modes=dict([(x.mode,x) for x in self.editingmodes])
+        mode=self.editingmodes[0].mode
+        def setmode(name):
+            self.mode=modes[name]
+        def bind_key(key,name):
+            log("bind %s %s"%(key,name))
+            if hasattr(modes[mode],name):
+                modes[mode]._bind_key(key,getattr(modes[mode],name))
+            else:
+                print "Trying to bind unknown command '%s' to key '%s'"%(name,key)
+        def un_bind_key(key):
+            keyinfo = make_KeyPress_from_keydescr(key).tuple()
+            if keyinfo in modes[mode].key_dispatch:
+                del modes[mode].key_dispatch[keyinfo]
+
+        def bind_exit_key(key):
+            modes[mode]._bind_exit_key(key)
+        def un_bind_exit_key(key):
+            keyinfo = make_KeyPress_from_keydescr(key).tuple()
+            if keyinfo in modes[mode].exit_dispatch:
+                del modes[mode].exit_dispatch[keyinfo]
+
+        def sethistoryfilename(filename):
+            self._history.history_filename=os.path.expanduser(filename)
+        def setbellstyle(mode):
+            self.bell_style=mode
+        def sethistorylength(length):
+            self._history.history_length=int(length)
+        def allow_ctrl_c(mode):
+            log_sock("allow_ctrl_c:%s:%s"%(self.allow_ctrl_c,mode))
+            self.allow_ctrl_c=mode
+        def setbellstyle(mode):
+            self.bell_style=mode
+        def show_all_if_ambiguous(mode):
+            self.show_all_if_ambiguous=mode
+        def ctrl_c_tap_time_interval(mode):
+            self.ctrl_c_tap_time_interval=mode
+        def mark_directories(mode):
+            self.mark_directories=mode
+        def completer_delims(mode):
+            self.completer_delims=mode
+        def debug_output(on,filename="pyreadline_debug_log.txt"):  #Not implemented yet
+            logger.start_log(on,filename)
+            logger.log("STARTING LOG")
+#            print release.branch
+        def set_prompt_color(color):
+            trtable={"black":0,"darkred":4,"darkgreen":2,"darkyellow":6,"darkblue":1,"darkmagenta":5,"darkcyan":3,"gray":7,
+                     "red":4+8,"green":2+8,"yellow":6+8,"blue":1+8,"magenta":5+8,"cyan":3+8,"white":7+8}
+            self.prompt_color=trtable.get(color.lower(),7)            
+            
+        def set_input_color(color):
+            trtable={"black":0,"darkred":4,"darkgreen":2,"darkyellow":6,"darkblue":1,"darkmagenta":5,"darkcyan":3,"gray":7,
+                     "red":4+8,"green":2+8,"yellow":6+8,"blue":1+8,"magenta":5+8,"cyan":3+8,"white":7+8}
+            self.command_color=trtable.get(color.lower(),7)            
+        loc={"branch":release.branch,
+             "version":release.version,
+             "mode":mode,
+             "modes":modes,
+             "set_mode":setmode,
+             "bind_key":bind_key,
+             "bind_exit_key":bind_exit_key,
+             "un_bind_key":un_bind_key,
+             "un_bind_exit_key":un_bind_exit_key,
+             "bell_style":setbellstyle,
+             "mark_directories":mark_directories,
+             "show_all_if_ambiguous":show_all_if_ambiguous,
+             "completer_delims":completer_delims,
+             "debug_output":debug_output,
+             "history_filename":sethistoryfilename,
+             "history_length":sethistorylength,
+             "set_prompt_color":set_prompt_color,
+             "set_input_color":set_input_color,
+             "allow_ctrl_c":allow_ctrl_c,
+             "ctrl_c_tap_time_interval":ctrl_c_tap_time_interval,
+             }
+        if os.path.isfile(inputrcpath): 
+            try:
+                execfile(inputrcpath,loc,loc)
+            except Exception,x:
+                raise
+                import traceback
+                print >>sys.stderr, "Error reading .pyinputrc"
+                filepath,lineno=traceback.extract_tb(sys.exc_traceback)[1][:2]
+                print >>sys.stderr, "Line: %s in file %s"%(lineno,filepath)
+                print >>sys.stderr, x
+                raise ReadlineError("Error reading .pyinputrc")
+
+
+
+
+def CTRL(c):
+    '''make a control character'''
+    assert '@' <= c <= '_'
+    return chr(ord(c) - ord('@'))
+
+# create a Readline object to contain the state
+rl = Readline()
+
+
+def GetOutputFile():
+    '''Return the console object used by readline so that it can be used for printing in color.'''
+    return rl.console
+
+# make these available so this looks like the python readline module
+parse_and_bind = rl.parse_and_bind
+get_line_buffer = rl.get_line_buffer
+insert_text = rl.insert_text
+read_init_file = rl.read_init_file
+add_history = rl.add_history
+get_history_length = rl.get_history_length
+set_history_length = rl.set_history_length
+clear_history = rl.clear_history
+read_history_file = rl.read_history_file
+write_history_file = rl.write_history_file
+set_completer = rl.set_completer
+get_completer = rl.get_completer
+get_begidx = rl.get_begidx
+get_endidx = rl.get_endidx
+set_completer_delims = rl.set_completer_delims
+get_completer_delims = rl.get_completer_delims
+set_startup_hook = rl.set_startup_hook
+set_pre_input_hook = rl.set_pre_input_hook
+
+if __name__ == '__main__':
+    res = [ rl.readline('In[%d] ' % i) for i in range(3) ]
+    print res
+else:
+    console.install_readline(rl.readline)
+    pass
diff --git a/windows/fuzzbunch/pyreadline/test/common.py b/windows/fuzzbunch/pyreadline/test/common.py
new file mode 100644
index 0000000..a6d1496
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/test/common.py
@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2006  Michael Graz. <mgraz@plan10.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+from pyreadline.modes.emacs import *
+from pyreadline import keysyms
+from pyreadline.lineeditor import lineobj
+from pyreadline.keysyms.common import make_KeyPress_from_keydescr
+
+import unittest
+class MockReadline:
+    def __init__ (self):
+        self.l_buffer=lineobj.ReadLineTextBuffer("")
+        self._history=history.LineHistory()
+
+    def add_history (self, line):
+        self._history.add_history (lineobj.TextLine (line))
+
+    def _print_prompt (self):
+        pass
+
+    def _bell (self):
+        pass
+
+    def insert_text(self, string):
+        '''Insert text into the command line.'''
+        self.l_buffer.insert_text(string)
+
+
+class MockConsole:
+    def __init__ (self):
+        self.bell_count = 0
+        self.text = ''
+
+    def size (self):
+        return (1, 1)
+
+    def cursor(self, visible=None, size=None):
+        pass
+
+    def bell (self):
+        self.bell_count += 1
+
+    def write (self, text):
+        self.text += text
+
+
+
+
+class Event:
+    def __init__ (self, char):
+        if char=="escape":
+            self.char='\x1b'
+        elif char=="backspace":
+            self.char='\x08'
+        else:
+            self.char = char
+
+def keytext_to_keyinfo_and_event (keytext):
+    keyinfo = keysyms.common.make_KeyPress_from_keydescr (keytext)
+    if len(keytext) == 3 and keytext[0] == '"' and keytext[2] == '"':
+        event = Event (keytext[1])
+    else:
+        event = Event (keyinfo.tuple() [3])
+    return keyinfo, event
+
+
+
+#override runTests from from main in unittest to remove sys.exit call
+class Tester(unittest.TestProgram):
+    def runTests(self):
+        if self.testRunner is None:
+            self.testRunner = unittest.TextTestRunner(verbosity=self.verbosity)
+        result = self.testRunner.run(self.test)
+#       sys.exit(not result.wasSuccessful())
diff --git a/windows/fuzzbunch/pyreadline/test/emacs_test.py b/windows/fuzzbunch/pyreadline/test/emacs_test.py
new file mode 100644
index 0000000..a0b583d
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/test/emacs_test.py
@@ -0,0 +1,396 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2006  Michael Graz. <mgraz@plan10.com>
+#       Copyright (C) 2006  Michael Graz. <mgraz@plan10.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+import sys, unittest
+import pdb
+sys.path.append ('../..')
+from pyreadline.modes.emacs import *
+from pyreadline import keysyms
+from pyreadline.lineeditor import lineobj
+
+from common import *
+from pyreadline.logger import log_sock
+import pyreadline.logger as logger
+logger.sock_silent=True
+logger.show_event=["debug"]
+
+#----------------------------------------------------------------------
+
+
+class EmacsModeTest (EmacsMode):
+    tested_commands={}
+    def __init__ (self):
+        EmacsMode.__init__ (self, MockReadline())
+        self.mock_console = MockConsole ()
+        self.init_editing_mode (None)
+        self.lst_completions = []
+        self.completer = self.mock_completer
+        self.completer_delims = ' '
+        self.tabstop = 4
+        self.mark_directories=False
+        self.show_all_if_ambiguous=False
+        
+    def get_mock_console (self):
+        return self.mock_console
+    console = property (get_mock_console)
+
+    def _set_line (self, text):
+        self.l_buffer.set_line (text)
+
+    def get_line (self):
+        return self.l_buffer.get_line_text ()
+    line = property (get_line)
+
+    def get_line_cursor (self):
+        return self.l_buffer.point
+    line_cursor = property (get_line_cursor)
+
+    def input (self, keytext):
+        if keytext[0:1] == '"' and keytext[-1:] == '"':
+            lst_key = ['"%s"' % c for c in keytext[1:-1]]
+        else:
+            lst_key = [keytext]
+        for key in lst_key:
+            keyinfo, event = keytext_to_keyinfo_and_event (key)
+            dispatch_func = self.key_dispatch.get(keyinfo.tuple(),self.self_insert)
+            self.tested_commands[dispatch_func.__name__]=dispatch_func
+            log_sock("keydisp: %s %s"%( key,dispatch_func.__name__),"debug")
+            dispatch_func (event)
+            self.previous_func=dispatch_func
+
+    def accept_line (self, e):
+        if EmacsMode.accept_line (self, e):
+            # simulate return
+            # self.add_history (self.line)
+            self.l_buffer.reset_line ()
+
+    def mock_completer (self, text, state):
+        return self.lst_completions [state]
+
+#----------------------------------------------------------------------
+
+class TestsKeyinfo (unittest.TestCase):
+
+    def test_keyinfo (self):
+        keyinfo, event = keytext_to_keyinfo_and_event ('"d"')
+        self.assertEqual ('d', event.char)
+        keyinfo, event = keytext_to_keyinfo_and_event ('"D"')
+        self.assertEqual ('D', event.char)
+        keyinfo, event = keytext_to_keyinfo_and_event ('"$"')
+        self.assertEqual ('$', event.char)
+        keyinfo, event = keytext_to_keyinfo_and_event ('Escape')
+        self.assertEqual ('\x1b', event.char)
+
+
+class TestsMovement (unittest.TestCase):
+    def test_cursor (self):
+        r = EmacsModeTest ()
+        self.assertEqual (r.line, '')
+        r.input('"First Second Third"')
+        self.assertEqual (r.line, 'First Second Third')
+        self.assertEqual (r.line_cursor, 18)
+        r.input('Control-a')
+        self.assertEqual (r.line, 'First Second Third')
+        self.assertEqual (r.line_cursor, 0)
+        r.input('Control-e')
+        self.assertEqual (r.line, 'First Second Third')
+        self.assertEqual (r.line_cursor, 18)
+        r.input('Home')
+        self.assertEqual (r.line, 'First Second Third')
+        self.assertEqual (r.line_cursor, 0)
+        r.input('Right')
+        self.assertEqual (r.line, 'First Second Third')
+        self.assertEqual (r.line_cursor, 1)
+        r.input('Ctrl-f')
+        self.assertEqual (r.line, 'First Second Third')
+        self.assertEqual (r.line_cursor, 2)
+        r.input('Ctrl-Right')
+        self.assertEqual (r.line, 'First Second Third')
+        self.assertEqual (r.line_cursor, 5)
+        r.input('Ctrl-Right')
+        self.assertEqual (r.line, 'First Second Third')
+        self.assertEqual (r.line_cursor, 12)
+        r.input('Ctrl-Right')
+        self.assertEqual (r.line, 'First Second Third')
+        self.assertEqual (r.line_cursor, 18)
+        r.input('Ctrl-Right')
+        self.assertEqual (r.line, 'First Second Third')
+        self.assertEqual (r.line_cursor, 18)
+        r.input('Ctrl-Left')
+        self.assertEqual (r.line, 'First Second Third')
+        self.assertEqual (r.line_cursor, 13)
+        r.input('Ctrl-Left')
+        self.assertEqual (r.line, 'First Second Third')
+        self.assertEqual (r.line_cursor, 6)
+        r.input('Ctrl-Left')
+        self.assertEqual (r.line, 'First Second Third')
+        self.assertEqual (r.line_cursor, 0)
+        r.input('Ctrl-Left')
+        self.assertEqual (r.line, 'First Second Third')
+        self.assertEqual (r.line_cursor, 0)
+
+
+class TestsDelete (unittest.TestCase):
+    def test_delete (self):
+        r = EmacsModeTest ()
+        self.assertEqual (r.line, '')
+        r.input('"First Second Third"')
+        self.assertEqual (r.line, 'First Second Third')
+        self.assertEqual (r.line_cursor, 18)
+        r.input('Delete')
+        self.assertEqual (r.line, 'First Second Third')
+        self.assertEqual (r.line_cursor, 18)
+        r.input('Left')
+        r.input('Left')
+        r.input('Delete')
+        self.assertEqual (r.line, 'First Second Thid')
+        self.assertEqual (r.line_cursor, 16)
+        r.input('Delete')
+        self.assertEqual (r.line, 'First Second Thi')
+        self.assertEqual (r.line_cursor, 16)
+        r.input('Backspace')
+        self.assertEqual (r.line, 'First Second Th')
+        self.assertEqual (r.line_cursor, 15)
+        r.input('Home')
+        r.input('Right')
+        r.input('Right')
+        self.assertEqual (r.line, 'First Second Th')
+        self.assertEqual (r.line_cursor, 2)
+        r.input('Backspace')
+        self.assertEqual (r.line, 'Frst Second Th')
+        self.assertEqual (r.line_cursor, 1)
+        r.input('Backspace')
+        self.assertEqual (r.line, 'rst Second Th')
+        self.assertEqual (r.line_cursor, 0)
+        r.input('Backspace')
+        self.assertEqual (r.line, 'rst Second Th')
+        self.assertEqual (r.line_cursor, 0)
+        r.input('Escape')
+        self.assertEqual (r.line, '')
+        self.assertEqual (r.line_cursor, 0)
+        
+    def test_delete_word (self):
+        r = EmacsModeTest ()
+        self.assertEqual (r.line, '')
+        r.input('"First Second Third"')
+        self.assertEqual (r.line, 'First Second Third')
+        self.assertEqual (r.line_cursor, 18)
+        r.input('Control-Backspace')
+        self.assertEqual (r.line, 'First Second ')
+        self.assertEqual (r.line_cursor, 13)
+        r.input('Backspace')
+        r.input('Left')
+        r.input('Left')
+        self.assertEqual (r.line, 'First Second')
+        self.assertEqual (r.line_cursor, 10)
+        r.input('Control-Backspace')
+        self.assertEqual (r.line, 'First nd')
+        self.assertEqual (r.line_cursor, 6)
+        r.input('Escape')
+        self.assertEqual (r.line, '')
+        self.assertEqual (r.line_cursor, 0)
+        r.input('"First Second Third"')
+        r.input('Home')
+        r.input('Right')
+        r.input('Right')
+        r.input('Control-Delete')
+        self.assertEqual (r.line, 'FiSecond Third')
+        self.assertEqual (r.line_cursor, 2)
+        r.input('Control-Delete')
+        self.assertEqual (r.line, 'FiThird')
+        self.assertEqual (r.line_cursor, 2)
+        r.input('Control-Delete')
+        self.assertEqual (r.line, 'Fi')
+        self.assertEqual (r.line_cursor, 2)
+        r.input('Control-Delete')
+        self.assertEqual (r.line, 'Fi')
+        self.assertEqual (r.line_cursor, 2)
+        r.input('Escape')
+        self.assertEqual (r.line, '')
+        self.assertEqual (r.line_cursor, 0)
+
+
+
+class TestsSelectionMovement (unittest.TestCase):
+    def test_cursor (self):
+        r = EmacsModeTest ()
+        self.assertEqual (r.line, '')
+        r.input('"First Second Third"')
+        self.assertEqual (r.line, 'First Second Third')
+        self.assertEqual (r.line_cursor, 18)
+        self.assertEqual (r.l_buffer.selection_mark, -1)
+        r.input('Home')
+        r.input('Shift-Right')
+        self.assertEqual (r.line, 'First Second Third')
+        self.assertEqual (r.line_cursor, 1)
+        self.assertEqual (r.l_buffer.selection_mark, 0)
+        r.input('Shift-Control-Right')
+        self.assertEqual (r.line, 'First Second Third')
+        self.assertEqual (r.line_cursor, 5)
+        self.assertEqual (r.l_buffer.selection_mark, 0)
+        r.input('"a"')
+        self.assertEqual (r.line, 'a Second Third')
+        self.assertEqual (r.line_cursor, 1)
+        self.assertEqual (r.l_buffer.selection_mark, -1)
+        r.input('Shift-End')
+        self.assertEqual (r.line, 'a Second Third')
+        self.assertEqual (r.line_cursor, 14)
+        self.assertEqual (r.l_buffer.selection_mark, 1)
+        r.input('Delete')
+        self.assertEqual (r.line, 'a')
+        self.assertEqual (r.line_cursor, 1)
+        self.assertEqual (r.l_buffer.selection_mark, -1)
+
+
+
+class TestsHistory (unittest.TestCase):
+    def test_history_1 (self):
+        r = EmacsModeTest ()
+        r.add_history ('aa')
+        r.add_history ('bbb')
+        self.assertEqual (r.line, '')
+        r.input ('Up')
+        self.assertEqual (r.line, 'bbb')
+        self.assertEqual (r.line_cursor, 3)
+        r.input ('Up')
+        self.assertEqual (r.line, 'aa')
+        self.assertEqual (r.line_cursor, 2)
+        r.input ('Up')
+        self.assertEqual (r.line, 'aa')
+        self.assertEqual (r.line_cursor, 2)
+        r.input ('Down')
+        self.assertEqual (r.line, 'bbb')
+        self.assertEqual (r.line_cursor, 3)
+        r.input ('Down')
+        self.assertEqual (r.line, '')
+        self.assertEqual (r.line_cursor, 0)
+
+    def test_history_2 (self):
+        r = EmacsModeTest ()
+        r.add_history ('aaaa')
+        r.add_history ('aaba')
+        r.add_history ('aaca')
+        r.add_history ('akca')
+        r.add_history ('bbb')
+        r.add_history ('ako')
+        self.assert_line(r,'',0)
+        r.input ('"a"')
+        r.input ('Up')
+        self.assert_line(r,'ako',1)
+        r.input ('Up')
+        self.assert_line(r,'akca',1)
+        r.input ('Up')
+        self.assert_line(r,'aaca',1)
+        r.input ('Up')
+        self.assert_line(r,'aaba',1)
+        r.input ('Up')
+        self.assert_line(r,'aaaa',1)
+        r.input ('Right')
+        self.assert_line(r,'aaaa',2)
+        r.input ('Down')
+        self.assert_line(r,'aaba',2)
+        r.input ('Down')
+        self.assert_line(r,'aaca',2)
+        r.input ('Down')
+        self.assert_line(r,'aaca',2)
+        r.input ('Left')
+        r.input ('Left')
+        r.input ('Down')
+        r.input ('Down')
+        self.assert_line(r,'bbb',3)
+        r.input ('Left')
+        self.assert_line(r,'bbb',2)
+        r.input ('Down')
+        self.assert_line(r,'bbb',2)
+        r.input ('Up')
+        self.assert_line(r,'bbb',2)
+
+
+    def test_history_3 (self):
+        r = EmacsModeTest ()
+        r.add_history ('aaaa')
+        r.add_history ('aaba')
+        r.add_history ('aaca')
+        r.add_history ('akca')
+        r.add_history ('bbb')
+        r.add_history ('ako')
+        self.assert_line(r,'',0)
+        r.input ('')
+        r.input ('Up')
+        self.assert_line(r,'ako',3)
+        r.input ('Down')
+        self.assert_line(r,'',0)
+        r.input ('Up')
+        self.assert_line(r,'ako',3)
+
+    def test_history_3 (self):
+        r = EmacsModeTest ()
+        r.add_history ('aaaa')
+        r.add_history ('aaba')
+        r.add_history ('aaca')
+        r.add_history ('akca')
+        r.add_history ('bbb')
+        r.add_history ('ako')
+        self.assert_line(r,'',0)
+        r.input ('k')
+        r.input ('Up')
+        self.assert_line(r,'k',1)
+
+    def test_complete (self):
+        import rlcompleter
+        logger.sock_silent=False
+
+        log_sock("-"*50,"debug")
+        r=EmacsModeTest()
+        r.completer=rlcompleter.Completer().complete
+        r._bind_key("tab",r.complete)
+        r.input('"exi(ksdjksjd)"')
+        r.input('Control-a')
+        r.input('Right')
+        r.input('Right')
+        r.input('Right')
+        r.input('Tab')
+        self.assert_line(r,"exit(ksdjksjd)",4)
+
+        r.input('Escape')
+        r.input('"exi"')
+        r.input('Control-a')
+        r.input('Right')
+        r.input('Right')
+        r.input('Right')
+        r.input('Tab')
+        self.assert_line(r,"exit",4)
+
+        
+        
+    def assert_line(self,r,line,cursor):
+        self.assertEqual (r.line, line)
+        self.assertEqual (r.line_cursor, cursor)
+        
+#----------------------------------------------------------------------
+# utility functions
+
+#----------------------------------------------------------------------
+
+if __name__ == '__main__':
+    Tester()
+    tested=EmacsModeTest.tested_commands.keys()    
+    tested.sort()
+#    print " Tested functions ".center(60,"-")
+#    print "\n".join(tested)
+#    print
+    
+    all_funcs=dict([(x.__name__,x) for x in EmacsModeTest().key_dispatch.values()])
+    all_funcs=all_funcs.keys()
+    not_tested=[x for x in all_funcs if x not in tested]
+    not_tested.sort()
+    print " Not tested functions ".center(60,"-")
+    print "\n".join(not_tested)
+    
+    
diff --git a/windows/fuzzbunch/pyreadline/test/lineeditor_test.py b/windows/fuzzbunch/pyreadline/test/lineeditor_test.py
new file mode 100644
index 0000000..f8b2a12
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/test/lineeditor_test.py
@@ -0,0 +1,390 @@
+# Copyright (C) 2006  Michael Graz. <mgraz@plan10.com>
+
+import sys, unittest
+sys.path.append ('../..')
+#from pyreadline.modes.vi import *
+#from pyreadline import keysyms
+from pyreadline.lineeditor import lineobj
+
+#----------------------------------------------------------------------
+
+
+#----------------------------------------------------------------------
+
+class Test_copy (unittest.TestCase):
+    def test_copy1 (self):
+        l=lineobj.ReadLineTextBuffer("first second")
+        q=l.copy()
+        self.assertEqual(q.get_line_text(),l.get_line_text())
+        self.assertEqual(q.point,l.point)
+        self.assertEqual(q.mark,l.mark)
+        
+    def test_copy2 (self):
+        l=lineobj.ReadLineTextBuffer("first second",point=5)
+        q=l.copy()
+        self.assertEqual(q.get_line_text(),l.get_line_text())
+        self.assertEqual(q.point,l.point)
+        self.assertEqual(q.mark,l.mark)
+        
+
+class Test_linepos (unittest.TestCase):
+    t="test text"
+    def test_NextChar (self):
+        t=self.t
+        l=lineobj.ReadLineTextBuffer(t)
+        for i in range(len(t)):
+            self.assertEqual(i,l.point)
+            l.point=lineobj.NextChar
+        #advance past end of buffer            
+        l.point=lineobj.NextChar
+        self.assertEqual(len(t),l.point)
+
+    def test_PrevChar (self):
+        t=self.t
+        l=lineobj.ReadLineTextBuffer(t,point=len(t))
+        for i in range(len(t)):
+            self.assertEqual(len(t)-i,l.point)
+            l.point=lineobj.PrevChar
+        #advance past beginning of buffer            
+        l.point=lineobj.PrevChar
+        self.assertEqual(0,l.point)
+
+    def test_EndOfLine (self):
+        t=self.t
+        l=lineobj.ReadLineTextBuffer(t,point=len(t))
+        for i in range(len(t)):
+            l.point=i
+            l.point=lineobj.EndOfLine
+            self.assertEqual(len(t),l.point)
+                        
+    def test_StartOfLine (self):
+        t=self.t
+        l=lineobj.ReadLineTextBuffer(t,point=len(t))
+        for i in range(len(t)):
+            l.point=i
+            l.point=lineobj.StartOfLine
+            self.assertEqual(0,l.point)
+                        
+
+class Tests_linepos2(Test_linepos):
+    t="kajkj"
+            
+class Tests_linepos3(Test_linepos):
+    t=""
+
+
+class Test_movement (unittest.TestCase):
+    def test_NextChar (self):
+        cmd=lineobj.NextChar
+        tests=[
+        # "First"
+         (cmd,
+          "First",
+          "#     ",
+          " #    "),
+         (cmd,
+          "First",
+          "    # ",
+          "     #"),
+         (cmd,
+          "First",
+          "     #",
+          "     #"),
+          ]
+        for cmd,text,init_point,expected_point in tests:
+            l=lineobj.ReadLineTextBuffer(text,get_point_pos(init_point))
+            l.point=cmd
+            self.assertEqual(get_point_pos(expected_point),l.point)
+        
+    def test_PrevChar (self):
+        cmd=lineobj.PrevChar
+        tests=[
+        # "First"
+         (cmd,
+          "First",
+          "     #",
+          "    # "),
+         (cmd,
+          "First",
+          " #   ",
+          "#    "),
+         (cmd,
+          "First",
+          "#     ",
+          "#     "),
+          ]
+        for cmd,text,init_point,expected_point in tests:
+            l=lineobj.ReadLineTextBuffer(text,get_point_pos(init_point))
+            l.point=cmd
+            self.assertEqual(get_point_pos(expected_point),l.point)
+        
+        
+        
+    def test_PrevWordStart (self):
+        cmd=lineobj.PrevWordStart
+        tests=[
+        # "First Second Third"
+         (cmd,
+          "First Second Third",
+          "                  #",
+          "             #     "),
+         (cmd,
+          "First Second Third",
+          "             #     ",
+          "      #            "),
+         (cmd,
+          "First Second Third",
+          "     #             ",
+          "#                  "),
+         (cmd,
+          "First Second Third",
+          "#                  ",
+          "#                  "),
+          ]
+        for cmd,text,init_point,expected_point in tests:
+            l=lineobj.ReadLineTextBuffer(text,get_point_pos(init_point))
+            l.point=cmd
+            self.assertEqual(get_point_pos(expected_point),l.point)
+        
+    def test_NextWordStart (self):
+        cmd=lineobj.NextWordStart
+        tests=[
+        # "First Second Third"
+         (cmd,
+          "First Second Third",
+          "#                 ",
+          "      #           "),
+         (cmd,
+          "First Second Third",
+          "    #             ",
+          "      #           "),
+         (cmd,
+          "First Second Third",
+          "      #            ",
+          "             #     "),
+         (cmd,
+          "First Second Third",
+          "              #    ",
+          "                  #"),
+          ]
+        for cmd,text,init_point,expected_point in tests:
+            l=lineobj.ReadLineTextBuffer(text,get_point_pos(init_point))
+            l.point=cmd
+            self.assertEqual(get_point_pos(expected_point),l.point)
+        
+    def test_NextWordEnd (self):
+        cmd=lineobj.NextWordEnd
+        tests=[
+        # "First Second Third"
+         (cmd,
+          "First Second Third",
+          "#                 ",
+          "     #            "),
+         (cmd,
+          "First Second Third",
+          "    #             ",
+          "     #            "),
+         (cmd,
+          "First Second Third",
+          "      #            ",
+          "            #      "),
+         (cmd,
+          "First Second Third",
+          "              #    ",
+          "                  #"),
+          ]
+        for cmd,text,init_point,expected_point in tests:
+            l=lineobj.ReadLineTextBuffer(text,get_point_pos(init_point))
+            l.point=cmd
+            self.assertEqual(get_point_pos(expected_point),l.point)
+        
+    def test_PrevWordEnd (self):
+        cmd=lineobj.PrevWordEnd
+        tests=[
+        # "First Second Third"
+         (cmd,
+          "First Second Third",
+          "                  #",
+          "            #      "),
+         (cmd,
+          "First Second Third",
+          "            #      ",
+          "     #             "),
+         (cmd,
+          "First Second Third",
+          "     #             ",
+          "#                  "),
+         (cmd,
+          "First Second Third",
+          "#                  ",
+          "#                  "),          
+          ]
+        for cmd,text,init_point,expected_point in tests:
+            l=lineobj.ReadLineTextBuffer(text,get_point_pos(init_point))
+            l.point=cmd
+            self.assertEqual(get_point_pos(expected_point),l.point)
+        
+    def test_WordEnd_1 (self):
+        cmd=lineobj.WordEnd
+        tests=[
+        # "First Second Third"
+         (cmd,
+          "First Second Third",
+          "#                  ",
+          "     #             "),
+         (cmd,
+          "First Second Third",
+          " #                 ",
+          "     #             "),
+         (cmd,
+          "First Second Third",
+          "             #     ",
+          "                  #"),
+          ]
+        for cmd,text,init_point,expected_point in tests:
+            l=lineobj.ReadLineTextBuffer(text,get_point_pos(init_point))
+            l.point=cmd
+            self.assertEqual(get_point_pos(expected_point),l.point)
+
+    def test_WordEnd_2 (self):
+        cmd=lineobj.WordEnd
+        tests=[
+        # "First Second Third"
+         (cmd,
+          "First Second Third",
+          "     #             "),
+         (cmd,
+          "First Second Third",
+          "            #      "),
+         (cmd,
+          "First Second Third",
+          "                  #"),
+          ]
+
+        for cmd,text,init_point in tests:
+            l=lineobj.ReadLineTextBuffer(text,get_point_pos(init_point))
+            self.assertRaises(lineobj.NotAWordError,cmd,l)
+        
+        
+    def test_WordStart_1 (self):
+        cmd=lineobj.WordStart
+        tests=[
+        # "First Second Third"
+         (cmd,
+          "First Second Third",
+          "#                  ",
+          "#                  "),
+         (cmd,
+          "First Second Third",
+          " #                 ",
+          "#                  "),
+         (cmd,
+          "First Second Third",
+          "               #   ",
+          "             #     "),
+          ]
+        for cmd,text,init_point,expected_point in tests:
+            l=lineobj.ReadLineTextBuffer(text,get_point_pos(init_point))
+            l.point=cmd
+            self.assertEqual(get_point_pos(expected_point),l.point)
+        
+    def test_WordStart_2 (self):
+        cmd=lineobj.WordStart
+        tests=[
+        # "First Second Third"
+         (cmd,
+          "First Second Third",
+          "     #             "),
+         (cmd,
+          "First Second Third",
+          "            #      "),
+         (cmd,
+          "First Second Third",
+          "                  #"),
+          ]
+
+        for cmd,text,init_point in tests:
+            l=lineobj.ReadLineTextBuffer(text,get_point_pos(init_point))
+            self.assertRaises(lineobj.NotAWordError,cmd,l)
+        
+
+    def test_StartOfLine (self):
+        cmd=lineobj.StartOfLine
+        tests=[
+        # "First Second Third"
+         (cmd,
+          "First Second Third",
+          "#                 ",
+          "#                 "),
+         (cmd,
+          "First Second Third",
+          "         #         ",
+          "#                  "),
+         (cmd,
+          "First Second Third",
+          "                  #",
+          "#                  "),
+          ]
+        for cmd,text,init_point,expected_point in tests:
+            l=lineobj.ReadLineTextBuffer(text,get_point_pos(init_point))
+            l.point=cmd
+            self.assertEqual(get_point_pos(expected_point),l.point)
+        
+    def test_EndOfLine (self):
+        cmd=lineobj.EndOfLine
+        tests=[
+        # "First Second Third"
+         (cmd,
+          "First Second Third",
+          "#                 ",
+          "                  #"),
+         (cmd,
+          "First Second Third",
+          "         #         ",
+          "                  #"),
+         (cmd,
+          "First Second Third",
+          "                  #",
+          "                  #"),
+          ]
+        for cmd,text,init_point,expected_point in tests:
+            l=lineobj.ReadLineTextBuffer(text,get_point_pos(init_point))
+            l.point=cmd
+            self.assertEqual(get_point_pos(expected_point),l.point)
+
+    def test_Point(self):
+        cmd=lineobj.Point
+        tests=[
+        # "First Second Third"
+         (cmd,
+          "First Second Third",
+          0),
+         (cmd,
+          "First Second Third",
+          12),
+         (cmd,
+          "First Second Third",
+          18),
+          ]
+        for cmd,text,p in tests:
+            l=lineobj.ReadLineTextBuffer(text,p)
+            self.assertEqual(p,cmd(l))
+
+
+#----------------------------------------------------------------------
+# utility functions
+
+def get_point_pos(pstr):
+    return pstr.index("#")
+
+def get_mark_pos(mstr):
+    try:
+        return mstr.index("#")
+    except ValueError:
+        return -1
+#----------------------------------------------------------------------
+
+if __name__ == '__main__':
+    unittest.main()
+
+    l=lineobj.ReadLineTextBuffer("First Second Third")
\ No newline at end of file
diff --git a/windows/fuzzbunch/pyreadline/test/vi_test.py b/windows/fuzzbunch/pyreadline/test/vi_test.py
new file mode 100644
index 0000000..60d99c2
--- /dev/null
+++ b/windows/fuzzbunch/pyreadline/test/vi_test.py
@@ -0,0 +1,2146 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2006  Michael Graz. <mgraz@plan10.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+import sys, unittest,pdb
+sys.path.append ('../..')
+from pyreadline.modes.vi import *
+from pyreadline import keysyms
+from pyreadline.lineeditor import lineobj
+from pyreadline.logger import log_sock
+import pyreadline.logger as logger
+from common import *
+
+from common import *
+#----------------------------------------------------------------------
+
+class ViModeTest (ViMode):
+    tested_commands={}
+    def __init__ (self):
+        ViMode.__init__ (self, MockReadline())
+        self.mock_console = MockConsole ()
+        self.init_editing_mode (None)
+        self.vi_set_insert_mode (True)
+        self.lst_completions = []
+        self.completer = self.mock_completer
+        self.completer_delims = ' '
+        self.tabstop = 4
+
+    def get_mock_console (self):
+        return self.mock_console
+    console = property (get_mock_console)
+
+    def _set_line (self, text):
+        self.l_buffer.set_line (text)
+
+    def get_line (self):
+        return self.l_buffer.get_line_text ()
+    line = property (get_line)
+
+    def get_line_cursor (self):
+        return self.l_buffer.point
+    line_cursor = property (get_line_cursor)
+
+    def input (self, keytext):
+        if keytext[0] == '"' and keytext[-1] == '"':
+            lst_key = ['"%s"' % c for c in keytext[1:-1]]
+        else:
+            lst_key = [keytext]
+        for key in lst_key:
+            keyinfo, event = keytext_to_keyinfo_and_event (key)
+            dispatch_func = self.key_dispatch.get( keyinfo.tuple(),self.vi_key)
+            self.tested_commands[dispatch_func.__name__]=dispatch_func
+            dispatch_func (event)
+
+    def vi_accept_line (self, e):
+        if ViMode.vi_accept_line (self, e):
+            # simulate return
+            # self.add_history (self.line)
+            self.l_buffer.reset_line ()
+
+    def mock_completer (self, text, state):
+        return self.lst_completions [state]
+
+class ViExternalEditorTest (ViExternalEditor):
+    def __init__ (self, line):
+        import StringIO
+        self.sio_write = StringIO.StringIO ()
+        self.sio_read = StringIO.StringIO ('qwerty after')
+        ViExternalEditor.__init__ (self, line)
+
+    def get_tempfile (self):
+        return 'temp.py'
+
+    def get_editor (self):
+        return 'vim.exe'
+
+    def file_open (self, filename, mode):
+        if mode == 'w':
+            return self.sio_write
+        else:
+            return self.sio_read
+
+    def file_remove (self, filename):
+        self.remove = filename
+
+    def run_command (self, command):
+        self.command = command
+
+#----------------------------------------------------------------------
+
+class Tests (unittest.TestCase):
+
+    def test_keyinfo (self):
+        keyinfo, event = keytext_to_keyinfo_and_event ('"d"')
+        self.assertEqual ('d', event.char)
+        keyinfo, event = keytext_to_keyinfo_and_event ('"D"')
+        self.assertEqual ('D', event.char)
+        keyinfo, event = keytext_to_keyinfo_and_event ('"$"')
+        self.assertEqual ('$', event.char)
+        keyinfo, event = keytext_to_keyinfo_and_event ('Escape')
+        self.assertEqual ('\x1b', event.char)
+
+    def test_simple (self):
+        r = ViModeTest ()
+        r._set_line ('abc')
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('"d"')
+        self.assert_ (r.vi_is_insert_mode)
+        self.assertEqual ('abcd', r.line)
+        r.input ('Escape')
+        self.assert_ (not r.vi_is_insert_mode)
+        self.assertEqual ('abcd', r.line)
+        r.input ('"i"')
+        self.assert_ (r.vi_is_insert_mode)
+        self.assertEqual ('abcd', r.line)
+        r.input ('"x"')
+        self.assertEqual ('abcxd', r.line)
+        r.input ('"y"')
+        self.assertEqual ('abcxyd', r.line)
+
+    def test_begin_and_end (self):
+        r = ViModeTest ()
+        r._set_line ('abc')
+        self.assertEqual (3, r.line_cursor)
+        r.input ('Escape')
+        self.assertEqual (2, r.line_cursor)
+        r.input ('"0"')
+        self.assertEqual (0, r.line_cursor)
+        r.input ('"$"')
+        self.assertEqual (2, r.line_cursor)
+        r.input ('"^"')
+        self.assertEqual (0, r.line_cursor)
+
+    def test_history_alpha (self):
+        r = ViModeTest ()
+        r.add_history ('abc')
+        r.add_history ('def')
+        r._set_line ('ghi')
+        r.input ('Escape')
+        r.input ('"k"')
+        self.assertEqual (0, r.line_cursor)
+        self.assertEqual ('def', r.line)
+        r.input ('"k"')
+        self.assertEqual ('abc', r.line)
+        self.assertEqual (0, r.console.bell_count)
+        r.input ('"k"')
+        self.assertEqual ('abc', r.line)
+        # TODO up history with no more -> error ?
+        # self.assertEqual (1, r.console.bell_count)
+        r.input ('"j"')
+        self.assertEqual ('def', r.line)
+        self.assertEqual (0, r.line_cursor)
+        r.input ('"j"')
+        self.assertEqual ('ghi', r.line)
+        # TODO returning to original line loses cursor pos?
+        # self.assertEqual (2, r.line_cursor)
+        r.input ('"j"')
+        self.assertEqual ('ghi', r.line)
+        self.assertEqual (2, r.line_cursor)
+
+    def test_history_arrow (self):
+        r = ViModeTest ()
+        r.add_history ('abc')
+        r.add_history ('def')
+        r.input ('"ghi"')
+        self.assertEqual (3, r.line_cursor)
+        r.input ('Up')
+        self.assertEqual (3, r.line_cursor)
+        self.assertEqual ('def', r.line)
+        r.input ('Up')
+        self.assertEqual (3, r.line_cursor)
+        self.assertEqual ('abc', r.line)
+        self.assertEqual (0, r.console.bell_count)
+        r.input ('Up')
+        self.assertEqual ('abc', r.line)
+        # TODO up history with no more -> error ?
+        # self.assertEqual (1, r.console.bell_count)
+        r.input ('Down')
+        self.assertEqual ('def', r.line)
+        self.assertEqual (3, r.line_cursor)
+        r.input ('Down')
+        self.assertEqual ('ghi', r.line)
+        self.assertEqual (3, r.line_cursor)
+        r.input ('Down')
+        self.assertEqual ('ghi', r.line)
+        self.assertEqual (3, r.line_cursor)
+
+    def test_history_arrow_after_undo (self):
+        r = ViModeTest ()
+        r.input ('"aaa"')
+        r.input ('Return')
+        r.input ('"bbb ccc"')
+        r.input ('Escape')
+        r.input ('"F D"')
+        self.assertEqual (r.line, 'bbb')
+        r.input ('"u"')
+        self.assertEqual (r.line, 'bbb ccc')
+        r.input ('Return')
+        self.assertEqual (r.console.bell_count, 0)
+        r.input ('"ddd"')
+        r.input ('Down')
+        self.assertEqual (r.line, 'ddd')
+        # TODO down history with no more -> error ?
+        # self.assertEqual (r.console.bell_count, 1)
+
+    def test_vi_is_word (self):
+        self.assert_ (vi_is_word ('a'))
+        self.assert_ (not vi_is_word (' '))
+
+    def test_pos_word_short (self):
+        self.assertEqual (0, vi_pos_word_short (''))
+        self.assertEqual (4, vi_pos_word_short ('abc def '))
+        self.assertEqual (4, vi_pos_word_short ('abc def ', 2))
+        self.assertEqual (4, vi_pos_word_short ('abc def ', 3))
+        self.assertEqual (8, vi_pos_word_short ('abc def ', 4))
+        self.assertEqual (3, vi_pos_word_short ('abc.def '))
+        self.assertEqual (5, vi_pos_word_short ('abc..def ', 3))
+        self.assertEqual (8, vi_pos_word_short ('ab  cd  ef  gh', count=2))
+        self.assertEqual (8, vi_pos_word_short ('ab  cd  ef  gh', 1, 2))
+        self.assertEqual (8, vi_pos_word_short ('ab  cd  ef  gh', 3, 2))
+        self.assertEqual (14, vi_pos_word_short ('ab  cd  ef  gh', count=10))
+
+    def test_pos_word_long (self):
+        self.assertEqual (0, vi_pos_word_long (''))
+        self.assertEqual (4, vi_pos_word_long ('abc def '))
+        self.assertEqual (4, vi_pos_word_long ('abc def ', 2))
+        self.assertEqual (4, vi_pos_word_long ('abc def ', 3))
+        self.assertEqual (8, vi_pos_word_long ('abc def ', 4))
+        self.assertEqual (8, vi_pos_word_long ('abc.def '))
+        self.assertEqual (9, vi_pos_word_long ('abc..def ', 3))
+        self.assertEqual (10, vi_pos_word_long ('a.b  c.d  e.f  g.h', count=2))
+        self.assertEqual (10, vi_pos_word_long ('a.b  c.d  e.f  g.h', 2, 2))
+        self.assertEqual (10, vi_pos_word_long ('a.b  c.d  e.f  g.h', 4, 2))
+
+    def test_pos_end_short (self):
+        self.assertEqual (0, vi_pos_end_short (''))
+        self.assertEqual (2, vi_pos_end_short ('abc def '))
+        self.assertEqual (6, vi_pos_end_short ('abc def ', 2))
+        self.assertEqual (6, vi_pos_end_short ('abc def ', 3))
+        self.assertEqual (6, vi_pos_end_short ('abc def ', 4))
+        self.assertEqual (2, vi_pos_end_short ('abc.def '))
+        self.assertEqual (7, vi_pos_end_short ('abc  ...  def ', 3))
+        self.assertEqual (7, vi_pos_end_short ('abc  ...  def ', 5))
+        self.assertEqual (12, vi_pos_end_short ('abc  ...  def ', 8))
+        self.assertEqual (5, vi_pos_end_short ('ab  cd  ef  gh', count=2))
+        self.assertEqual (9, vi_pos_end_short ('ab  cd  ef  gh', 1, 2))
+        self.assertEqual (9, vi_pos_end_short ('ab  cd  ef  gh', 3, 2))
+
+    def test_pos_end_long (self):
+        self.assertEqual (0, vi_pos_end_long (''))
+        self.assertEqual (2, vi_pos_end_long ('abc def '))
+        self.assertEqual (6, vi_pos_end_long ('abc def ', 2))
+        self.assertEqual (6, vi_pos_end_long ('abc def ', 3))
+        self.assertEqual (6, vi_pos_end_long ('abc def ', 4))
+        self.assertEqual (6, vi_pos_end_long ('abc.def '))
+        self.assertEqual (10, vi_pos_end_long ('  abc...def '))
+        self.assertEqual (10, vi_pos_end_long ('abc  ...def ', 5))
+        self.assertEqual (7, vi_pos_end_long ('a.b  c.d  e.f  g.h', count=2))
+        self.assertEqual (12, vi_pos_end_long ('a.b  c.d  e.f  g.h', 2, 2))
+        self.assertEqual (12, vi_pos_end_long ('a.b  c.d  e.f  g.h', 4, 2))
+
+    def test_pos_back_short (self):
+        self.assertEqual (0, vi_pos_back_short (''))
+        self.assertEqual (4, vi_pos_back_short ('abc def', 6))
+        self.assertEqual (4, vi_pos_back_short ('abc def', 5))
+        self.assertEqual (0, vi_pos_back_short ('abc def', 4))
+        self.assertEqual (0, vi_pos_back_short ('abc def', 3))
+        self.assertEqual (8, vi_pos_back_short ('abc  ...def ', 11))
+        self.assertEqual (5, vi_pos_back_short ('abc  ...def ', 8))
+        self.assertEqual (0, vi_pos_back_short ('abc  ...def ', 5))
+        self.assertEqual (0, vi_pos_back_short ('abc  ...def '))
+        self.assertEqual (8, vi_pos_back_short ('abc  def... ', 11))
+        self.assertEqual (5, vi_pos_back_short ('abc  def... ', 8))
+        self.assertEqual (0, vi_pos_back_short ('abc  def... ', 5))
+        self.assertEqual (11, vi_pos_back_short ('abc def... ghi...', 16, count=2))
+        self.assertEqual (0, vi_pos_back_short ('abc def... ghi...', 11, count=3))
+
+    def test_pos_back_long (self):
+        self.assertEqual (0, vi_pos_back_long (''))
+        self.assertEqual (4, vi_pos_back_long ('abc def', 6))
+        self.assertEqual (4, vi_pos_back_long ('abc def', 5))
+        self.assertEqual (0, vi_pos_back_long ('abc def', 4))
+        self.assertEqual (0, vi_pos_back_long ('abc def', 3))
+        self.assertEqual (5, vi_pos_back_long ('abc  ...def ', 11))
+        self.assertEqual (0, vi_pos_back_long ('abc  ...def ', 5))
+        self.assertEqual (0, vi_pos_back_long ('abc  ...def '))
+        self.assertEqual (5, vi_pos_back_long ('abc  def... ', 11))
+        self.assertEqual (0, vi_pos_back_long ('abc  def... ', 5))
+        self.assertEqual (4, vi_pos_back_long ('abc def... ghi...', 16, count=2))
+
+    def test_pos_find_char_forward (self):
+        self.assertEqual (-1, vi_pos_find_char_forward ('', 'x'))
+        self.assertEqual (-1, vi_pos_find_char_forward ('abc def', 'x'))
+        self.assertEqual (4, vi_pos_find_char_forward ('abc def', 'd'))
+        self.assertEqual (4, vi_pos_find_char_forward ('abc def', 'd', 3))
+        self.assertEqual (-1, vi_pos_find_char_forward ('abc def', 'd', 4))
+        self.assertEqual (-1, vi_pos_find_char_forward ('abc def', 'd', count=2))
+        self.assertEqual (12, vi_pos_find_char_forward ('abc def abc def', 'd', count=2))
+
+    def test_pos_find_char_backward (self):
+        self.assertEqual (-1, vi_pos_find_char_backward ('', 'x'))
+        self.assertEqual (-1, vi_pos_find_char_backward ('abc def', 'x', 6))
+        self.assertEqual (4, vi_pos_find_char_backward ('abc def', 'd', 6))
+        self.assertEqual (4, vi_pos_find_char_backward ('abc def', 'd', 5))
+        self.assertEqual (-1, vi_pos_find_char_backward ('abc def', 'd', 4))
+        self.assertEqual (-1, vi_pos_find_char_backward ('abc def', 'd', 6, count=2))
+        self.assertEqual (4, vi_pos_find_char_backward ('abc def abc def', 'd', 14, count=2))
+
+    def test_pos_to_char_forward (self):
+        self.assertEqual (-1, vi_pos_to_char_forward ('', 'x'))
+        self.assertEqual (-1, vi_pos_to_char_forward ('abc def', 'x'))
+        self.assertEqual (3, vi_pos_to_char_forward ('abc def', 'd'))
+        self.assertEqual (3, vi_pos_to_char_forward ('abc def', 'd', 2))
+        self.assertEqual (-1, vi_pos_to_char_forward ('abc def', 'd', 4))
+        self.assertEqual (-1, vi_pos_to_char_forward ('abc def', 'd', count=2))
+        self.assertEqual (11, vi_pos_to_char_forward ('abc def abc def', 'd', count=2))
+
+    def test_pos_to_char_backward (self):
+        self.assertEqual (-1, vi_pos_to_char_backward ('', 'x'))
+        self.assertEqual (-1, vi_pos_to_char_backward ('abc def', 'x', 6))
+        self.assertEqual (5, vi_pos_to_char_backward ('abc def', 'd', 6))
+        self.assertEqual (5, vi_pos_to_char_backward ('abc def', 'd', 5))
+        self.assertEqual (-1, vi_pos_to_char_backward ('abc def', 'd', 4))
+        self.assertEqual (-1, vi_pos_to_char_backward ('abc def', 'd', 6, count=2))
+        self.assertEqual (5, vi_pos_to_char_backward ('abc def abc def', 'd', 14, count=2))
+
+    def test_motion_word (self):
+        '''motions: lowercase mode is alpha, digit and _, uppercase is delim by spaces
+        w/W: forward short/long word'''
+        r = ViModeTest ()
+        r._set_line ('abc_123  def--456.789  x')
+        r.input ('Escape')
+        r.input ('"0"')
+        r.input ('"w"')
+        self.assertEqual (9, r.line_cursor)
+        r.input ('"w"')
+        self.assertEqual (12, r.line_cursor)
+        r.input ('"w"')
+        self.assertEqual (14, r.line_cursor)
+        r.input ('"W"')
+        self.assertEqual (23, r.line_cursor)
+
+    def test_motion_word_multiplier (self):
+        r = ViModeTest ()
+        r._set_line ('a b c d e f g h i j k l m n o p q r s t u v w x y z')
+        r.input ('Escape')
+        r.input ('"0"')
+        r.input ('"2"')
+        self.assertEqual (0, r.line_cursor)
+        r.input ('"w"')
+        self.assertEqual (4, r.line_cursor)
+        r.input ('"2"')
+        r.input ('"0"')
+        r.input ('"w"')
+        self.assertEqual (44, r.line_cursor)
+        r.input ('"2"')
+        r.input ('"W"')
+        self.assertEqual (48, r.line_cursor)
+
+    def test_motion_end (self):
+        '''motions: lowercase mode is alpha, digit and _, uppercase is delim by spaces
+        e/E: to end of short/long word'''
+        r = ViModeTest ()
+        r._set_line ('  abc_123  --def--456.789  x')
+        r.input ('Escape')
+        r.input ('"0"')
+        r.input ('"e"')
+        self.assertEqual (8, r.line_cursor)
+        r.input ('"e"')
+        self.assertEqual (12, r.line_cursor)
+        r.input ('"e"')
+        self.assertEqual (15, r.line_cursor)
+        r.input ('"E"')
+        self.assertEqual (24, r.line_cursor)
+
+    def test_motion_end_multiplier (self):
+        r = ViModeTest ()
+        r._set_line ('ab cd ef gh ij kl mn op qr st uv wx yz')
+        r.input ('Escape')
+        r.input ('"0"')
+        r.input ('"3"')
+        r.input ('"e"')
+        self.assertEqual (7, r.line_cursor)
+        r.input ('"4"')
+        r.input ('"E"')
+        self.assertEqual (19, r.line_cursor)
+
+    def test_motion_backward (self):
+        '''motions: lowercase mode is alpha, digit and _, uppercase is delim by spaces
+        b/B: backward short/long word'''
+        r = ViModeTest ()
+        r._set_line ('abc_123  def--456.789  x')
+        r.input ('Escape')
+        r.input ('"$"')
+        self.assertEqual (23, r.line_cursor)
+        r.input ('"b"')
+        self.assertEqual (18, r.line_cursor)
+        r.input ('"b"')
+        self.assertEqual (17, r.line_cursor)
+        r.input ('"B"')
+        self.assertEqual (9, r.line_cursor)
+        r.input ('"B"')
+        self.assertEqual (0, r.line_cursor)
+
+    def test_motion_backward_multiplier (self):
+        r = ViModeTest ()
+        r._set_line ('ab cd ef gh ij kl mn op qr st uv wx yz')
+        r.input ('Escape')
+        r.input ('"$"')
+        self.assertEqual (37, r.line_cursor)
+        r.input ('"3"')
+        r.input ('"b"')
+        self.assertEqual (30, r.line_cursor)
+        r.input ('"5"')
+        r.input ('"b"')
+        self.assertEqual (15, r.line_cursor)
+
+    def test_motion_find_char_forward (self):
+        r = ViModeTest ()
+        r._set_line ('abc_123  def--456.789  x')
+        r.input ('Escape')
+        r.input ('"0"')
+        r.input ('"f"')
+        self.assertEqual (0, r.line_cursor)
+        r.input ('"c"')
+        self.assertEqual (2, r.line_cursor)
+
+    def test_motion_find_char_backward (self):
+        r = ViModeTest ()
+        r._set_line ('abc_123  def--456.789  x')
+        r.input ('Escape')
+        r.input ('"$"')
+        self.assertEqual (23, r.line_cursor)
+        r.input ('"F"')
+        self.assertEqual (23, r.line_cursor)
+        r.input ('"c"')
+        self.assertEqual (2, r.line_cursor)
+
+    def test_motion_find_char_forward_multiplier (self):
+        r = ViModeTest ()
+        r._set_line ('ab cd ef 01 23 45 ab cd ef 01 23 45 ab cd ef 01 23 45')
+        r.input ('Escape')
+        r.input ('"0"')
+        r.input ('"2"')
+        r.input ('"f"')
+        r.input ('"0"')
+        self.assertEqual (27, r.line_cursor)
+
+    def test_motion_find_char_backward_multiplier (self):
+        r = ViModeTest ()
+        r._set_line ('ab cd ef 01 23 45 ab cd ef 01 23 45 ab cd ef 01 23 45')
+        r.input ('Escape')
+        r.input ('"$"')
+        self.assertEqual (52, r.line_cursor)
+        r.input ('"2"')
+        r.input ('"F"')
+        r.input ('"0"')
+        self.assertEqual (27, r.line_cursor)
+
+    def test_motion_find_char_again (self):
+        r = ViModeTest ()
+        r._set_line ('1234512345123451234512345')
+        r.input ('Escape')
+        r.input ('"0"')
+        r.input ('"2"')
+        r.input ('"f"')
+        r.input ('"3"')
+        self.assertEqual (7, r.line_cursor)
+        r.input ('";"')
+        self.assertEqual (12, r.line_cursor)
+        r.input ('"2"')
+        r.input ('";"')
+        self.assertEqual (22, r.line_cursor)
+        r.input ('","')
+        self.assertEqual (17, r.line_cursor)
+        r.input ('"2"')
+        r.input ('","')
+        self.assertEqual (7, r.line_cursor)
+
+    def test_motion_find_char_opposite (self):
+        r = ViModeTest ()
+        r._set_line ('1234512345123451234512345')
+        r.input ('Escape')
+        r.input ('"$"')
+        r.input ('"2"')
+        r.input ('"F"')
+        r.input ('"3"')
+        self.assertEqual (17, r.line_cursor)
+        r.input ('";"')
+        self.assertEqual (12, r.line_cursor)
+        r.input ('"2"')
+        r.input ('";"')
+        self.assertEqual (2, r.line_cursor)
+        r.input ('","')
+        self.assertEqual (7, r.line_cursor)
+        r.input ('"2"')
+        r.input ('","')
+        self.assertEqual (17, r.line_cursor)
+        r.input ('"2"')
+        r.input ('","')
+        self.assertEqual (17, r.line_cursor)
+
+    def test_motion_to_char_forward (self):
+        r = ViModeTest ()
+        r._set_line ('abc_123  def--456.789  x')
+        r.input ('Escape')
+        r.input ('"0"')
+        r.input ('"t"')
+        self.assertEqual (0, r.line_cursor)
+        r.input ('"c"')
+        self.assertEqual (1, r.line_cursor)
+
+    def test_motion_to_char_backward (self):
+        r = ViModeTest ()
+        r._set_line ('abc_123  def--456.789  x')
+        r.input ('Escape')
+        r.input ('"$"')
+        self.assertEqual (23, r.line_cursor)
+        r.input ('"T"')
+        self.assertEqual (23, r.line_cursor)
+        r.input ('"c"')
+        self.assertEqual (3, r.line_cursor)
+
+    def test_motion_to_char_forward_multiplier (self):
+        r = ViModeTest ()
+        r._set_line ('ab cd ef 01 23 45 ab cd ef 01 23 45 ab cd ef 01 23 45')
+        r.input ('Escape')
+        r.input ('"0"')
+        r.input ('"2"')
+        r.input ('"t"')
+        r.input ('"0"')
+        self.assertEqual (26, r.line_cursor)
+
+    def test_motion_to_char_backward_multiplier (self):
+        r = ViModeTest ()
+        r._set_line ('ab cd ef 01 23 45 ab cd ef 01 23 45 ab cd ef 01 23 45')
+        r.input ('Escape')
+        r.input ('"$"')
+        self.assertEqual (52, r.line_cursor)
+        r.input ('"2"')
+        r.input ('"T"')
+        r.input ('"0"')
+        self.assertEqual (28, r.line_cursor)
+
+    def test_delete_word (self):
+        r = ViModeTest ()
+        r._set_line ('abc de fghi jkl mnopq rst')
+        r.input ('Escape')
+        r.input ('"0"')
+        r.input ('"d"')
+        r.input ('"w"')
+        self.assertEqual (0, r.line_cursor)
+        self.assertEqual (r.line, 'de fghi jkl mnopq rst')
+        r.input ('"d"')
+        r.input ('"2"')
+        r.input ('"w"')
+        self.assertEqual (0, r.line_cursor)
+        self.assertEqual (r.line, 'jkl mnopq rst')
+        r.input ('"2"')
+        r.input ('"d"')
+        r.input ('"w"')
+        self.assertEqual (0, r.line_cursor)
+        self.assertEqual (r.line, 'rst')
+
+    def test_delete_word_two_multipliers (self):
+        r = ViModeTest ()
+        r._set_line ('abc de fghi jkl mnopq rst uv wx yz')
+        r.input ('Escape')
+        r.input ('"0w"')
+        r.input ('"2d3w"')
+        self.assertEqual (4, r.line_cursor)
+        self.assertEqual (r.line, 'abc wx yz')
+
+    def test_delete_find_char_forward_two_multipliers (self):
+        r = ViModeTest ()
+        r._set_line ('0123456789012345678901234567890123456789012345678901234567890123456789')
+        r.input ('Escape')
+        r.input ('"0"')
+        r.input ('"2d3f4"')
+        self.assertEqual (r.line, '567890123456789')
+
+    def test_delete_end_of_line (self):
+        r = ViModeTest ()
+        r._set_line ('abc de fghi jkl mnopq rst uv wx yz')
+        r.input ('Escape')
+        r.input ('"0w"')
+        r.input ('"D"')
+        self.assertEqual (r.line, 'abc ')
+
+    def test_two_lines (self):
+        r = ViModeTest ()
+        r.input ('"abcdef"')
+        self.assertEqual (r.line, 'abcdef')
+        r.input ('Escape')
+        r.input ('"0iqq"')
+        self.assertEqual (r.line, 'qqabcdef')
+        r.input ('Return')
+        self.assertEqual (r.line, '')
+        r.input ('"xyz"')
+        self.assertEqual (r.line, 'xyz')
+
+    def test_delete_word_short_to_end_of_line (self):
+        r = ViModeTest ()
+        r._set_line ('abc def ghi')
+        r.input ('Escape')
+        r.input ('"03dw"')
+        self.assertEqual ('', r.line)
+        r._set_line ('abc def ghi  ')
+        r.input ('Escape')
+        r.input ('"03dw"')
+        self.assertEqual ('', r.line)
+
+    def test_delete_word_long_to_end_of_line (self):
+        r = ViModeTest ()
+        r._set_line ('a.c d.f g.i')
+        r.input ('Escape')
+        r.input ('"03dW"')
+        self.assertEqual ('', r.line)
+        r._set_line ('a.c d.f g.i  ')
+        r.input ('Escape')
+        r.input ('"03dW"')
+        self.assertEqual ('', r.line)
+
+    def test_delete_end_short_to_end_of_line (self):
+        r = ViModeTest ()
+        r._set_line ('abc def ghi')
+        r.input ('Escape')
+        r.input ('"03de"')
+        self.assertEqual ('', r.line)
+        r._set_line ('abc def ghi  ')
+        r.input ('Escape')
+        r.input ('"03de"')
+        self.assertEqual ('  ', r.line)
+
+    def test_delete_end_long_to_end_of_line (self):
+        r = ViModeTest ()
+        r._set_line ('a.c d.f g.i')
+        r.input ('Escape')
+        r.input ('"03dE"')
+        self.assertEqual ('', r.line)
+        r._set_line ('a.c d.f g.i  ')
+        r.input ('Escape')
+        r.input ('"03dE"')
+        self.assertEqual ('  ', r.line)
+
+    def test_delete_back_short_to_begining_of_line (self):
+        r = ViModeTest ()
+        r._set_line ('abc def ghi')
+        r.input ('Escape')
+        r.input ('"$3db"')
+        self.assertEqual ('i', r.line)
+        r._set_line ('abc def ghi  ')
+        r.input ('Escape')
+        r.input ('"$3db"')
+        self.assertEqual (' ', r.line)
+
+    def test_delete_back_long_to_begining_of_line (self):
+        r = ViModeTest ()
+        r._set_line ('a.c d.f g.i')
+        r.input ('Escape')
+        r.input ('"$3dB"')
+        self.assertEqual ('i', r.line)
+        r._set_line ('a.c d.f g.i  ')
+        r.input ('Escape')
+        r.input ('"$3dB"')
+        self.assertEqual (' ', r.line)
+
+    def test_delete_dollar (self):
+        r = ViModeTest ()
+        r._set_line ('abc def')
+        r.input ('Escape')
+        r.input ('"0ld$"')
+        self.assertEqual (r.line, 'a')
+        self.assertEqual (r.line_cursor, 0)
+
+    def test_motion_left (self):
+        r = ViModeTest ()
+        r._set_line ('abc def ghi')
+        r.input ('Escape')
+        r.input ('"$"')
+        self.assertEqual (10, r.line_cursor)
+        r.input ('"h"')
+        self.assertEqual (9, r.line_cursor)
+        r.input ('"2h"')
+        self.assertEqual (7, r.line_cursor)
+        r.input ('"2d3h"')
+        self.assertEqual (1, r.line_cursor)
+        self.assertEqual ('a ghi', r.line)
+        r.input ('"4dh"')
+        self.assertEqual (0, r.line_cursor)
+        self.assertEqual (' ghi', r.line)
+
+    def test_motion_right (self):
+        r = ViModeTest ()
+        r.input ('Escape')
+        self.assertEqual (r.line, '')
+        self.assertEqual (r.line_cursor, 0)
+        r.input ('"a"')
+        self.assertEqual (r.line, '')
+        self.assertEqual (r.line_cursor, 0)
+        r.input ('"abc"')
+        self.assertEqual (r.line, 'abc')
+        self.assertEqual (r.line_cursor, 3)
+        r.input ('Escape')
+        self.assertEqual (r.line, 'abc')
+        self.assertEqual (r.line_cursor, 2)
+        r.input ('"l"')
+        self.assertEqual (r.line, 'abc')
+        self.assertEqual (r.line_cursor, 2)
+        r.input ('Left')
+        self.assertEqual (r.line, 'abc')
+        self.assertEqual (r.line_cursor, 1)
+        r.input ('"l"')
+        self.assertEqual (r.line, 'abc')
+        self.assertEqual (r.line_cursor, 2)
+        r.input ('"l"')
+        self.assertEqual (r.line, 'abc')
+        self.assertEqual (r.line_cursor, 2)
+
+    def test_motion_right_delete (self):
+        r = ViModeTest ()
+        r._set_line ('abc def ghi')
+        r.input ('Escape')
+        r.input ('"0"')
+        self.assertEqual (0, r.line_cursor)
+        r.input ('"l"')
+        self.assertEqual (1, r.line_cursor)
+        r.input ('"2l"')
+        self.assertEqual (3, r.line_cursor)
+        r.input ('"2d3l"')
+        self.assertEqual (3, r.line_cursor)
+        self.assertEqual ('abchi', r.line)
+        r.input ('"4dl"')
+        self.assertEqual (2, r.line_cursor)
+        self.assertEqual ('abc', r.line)
+
+    def test_backspace_motion (self):
+        r = ViModeTest ()
+        r._set_line ('abc def ghi')
+        r.input ('Escape')
+        r.input ('"$"')
+        self.assertEqual (10, r.line_cursor)
+        r.input ('BackSpace')
+        self.assertEqual (9, r.line_cursor)
+        r.input ('"2"')
+        r.input ('BackSpace')
+        self.assertEqual (7, r.line_cursor)
+        r.input ('"2d3"')
+        r.input ('BackSpace')
+        self.assertEqual (1, r.line_cursor)
+        self.assertEqual ('a ghi', r.line)
+        r.input ('"4d"')
+        r.input ('BackSpace')
+        self.assertEqual (0, r.line_cursor)
+        self.assertEqual (' ghi', r.line)
+
+    def test_backspace_insert (self):
+        r = ViModeTest ()
+        r._set_line ('abc def ghi')
+        r.input ('Escape')
+        r.input ('"$"')
+        self.assertEqual (10, r.line_cursor)
+        r.input ('"i"')
+        self.assertEqual (10, r.line_cursor)
+        r.input ('BackSpace')
+        self.assertEqual (9, r.line_cursor)
+        self.assertEqual ('abc def gi', r.line)
+
+    def test_insert_lower_i (self):
+        r = ViModeTest ()
+        r._set_line ('abc def ghi')
+        r.input ('Escape')
+        r.input ('"0w"')
+        r.input ('"i"')
+        r.input ('"zz"')
+        self.assert_ (r.vi_is_insert_mode)
+        self.assertEqual (r.line, 'abc zzdef ghi')
+        r.input ('Escape')
+        r.input ('"w"')
+        r.input ('"2iyy"')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'abc zzdef yyyyghi')
+
+    def test_insert_upper_i (self):
+        r = ViModeTest ()
+        r._set_line ('abc def ghi')
+        r.input ('Escape')
+        r.input ('"0w"')
+        r.input ('"I"')
+        r.input ('"zz"')
+        self.assert_ (r.vi_is_insert_mode)
+        self.assertEqual (r.line, 'zzabc def ghi')
+        r.input ('Escape')
+        r.input ('"w"')
+        r.input ('"2Iyy"')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'yyyyzzabc def ghi')
+
+    def test_append_lower_a (self):
+        r = ViModeTest ()
+        r._set_line ('abc def ghi')
+        r.input ('Escape')
+        r.input ('"0"')
+        r.input ('"a"')
+        r.input ('"zz"')
+        self.assertEqual (r.line, 'azzbc def ghi')
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('Escape')
+        r.input ('"w"')
+        r.input ('"2ayy"')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'azzbc dyyyyef ghi')
+
+    def test_append_upper_a_simple (self):
+        r = ViModeTest ()
+        r._set_line ('')
+        r.input ('Escape')
+        r.input ('"2A"')
+        r.input ('"jj"')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'jjjj')
+        self.assert_ (not r.vi_is_insert_mode)
+
+    def test_append_upper_a (self):
+        r = ViModeTest ()
+        r._set_line ('abc def ghi')
+        r.input ('Escape')
+        r.input ('"0"')
+        r.input ('"A"')
+        r.input ('"zz"')
+        self.assertEqual (r.line, 'abc def ghizz')
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('Escape')
+        r.input ('"0w"')
+        r.input ('"2Ayy"')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'abc def ghizzyyyy')
+
+    def test_delete_lower_x (self):
+        r = ViModeTest ()
+        r._set_line ('abc def')
+        r.input ('Escape')
+        r.input ('"0w"')
+        r.input ('"x"')
+        self.assertEqual (r.line, 'abc ef')
+        r.input ('"4x"')
+        self.assertEqual (r.line, 'abc ')
+        self.assertEqual (r.line_cursor, 3)
+        r.input ('"x"')
+        self.assertEqual (r.line, 'abc')
+        self.assertEqual (r.line_cursor, 2)
+        r.input ('"x"')
+        self.assertEqual (r.line, 'ab')
+        self.assertEqual (r.line_cursor, 1)
+        r.input ('"x"')
+        self.assertEqual (r.line, 'a')
+        self.assertEqual (r.line_cursor, 0)
+        r.input ('"x"')
+        self.assertEqual (r.line, '')
+        self.assertEqual (r.line_cursor, 0)
+        r.input ('"x"')
+        self.assertEqual (r.line, '')
+        self.assertEqual (r.line_cursor, 0)
+
+    def test_delete_upper_x (self):
+        r = ViModeTest ()
+        r._set_line ('abc def')
+        self.assertEqual (r.line_cursor, 7)
+        r.input ('Escape')
+        self.assertEqual (r.line_cursor, 6)
+        r.input ('"$"')
+        self.assertEqual (r.line_cursor, 6)
+        r.input ('"X"')
+        self.assertEqual (r.line, 'abc df')
+        self.assertEqual (r.line_cursor, 5)
+        r.input ('"4X"')
+        self.assertEqual (r.line, 'af')
+        self.assertEqual (r.line_cursor, 1)
+        r.input ('"2X"')
+        self.assertEqual (r.line, 'f')
+        self.assertEqual (r.line_cursor, 0)
+        r.input ('"X"')
+        self.assertEqual (r.line, 'f')
+        self.assertEqual (r.line_cursor, 0)
+
+    def test_substitute_lower_s (self):
+        r = ViModeTest ()
+        r._set_line ('abc def')
+        r.input ('Escape')
+        r.input ('"0"')
+        r.input ('"s"')
+        r.input ('"qq"')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'qqbc def')
+        self.assertEqual (r.line_cursor, 1)
+        r.input ('"3s"')
+        r.input ('"yyy"')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'qyyy def')
+        self.assertEqual (r.line_cursor, 3)
+        r.input ('"w"')
+        r.input ('"5"')
+        r.input ('"s"')
+        r.input ('"zz"')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'qyyy zz')
+        self.assertEqual (r.line_cursor, 6)
+
+    def test_change_to_end_of_line (self):
+        r = ViModeTest ()
+        r._set_line ('abc def ghi')
+        r.input ('Escape')
+        r.input ('"0w"')
+        r.input ('"C"')
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('"123"')
+        self.assertEqual (r.line, 'abc 123')
+        r.input ('Escape')
+        self.assert_ (not r.vi_is_insert_mode)
+
+    def test_change_whole_line (self):
+        r = ViModeTest ()
+        r._set_line ('abc def ghi')
+        r.input ('Escape')
+        r.input ('"0w"')
+        r.input ('"S"')
+        self.assert_ (r.vi_is_insert_mode)
+        self.assertEqual (r.line, '')
+        r.input ('"123"')
+        self.assertEqual (r.line, '123')
+        r.input ('Escape')
+        self.assert_ (not r.vi_is_insert_mode)
+
+    def test_change_word_short (self):
+        r = ViModeTest ()
+        r._set_line ('abc def ghi')
+        r.input ('Escape')
+        r.input ('"0cwzzz"')
+        self.assert_ (r.vi_is_insert_mode)
+        self.assertEqual (r.line, 'zzz def ghi')
+        self.assertEqual (r.line_cursor, 3)
+        r.input ('Escape')
+        self.assert_ (not r.vi_is_insert_mode)
+        self.assertEqual (r.line_cursor, 2)
+        r.input ('"w"')
+        self.assertEqual (r.line_cursor, 4)
+        r.input ('"2cwyyy"')
+        self.assertEqual (r.line, 'zzz yyy')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'zzz yyy')
+
+    def test_change_word_long (self):
+        r = ViModeTest ()
+        r._set_line ('abc.def ghi.jkl mno.pqr')
+        r.input ('Escape')
+        r.input ('"0cWss"')
+        self.assertEqual (r.line, 'ss ghi.jkl mno.pqr')
+        self.assert_ (r.vi_is_insert_mode)
+        self.assertEqual (r.line_cursor, 2)
+        r.input ('Escape')
+        self.assert_ (not r.vi_is_insert_mode)
+        self.assertEqual (r.line_cursor, 1)
+        r.input ('"w2."')
+        self.assertEqual (r.line, 'ss ss')
+        self.assert_ (not r.vi_is_insert_mode)
+        self.assertEqual (r.line_cursor, 4)
+
+    def test_change_end_short (self):
+        r = ViModeTest ()
+        r._set_line ('abc def ghi')
+        r.input ('Escape')
+        r.input ('"0cezzz"')
+        self.assert_ (r.vi_is_insert_mode)
+        self.assertEqual (r.line, 'zzz def ghi')
+        self.assertEqual (r.line_cursor, 3)
+        r.input ('Escape')
+        self.assert_ (not r.vi_is_insert_mode)
+        self.assertEqual (r.line_cursor, 2)
+        r.input ('"w2."')
+        self.assertEqual (r.line, 'zzz zzz')
+
+    def test_change_end_long (self):
+        r = ViModeTest ()
+        r._set_line ('abc.def ghi jkl.mno pqr stu.vwx')
+        r.input ('Escape')
+        r.input ('"02cEzz"')
+        self.assert_ (r.vi_is_insert_mode)
+        self.assertEqual (r.line, 'zz jkl.mno pqr stu.vwx')
+        self.assertEqual (r.line_cursor, 2)
+        r.input ('Escape')
+        self.assert_ (not r.vi_is_insert_mode)
+        self.assertEqual (r.line_cursor, 1)
+        r.input ('"w2."')
+        self.assertEqual (r.line, 'zz zz stu.vwx')
+        self.assertEqual (r.line_cursor, 5)
+
+    def test_change_back_short (self):
+        r = ViModeTest ()
+        r._set_line ('abc def ghi')
+        r.input ('Escape')
+        r.input ('"$cbzz"')
+        self.assert_ (r.vi_is_insert_mode)
+        self.assertEqual (r.line, 'abc def zzi')
+        self.assertEqual (r.line_cursor, 10)
+        r.input ('Escape')
+        self.assert_ (not r.vi_is_insert_mode)
+        self.assertEqual (r.line_cursor, 9)
+        r.input ('"b2."')
+        self.assertEqual (r.line, 'zzzzi')
+        self.assertEqual (r.line_cursor, 2)
+
+    def test_change_back_long (self):
+        r = ViModeTest ()
+        r._set_line ('abc.def ghi jkl.mno pqr stu.vwx')
+        r.input ('Escape')
+        r.input ('"$2cBzz"')
+        self.assert_ (r.vi_is_insert_mode)
+        self.assertEqual (r.line, 'abc.def ghi jkl.mno zzx')
+        self.assertEqual (r.line_cursor, 22)
+        r.input ('Escape')
+        self.assert_ (not r.vi_is_insert_mode)
+        self.assertEqual (r.line_cursor, 21)
+        r.input ('"5."')
+        self.assertEqual (r.line, 'zzzx')
+        self.assertEqual (r.line_cursor, 2)
+        self.assert_ (not r.vi_is_insert_mode)
+
+    def test_change_find_lower (self):
+        r = ViModeTest ()
+        r._set_line ('aa bb cc dd ee aa bb cc dd ee')
+        r.input ('Escape')
+        r.input ('"0cfbzz"')
+        self.assert_ (r.vi_is_insert_mode)
+        self.assertEqual (r.line, 'zzb cc dd ee aa bb cc dd ee')
+        self.assertEqual (r.line_cursor, 2)
+        r.input ('Escape')
+        self.assert_ (not r.vi_is_insert_mode)
+        self.assertEqual (r.line_cursor, 1)
+        r.input ('"c2fcyy"')
+        self.assertEqual (r.line, 'zyy dd ee aa bb cc dd ee')
+        r.input ('Escape')
+        r.input ('"."')
+        self.assertEqual (r.line, 'zyyy dd ee')
+
+    def test_change_find_upper (self):
+        r = ViModeTest ()
+        r._set_line ('aa bb cc aa bb cc')
+        r.input ('Escape')
+        r.input ('"$2c2Fazz"')
+        self.assert_ (r.vi_is_insert_mode)
+        self.assertEqual (r.line, 'zzc')
+        self.assertEqual (r.line_cursor, 2)
+        r.input ('Escape')
+        self.assert_ (not r.vi_is_insert_mode)
+        self.assertEqual (r.line_cursor, 1)
+        r.input ('"."')
+        self.assertEqual (r.line, 'zzc')
+
+    def test_change_to_lower (self):
+        r = ViModeTest ()
+        r._set_line ('aa bb cc aa bb cc aa bb cc')
+        r.input ('Escape')
+        r.input ('"02c2ta"')
+        self.assert_ (r.vi_is_insert_mode)
+        self.assertEqual (r.line, 'aa bb cc')
+        self.assertEqual (r.line_cursor, 0)
+        r.input ('"zz "')
+        self.assertEqual (r.line, 'zz aa bb cc')
+        self.assertEqual (r.line_cursor, 3)
+        r.input ('Escape')
+        self.assert_ (not r.vi_is_insert_mode)
+        self.assertEqual (r.line_cursor, 2)
+
+    def test_change_to_upper (self):
+        r = ViModeTest ()
+        r._set_line ('aa bb cc aa bb cc aa bb cc')
+        r.input ('Escape')
+        r.input ('"$2c2Ta"')
+        self.assert_ (r.vi_is_insert_mode)
+        self.assertEqual (r.line, 'aa bb cc ac')
+        self.assertEqual (r.line_cursor, 10)
+        r.input ('"zz"')
+        self.assertEqual (r.line, 'aa bb cc azzc')
+        self.assertEqual (r.line_cursor, 12)
+        r.input ('Escape')
+        self.assert_ (not r.vi_is_insert_mode)
+        self.assertEqual (r.line_cursor, 11)
+        r.input ('"3."')
+        self.assertEqual (r.line, 'azzzc')
+        # The following fails but it does not seem that important
+        # self.assertEqual (r.line_cursor, 2)
+        self.assert_ (not r.vi_is_insert_mode)
+
+    def test_pos_matching (self):
+        self.assertEqual (6, vi_pos_matching ('aa (bb)'))
+        self.assertEqual (6, vi_pos_matching ('aa (bb)', 3))
+        self.assertEqual (3, vi_pos_matching ('aa (bb)', 6))
+        self.assertEqual (11, vi_pos_matching ('aa (bb (cc))'))
+        self.assertEqual (3, vi_pos_matching ('aa (bb (cc))', 11))
+        self.assertEqual (10, vi_pos_matching ('aa (bb (cc))', 4))
+        self.assertEqual (7, vi_pos_matching ('aa (bb (cc))', 10))
+        self.assertEqual (7, vi_pos_matching ('aa (bb (cc))', 8))
+        self.assertEqual (3, vi_pos_matching ('aa (bb (cc) dd)', 12))
+        self.assertEqual (3, vi_pos_matching ('aa (bb (cc) dd)', 14))
+        self.assertEqual (-1, vi_pos_matching ('aa ((bb (cc) dd)', 3))
+        self.assertEqual (-1, vi_pos_matching ('aa (bb (cc) dd) ee)', 16))
+        self.assertEqual (-1, vi_pos_matching ('aa (bb (cc) dd) ee)', 18))
+        self.assertEqual (6, vi_pos_matching ('aa <bb>'))
+        self.assertEqual (11, vi_pos_matching ('aa <bb <cc>>'))
+        self.assertEqual (10, vi_pos_matching ('aa <bb <cc>>', 4))
+        self.assertEqual (6, vi_pos_matching ('aa {bb}'))
+        self.assertEqual (11, vi_pos_matching ('aa {bb {cc}}'))
+        self.assertEqual (10, vi_pos_matching ('aa {bb {cc}}', 4))
+        self.assertEqual (6, vi_pos_matching ('aa [bb]'))
+        self.assertEqual (11, vi_pos_matching ('aa [bb [cc]]'))
+        self.assertEqual (10, vi_pos_matching ('aa [bb [cc]]', 4))
+
+    def test_matching_paren_forward (self):
+        r = ViModeTest ()
+        r._set_line ('abc (def (ghi)) jkl')
+        r.input ('Escape')
+        r.input ('"0w"')
+        r.input ('"d"')
+        r.input ('"%"')
+        self.assertEqual (r.line, 'abc  jkl')
+        self.assertEqual (r.line_cursor, 4)
+
+    def test_matching_paren_backward (self):
+        r = ViModeTest ()
+        r._set_line ('abc (def (ghi)) jkl')
+        r.input ('Escape')
+        r.input ('"0w"')
+        r.input ('"%"')
+        self.assertEqual (r.line_cursor, 14)
+        r.input ('"d"')
+        r.input ('"%"')
+        self.assertEqual (r.line, 'abc  jkl')
+        self.assertEqual (r.line_cursor, 4)
+
+    def test_yank_and_put (self):
+        r = ViModeTest ()
+        r._set_line ('abc def')
+        r.input ('Escape')
+        r.input ('"0"')
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('"yw"')
+        self.assert_ (not r.vi_is_insert_mode)
+        self.assertEqual (r.line, 'abc def')
+        self.assertEqual (r.line_cursor, 0)
+        r.input ('"P"')
+        self.assertEqual (r.line, 'abc abc def')
+        self.assertEqual (r.line_cursor, 3)
+        r.input ('"p"')
+        self.assertEqual (r.line, 'abc abc abc def')
+        self.assertEqual (r.line_cursor, 7)
+
+    def test_put_multiple (self):
+        r = ViModeTest ()
+        r._set_line ('001122')
+        r.input ('Escape')
+        r.input ('"0"')
+        r.input ('"y3l"')
+        self.assert_ (not r.vi_is_insert_mode)
+        self.assertEqual (r.line_cursor, 0)
+        r.input ('"2P"')
+        self.assertEqual (r.line, '001001001122')
+        self.assertEqual (r.line_cursor, 5)
+        r.input ('"f2"')
+        r.input ('"3p"')
+        self.assertEqual (r.line, '001001001120010010012')
+        self.assertEqual (r.line_cursor, 19)
+
+    def test_put_undo (self):
+        r = ViModeTest ()
+        r._set_line ('aaa b ccc')
+        r.input ('Escape')
+        r.input ('"0ywwp"')
+        self.assertEqual (r.line, 'aaa baaa  ccc')
+        r.input ('"u"')
+        self.assertEqual (r.line, 'aaa b ccc')
+        r.input ('"P"')
+        self.assertEqual (r.line, 'aaa aaa b ccc')
+        r.input ('"u"')
+        self.assertEqual (r.line, 'aaa b ccc')
+
+    def test_x_and_p (self):
+        r = ViModeTest ()
+        r._set_line ('abc')
+        r.input ('Escape')
+        r.input ('"0xp"')
+        self.assertEqual (r.line, 'bac')
+
+    def test_delete_and_put (self):
+        r = ViModeTest ()
+        r._set_line ('abc def')
+        r.input ('Escape')
+        r.input ('"0dwep"')
+        self.assertEqual (r.line, 'defabc ')
+        r.input ('"0xp"')
+        self.assertEqual (r.line, 'edfabc ')
+        r.input ('"p"')
+        self.assertEqual (r.line, 'eddfabc ')
+
+    def test_dot_simple (self):
+        r = ViModeTest ()
+        r._set_line ('abc def')
+        r.input ('Escape')
+        r.input ('"0x"')
+        self.assertEqual (r.line, 'bc def')
+        r.input ('"."')
+        self.assertEqual (r.line, 'c def')
+        r.input ('"3."')
+        self.assertEqual (r.line, 'ef')
+
+    def test_dot_movement_not_repeated_one (self):
+        r = ViModeTest ()
+        r._set_line ('abc def')
+        r.input ('Escape')
+        r.input ('"0x"')
+        self.assertEqual (r.line, 'bc def')
+        r.input ('"$."')
+        self.assertEqual (r.line, 'bc de')
+        r.input ('"0."')
+        self.assertEqual (r.line, 'c de')
+        r.input ('"$."')
+        self.assertEqual (r.line, 'c d')
+        r.input ('"^."')
+        self.assertEqual (r.line, ' d')
+
+    def test_dot_movement_not_repeated_two (self):
+        r = ViModeTest ()
+        r._set_line ('abc def ghi jkl mno pqr')
+        r.input ('Escape')
+        r.input ('"0x"')
+        self.assertEqual (r.line, 'bc def ghi jkl mno pqr')
+        r.input ('"w."')
+        self.assertEqual (r.line, 'bc ef ghi jkl mno pqr')
+        r.input ('"fg."')
+        self.assertEqual (r.line, 'bc ef hi jkl mno pqr')
+        r.input ('"2b."')
+        self.assertEqual (r.line, 'c ef hi jkl mno pqr')
+        r.input ('"3e."')
+        self.assertEqual (r.line, 'c ef hi jk mno pqr')
+        r.input ('"Fh."')
+        self.assertEqual (r.line, 'c ef i jk mno pqr')
+        r.input ('"tn."')
+        self.assertEqual (r.line, 'c ef i jk no pqr')
+        r.input ('"3h."')
+        self.assertEqual (r.line, 'c ef i k no pqr')
+        r.input ('"5l."')
+        self.assertEqual (r.line, 'c ef i k no qr')
+
+    def test_dot_insert (self):
+        r = ViModeTest ()
+        r._set_line ('abc def')
+        r.input ('Escape')
+        r.input ('"0"')
+        r.input ('"2izz "')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'zz zz abc def')
+        r.input ('"2w."')
+        self.assertEqual (r.line, 'zz zz abc zz zz def')
+
+    def test_dot_delete_word (self):
+        r = ViModeTest ()
+        r._set_line ('0 1 2 3 4 5 6 7 8 9')
+        r.input ('Escape')
+        r.input ('"02dw"')
+        self.assertEqual (r.line, '2 3 4 5 6 7 8 9')
+        r.input ('"."')
+        self.assertEqual (r.line, '4 5 6 7 8 9')
+        r.input ('"1."')
+        self.assertEqual (r.line, '5 6 7 8 9')
+
+    def test_dot_override_multiplier (self):
+        r = ViModeTest ()
+        r._set_line ('ab ab ab ab  ab ab ab ab  ab ab ab ab  ab ab ab ab')
+        r.input ('Escape')
+        r.input ('"02d2fb"')
+        self.assertEqual (r.line, '  ab ab ab ab  ab ab ab ab  ab ab ab ab')
+        r.input ('"."')
+        self.assertEqual (r.line, '  ab ab ab ab  ab ab ab ab')
+        r.input ('"3."')
+        self.assertEqual (r.line, ' ab  ab ab ab ab')
+        r.input ('"."')
+        self.assertEqual (r.line, ' ab ab')
+
+    def test_dot_yank_and_put (self):
+        r = ViModeTest ()
+        r._set_line ('abc def')
+        r.input ('Escape')
+        r.input ('"0ywP"')
+        self.assertEqual (r.line, 'abc abc def')
+        r.input ('"."')
+        self.assertEqual (r.line, 'abcabc  abc def')
+        r.input ('"p"')
+        self.assertEqual (r.line, 'abcabc abc  abc def')
+        r.input ('"2."')
+        self.assertEqual (r.line, 'abcabc abc abc abc  abc def')
+
+    def test_dot_insert_begin (self):
+        r = ViModeTest ()
+        r._set_line ('abc def')
+        r.input ('Escape')
+        r.input ('"Izz "')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'zz abc def')
+        r.input ('"."')
+        self.assertEqual (r.line, 'zz zz abc def')
+        r.input ('"2."')
+        self.assertEqual (r.line, 'zz zz zz zz abc def')
+
+    def test_dot_append_end (self):
+        r = ViModeTest ()
+        r._set_line ('abc def')
+        r.input ('Escape')
+        r.input ('"A yy"')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'abc def yy')
+        r.input ('"."')
+        self.assertEqual (r.line, 'abc def yy yy')
+        r.input ('"2."')
+        self.assertEqual (r.line, 'abc def yy yy yy yy')
+
+    def test_dot_insert_lower (self):
+        r = ViModeTest ()
+        r._set_line ('abc def')
+        r.input ('Escape')
+        r.input ('"b2izz "')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'abc zz zz def')
+        r.input ('"3."')
+        self.assertEqual (r.line, 'abc zz zzzz zz zz  def')
+
+    def test_dot_append_lower (self):
+        r = ViModeTest ()
+        r._set_line ('abc def')
+        r.input ('Escape')
+        r.input ('"0e2a zz"')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'abc zz zz def')
+        r.input ('"1."')
+        self.assertEqual (r.line, 'abc zz zz zz def')
+
+    def test_dot_substitute_lower (self):
+        r = ViModeTest ()
+        r._set_line ('abc def')
+        r.input ('Escape')
+        r.input ('"03sqq"')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'qq def')
+        r.input ('"2."')
+        self.assertEqual (r.line, 'qqqdef')
+
+    def test_undo (self):
+        r = ViModeTest ()
+        r._set_line ('abc def ghi')
+        r.input ('Escape')
+        r.input ('"0wdw"')
+        self.assertEqual (r.line, 'abc ghi')
+        self.assertEqual (r.line_cursor, 4)
+        r.input ('"u"')
+        self.assertEqual (r.line, 'abc def ghi')
+        self.assertEqual (r.line_cursor, 4)
+
+    def test_undo_line (self):
+        r = ViModeTest ()
+        r._set_line ('')
+        r.input ('"abc def ghi"')
+        r.input ('Escape')
+        r.input ('"0dwdw"')
+        self.assertEqual (r.line, 'ghi')
+        r.input ('"U"')
+        self.assertEqual (r.line, '')
+
+    def test_undo_line_with_history (self):
+        r = ViModeTest ()
+        r.add_history ('abc 123')
+        r._set_line ('')
+        r.input ('"abc def ghi"')
+        r.input ('Escape')
+        r.input ('"0dwdw"')
+        self.assertEqual (r.line, 'ghi')
+        r.input ('"U"')
+        self.assertEqual (r.line, '')
+
+    def test_history_no_match (self):
+        r = ViModeTest ()
+        r.add_history ('abc 123')
+        r.add_history ('def 456')
+        r.add_history ('ghi 789')
+        r._set_line ('abc def ghi')
+        r.input ('Escape')
+        r.input ('"/"')
+        self.assertEqual (r.line, '/')
+        self.assertEqual (r.line_cursor, 1)
+        r.input ('"zz"')
+        self.assertEqual (r.line, '/zz')
+        self.assertEqual (r.line_cursor, 3)
+        self.assertEqual (r.console.bell_count, 0)
+        r.input ('Return')
+        # TODO should bell be rung here?
+        # self.assertEqual (r.console.bell_count, 1)
+        self.assertEqual (r.line, 'abc def ghi')
+        self.assertEqual (r.line_cursor, 10)
+
+    def test_history_found_match (self):
+        r = ViModeTest ()
+        r.add_history ('abc 123')
+        r.add_history ('def 456')
+        r.add_history ('ghi 789')
+        r._set_line ('abc def ghi')
+        r.input ('Escape')
+        r.input ('"/"')
+        self.assertEqual (r.line, '/')
+        self.assertEqual (r.line_cursor, 1)
+        r.input ('"de"')
+        self.assertEqual (r.line, '/de')
+        self.assertEqual (r.line_cursor, 3)
+        r.input ('Return')
+        self.assertEqual (r.line, 'def 456')
+        self.assertEqual (r.line_cursor, 0)
+
+    def test_history_multi_match (self):
+        r = ViModeTest ()
+        r.add_history ('xyz 123')
+        r.add_history ('xyz 456')
+        r.add_history ('xyz 789')
+        r._set_line ('abc def')
+        r.input ('Escape')
+        r.input ('"/xyz"')
+        r.input ('Return')
+        self.assertEqual (r.line, 'xyz 789')
+        r.input ('"n"')
+        self.assertEqual (r.line, 'xyz 456')
+        r.input ('"n"')
+        self.assertEqual (r.line, 'xyz 123')
+        self.assertEqual (r.console.bell_count, 0)
+        r.input ('"n"')
+        # TODO check bell ringing
+        # self.assertEqual (r.console.bell_count, 1)
+        self.assertEqual (r.line, 'xyz 123')
+        r.input ('"N"')
+        self.assertEqual (r.line, 'xyz 456')
+        r.input ('"N"')
+        self.assertEqual (r.line, 'xyz 789')
+        # TODO check bell ringing
+        # self.assertEqual (r.console.bell_count, 1)
+        r.input ('"N"')
+        # TODO check bell ringing
+        # self.assertEqual (r.console.bell_count, 2)
+        self.assertEqual (r.line, 'xyz 789')
+
+    def test_history_search_empty_string (self):
+        r = ViModeTest ()
+        r.add_history ('xyz 123')
+        r.add_history ('xyz 456')
+        r.add_history ('xyz 789')
+        r.input ('Escape')
+        r.input ('"/"')
+        r.input ('Return')
+        self.assertEqual (r.line, '')
+        # TODO check bell ringing
+        # self.assertEqual (r.console.bell_count, 1)
+        r.input ('"/"')
+        r.input ('Return')
+        self.assertEqual (r.line, '')
+        # TODO check bell ringing
+        # self.assertEqual (r.console.bell_count, 2)
+        r.input ('"/x"')
+        r.input ('Return')
+        self.assertEqual (r.line, 'xyz 789')
+        r.input ('"/"')
+        r.input ('Return')
+        self.assertEqual (r.line, 'xyz 456')
+
+    def test_history_search_again_after_return (self):
+        r = ViModeTest ()
+        r.add_history ('xyz 123')
+        r.add_history ('xyz 456')
+        r.add_history ('xyz 789')
+        r._set_line ('abc def')
+        r.input ('Escape')
+        r.input ('"/xyz"')
+        r.input ('Return')
+        self.assertEqual (r.line, 'xyz 789')
+        r.input ('"n"')
+        self.assertEqual (r.line, 'xyz 456')
+        r.input ('Return')
+        self.assertEqual (r.line, '')
+        r.input ('Escape')
+        r.input ('"n"')
+        self.assertEqual (r.line, 'xyz 123')
+        r.input ('Return')
+        r.input ('Escape')
+        r.input ('"N"')
+        self.assertEqual (r.line, 'xyz 456')
+
+    def test_history_search_again_after_search_failed (self):
+        r = ViModeTest ()
+        r.add_history ('xyz 123')
+        r.add_history ('xyz 456')
+        r.add_history ('xyz 789')
+        r._set_line ('abc def')
+        r.input ('Escape')
+        r.input ('"/xyz"')
+        r.input ('Return')
+        self.assertEqual (r.line, 'xyz 789')
+        r.input ('"C"')
+        self.assertEqual (r.line, '')
+        r.input ('Escape')
+        self.assertEqual (r.console.bell_count, 0)
+        r.input ('"/abc"')
+        r.input ('Return')
+        # TODO check bell ringing
+        # self.assertEqual (r.console.bell_count, 1)
+        self.assertEqual (r.line, '')
+        r.input ('Escape')
+        r.input ('"n"')
+        self.assertEqual (r.line, '')
+
+    def test_history_search_and_backspace (self):
+        r = ViModeTest ()
+        r.add_history ('aaa')
+        r.add_history ('bbb')
+        r._set_line ('')
+        r.input ('Escape')
+        r.input ('"/aaz"')
+        self.assertEqual (r.line, '/aaz')
+        r.input ('BackSpace')
+        self.assertEqual (r.line, '/aa')
+        r.input ('Return')
+        self.assertEqual (r.line, 'aaa')
+        r.input ('Escape')
+        r.input ('"/z"')
+        r.input ('BackSpace')
+        r.input ('BackSpace')
+        self.assertEqual (r.line, '')
+        r.input ('"j"')
+        self.assertEqual (r.line, 'bbb')
+        r.input ('"k"')
+        self.assertEqual (r.line, 'aaa')
+
+    def test_history_insert_mode (self):
+        r = ViModeTest ()
+        r.add_history ('aaa')
+        r.add_history ('bbb')
+        r.add_history ('ccc')
+        r.input ('Up')
+        self.assertEqual (r.line, 'ccc')
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('"z"')
+        self.assertEqual (r.line, 'cccz')
+        r.input ('Escape')
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('Up')
+        self.assertEqual (r.line, 'bbb')
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('"z"')
+        self.assertEqual (r.line, 'bbbz')
+        r.input ('Escape')
+        r.input ('"k"')
+        self.assertEqual (r.line, 'aaa')
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('"iz"')
+        self.assertEqual (r.line, 'zaaa')
+        r.input ('Down')
+        self.assertEqual (r.line, 'bbb')
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('"y"')
+        self.assertEqual (r.line, 'bbby')
+        r.input ('Escape')
+        r.input ('"j"')
+        self.assertEqual (r.line, 'ccc')
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('"iy"')
+        self.assertEqual (r.line, 'yccc')
+        self.assert_ (r.vi_is_insert_mode)
+
+    def test_history_cursor_arrow (self):
+        r = ViModeTest ()
+        self.assertEqual (r._history.history_cursor, 0)
+        r.add_history ('aaa')
+        self.assertEqual (r._history.history_cursor, 1)
+        r.add_history ('bbb')
+        self.assertEqual (r._history.history_cursor, 2)
+        self.assertEqual (r.line, '')
+        r.input ('Up')
+        self.assertEqual (r._history.history_cursor, 1)
+        self.assertEqual (r.line, 'bbb')
+        r.input ('Up')
+        self.assertEqual (r._history.history_cursor, 0)
+        self.assertEqual (r.line, 'aaa')
+        r.input ('Down')
+        self.assertEqual (r._history.history_cursor, 1)
+        self.assertEqual (r.line, 'bbb')
+        r.input ('Down')
+        self.assertEqual (r._history.history_cursor, 2)
+        self.assertEqual (r.line, '')
+        r.input ('Up')
+        self.assertEqual (r._history.history_cursor, 1)
+        self.assertEqual (r.line, 'bbb')
+
+    def test_history_control_n_and_p (self):
+        r = ViModeTest ()
+        r.add_history ('aa')
+        r.add_history ('bbb')
+        self.assertEqual (r.line, '')
+        r.input ('Control-p')
+        self.assertEqual (r.line, 'bbb')
+        self.assertEqual (r.line_cursor, 3)
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('Control-p')
+        self.assertEqual (r.line, 'aa')
+        self.assertEqual (r.line_cursor, 2)
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('Control-n')
+        self.assertEqual (r.line, 'bbb')
+        self.assertEqual (r.line_cursor, 3)
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('Control-n')
+        self.assertEqual (r.line, '')
+        self.assertEqual (r.line_cursor, 0)
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('Control-p')
+        self.assertEqual (r.line, 'bbb')
+        self.assertEqual (r.line_cursor, 3)
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('Escape')
+        self.assertEqual (r.line, 'bbb')
+        self.assertEqual (r.line_cursor, 2)
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('Control-p')
+        self.assertEqual (r.line, 'aa')
+        self.assertEqual (r.line_cursor, 0)
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('Control-n')
+        self.assertEqual (r.line, 'bbb')
+        self.assertEqual (r.line_cursor, 0)
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('Control-n')
+        self.assertEqual (r.line, '')
+        self.assertEqual (r.line_cursor, 0)
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('"/a"')
+        r.input ('Return')
+        self.assertEqual (r.line, 'aa')
+        self.assertEqual (r.line_cursor, 0)
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('Control-n')
+        self.assertEqual (r.line, 'bbb')
+        self.assertEqual (r.line_cursor, 0)
+        self.assert_ (not r.vi_is_insert_mode)
+
+    def test_history_cursor_j_and_k (self):
+        r = ViModeTest ()
+        r.add_history ('aaa')
+        r.input ('Escape')
+        r.input ('"kiz"')
+        self.assertEqual (r.line, 'zaaa')
+        r.input ('Escape')
+        r.input ('"j"')
+        self.assertEqual (r.line, '')
+
+    def test_history_input_j_and_k (self):
+        r = ViModeTest ()
+        r.add_history ('aaa')
+        r.input ('Escape')
+        r.input ('"kAjk"')
+        self.assertEqual (r.line, 'aaajk')
+
+    def test_history_cursor_search (self):
+        r = ViModeTest ()
+        r.add_history ('aaa')
+        r.input ('Escape')
+        r.input ('"/a"')
+        r.input ('Return')
+        self.assertEqual (r.line, 'aaa')
+        r.input ('"iz"')
+        self.assertEqual (r.line, 'zaaa')
+        self.assertEqual (r.console.bell_count, 0)
+        r.input ('Escape')
+        r.input ('"j"')
+        self.assertEqual (r.line, 'zaaa')
+        # TODO check bell ringing
+        # self.assertEqual (r.console.bell_count, 1)
+
+    def test_history_undo (self):
+        r = ViModeTest ()
+        r.add_history ('aaa')
+        r.input ('Escape')
+        r.input ('"k"')
+        r.input ('"A b"')
+        r.input ('Escape')
+        r.input ('"A c"')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'aaa b c')
+        r.input ('"U"')
+        self.assertEqual (r.line, 'aaa')
+
+    def test_history_arrow_undo (self):
+        r = ViModeTest ()
+        r.add_history ('aaa')
+        r.input ('Up')
+        r.input ('" zz"')
+        self.assertEqual (r.line, 'aaa zz')
+        r.input ('Escape')
+        r.input ('"u"')
+        self.assertEqual (r.line, 'aaa')
+
+# TODO: mode support?
+#     def test_mode (self):
+#         r = ViModeTest ()
+#         self.assertEqual (r.editing_mode, Readline.mode_vi)
+#         self.assertEqual (r.mode (verbose=False), Readline.mode_vi)
+#         self.assertEqual (r.count_vi_editing_mode, 1)
+#         self.assertEqual (r.count_emacs_editing_mode, 0)
+#         r.vi ()
+#         self.assertEqual (r.editing_mode, Readline.mode_vi)
+#         self.assertEqual (r.mode (verbose=False), Readline.mode_vi)
+#         self.assertEqual (r.count_vi_editing_mode, 1)
+#         self.assertEqual (r.count_emacs_editing_mode, 0)
+#         r.emacs ()
+#         self.assertEqual (r.editing_mode, Readline.mode_emacs)
+#         self.assertEqual (r.mode (verbose=False), Readline.mode_emacs)
+#         self.assertEqual (r.count_vi_editing_mode, 1)
+#         self.assertEqual (r.count_emacs_editing_mode, 1)
+#         r.emacs ()
+#         self.assertEqual (r.editing_mode, Readline.mode_emacs)
+#         self.assertEqual (r.mode (verbose=False), Readline.mode_emacs)
+#         self.assertEqual (r.count_vi_editing_mode, 1)
+#         self.assertEqual (r.count_emacs_editing_mode, 1)
+#         r.vi ()
+#         self.assertEqual (r.editing_mode, Readline.mode_vi)
+#         self.assertEqual (r.mode (verbose=False), Readline.mode_vi)
+#         self.assertEqual (r.count_vi_editing_mode, 2)
+#         self.assertEqual (r.count_emacs_editing_mode, 1)
+#
+#     def test_switch_mode (self):
+#         r = ViModeTest ()
+#         r._set_line ('')
+#         r.input ('Escape')
+#         self.assertEqual (r.editing_mode, Readline.mode_vi)
+#         self.assertEqual (r.count_vi_editing_mode, 1)
+#         self.assertEqual (r.count_emacs_editing_mode, 0)
+#         r.input ('"abc"')
+#         r.input ('Control-e')
+#         self.assertEqual (r.editing_mode, Readline.mode_emacs)
+#         self.assertEqual (r.count_vi_editing_mode, 1)
+#         self.assertEqual (r.count_emacs_editing_mode, 1)
+#         r.input ('Meta-Control-j')
+#         self.assertEqual (r.editing_mode, Readline.mode_vi)
+#         self.assertEqual (r.count_vi_editing_mode, 2)
+#         self.assertEqual (r.count_emacs_editing_mode, 1)
+
+# TODO: show history support?
+#     def test_history_output (self):
+#         import StringIO
+#         sio = StringIO.StringIO ()
+#         r = ViModeTest ()
+#         r.add_history ('abc')
+#         r.add_history ('def')
+#         r.add_history ('ghi')
+#         r.show_history (sio)
+#         sio.seek (0)
+#         self.assertEqual (sio.read(), '  1 abc\n  2 def\n  3 ghi\n')
+
+    def test_editor (self):
+        vee = ViExternalEditorTest ('qwerty before')
+        self.assert_ (vee.sio_write.closed)
+        self.assertEqual (vee.command, 'vim.exe temp.py')
+        self.assert_ (vee.sio_read.closed)
+        self.assertEqual (vee.remove, 'temp.py')
+        self.assertEqual (vee.result, 'qwerty after')
+
+    def test_completer (self):
+        r = ViModeTest ()
+        r.lst_completions = ['aab', 'aac', 'aad', ]
+        r.input ('"aa"')
+        r.input ('Tab')
+        self.assertEqual (r.line, 'aa')
+        self.assertEqual (r.console.text, '\naab \naac \naad \n')
+
+    def test_completer_star (self):
+        r = ViModeTest ()
+        r.lst_completions = ['bbc', 'bbd', 'bbe', ]
+        r.input ('"aa bb"')
+        r.input ('Escape')
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('"*"')
+        self.assertEqual (r.line, 'aa bbc bbd bbe ')
+        self.assertEqual (r.line_cursor, 15)
+        self.assert_ (r.vi_is_insert_mode)
+        self.assertEqual (r.console.text, '')
+        r.input ('" "')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'aa bbc bbd bbe  ')
+        self.assertEqual (r.line_cursor, 15)
+        r.input ('"."')
+        self.assertEqual (r.line, 'aa bbc bbd bbe bbc bbd bbe ')
+        self.assertEqual (r.line_cursor, 27)
+
+    def test_completer_beginning_of_line (self):
+        r = ViModeTest ()
+        r.input ('Tab')
+        self.assertEqual (r.line, '    ')
+        self.assertEqual (r.line_cursor, 4)
+        r.input ('Space')
+        self.assertEqual (r.line, '     ')
+        self.assertEqual (r.line_cursor, 5)
+        r.input ('Tab')
+        self.assertEqual (r.line, '        ')
+        self.assertEqual (r.line_cursor, 8)
+        r.input ('Space')
+        r.input ('Space')
+        r.input ('Space')
+        self.assertEqual (r.line, '           ')
+        self.assertEqual (r.line_cursor, 11)
+        r.input ('Tab')
+        self.assertEqual (r.line, '            ')
+        self.assertEqual (r.line_cursor, 12)
+        r.input ('Tab')
+        self.assertEqual (r.line, '                ')
+        self.assertEqual (r.line_cursor, 16)
+
+    def test_replace_lower (self):
+        r = ViModeTest ()
+        r._set_line ('aaa bbb ccc')
+        r.input ('Escape')
+        r.input ('"0ry"')
+        self.assertEqual (r.line, 'yaa bbb ccc')
+        self.assertEqual (r.line_cursor, 0)
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('"i"')
+        self.assertEqual (r.line, 'yaa bbb ccc')
+        self.assertEqual (r.line_cursor, 0)
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('"x"')
+        self.assertEqual (r.line, 'xyaa bbb ccc')
+        self.assertEqual (r.line_cursor, 1)
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('Escape')
+        self.assertEqual (r.line, 'xyaa bbb ccc')
+        self.assertEqual (r.line_cursor, 0)
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('"ll"')
+        r.input ('"2rz"')
+        self.assertEqual (r.line, 'xyzz bbb ccc')
+        self.assertEqual (r.line_cursor, 3)
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('"w7."')
+        self.assertEqual (r.line, 'xyzz zzzzzzz')
+        self.assertEqual (r.line_cursor, 11)
+        self.assert_ (not r.vi_is_insert_mode)
+
+    def test_replace_lower_undo (self):
+        r = ViModeTest ()
+        r._set_line ('aaa')
+        r.input ('Escape')
+        # print 'xx', sys._getframe().f_lineno, r._vi_undo_cursor, r._vi_undo_stack
+        r.input ('"0rz"')
+        self.assertEqual (r.line, 'zaa')
+        r.input ('"u"')
+        self.assertEqual (r.line, 'aaa')
+        r.input ('"2."')
+        self.assertEqual (r.line, 'zza')
+        r.input ('"u"')
+        self.assertEqual (r.line, 'aaa')
+
+    def test_replace_lower_escape (self):
+        r = ViModeTest ()
+        r._set_line ('aaa')
+        r.input ('Escape')
+        r.input ('"0r"')
+        self.assertEqual (r.line, 'aaa')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'aaa')
+        r.input ('"r"')
+        self.assertEqual (r.line, 'aaa')
+        r.input ('"z"')
+        self.assertEqual (r.line, 'zaa')
+
+    def test_replace_lower_escape_undo (self):
+        r = ViModeTest ()
+        r._set_line ('aa bb cc')
+        r.input ('Escape')
+        r.input ('"0cwdd"')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'dd bb cc')
+        r.input ('"wr"')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'dd bb cc')
+        r.input ('"."')
+        self.assertEqual (r.line, 'dd dd cc')
+        r.input ('"u"')
+        self.assertEqual (r.line, 'dd bb cc')
+        r.input ('"u"')
+        self.assertEqual (r.line, 'aa bb cc')
+
+    def test_replace_dot (self):
+        r = ViModeTest ()
+        r._set_line ('ab')
+        r.input ('Escape')
+        r.input ('"0rzl"')
+        self.assertEqual (r.line, 'zb')
+        self.assertEqual (r.line_cursor, 1)
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('"r."')
+        self.assertEqual (r.line, 'z.')
+        self.assertEqual (r.line_cursor, 1)
+        self.assert_ (not r.vi_is_insert_mode)
+
+    def test_replace_upper (self):
+        r = ViModeTest ()
+        r._set_line ('aaa bbb')
+        r.input ('Escape')
+        r.input ('"0wR"')
+        self.assertEqual (r.line, 'aaa bbb')
+        self.assertEqual (r.line_cursor, 4)
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('"z"')
+        self.assertEqual (r.line, 'aaa zbb')
+        self.assertEqual (r.line_cursor, 5)
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('"zzz"')
+        self.assertEqual (r.line, 'aaa zzzz')
+        self.assertEqual (r.line_cursor, 8)
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('Escape')
+        self.assertEqual (r.line_cursor, 7)
+        self.assert_ (not r.vi_is_insert_mode)
+
+    def test_replace_upper_dot (self):
+        r = ViModeTest ()
+        r._set_line ('aaa bbb ccc ddd')
+        r.input ('Escape')
+        r.input ('"02Rz"')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'zza bbb ccc ddd')
+        self.assertEqual (r.line_cursor, 1)
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('"w."')
+        self.assertEqual (r.line, 'zza zzb ccc ddd')
+        self.assertEqual (r.line_cursor, 5)
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('"w6."')
+        self.assertEqual (r.line, 'zza zzb zzzzzzd')
+        self.assertEqual (r.line_cursor, 13)
+        self.assert_ (not r.vi_is_insert_mode)
+
+    def test_replace_upper_undo (self):
+        r = ViModeTest ()
+        r._set_line ('aaa bbb ccc')
+        r.input ('Escape')
+        r.input ('"0Rzz"')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'zza bbb ccc')
+        r.input ('"w3."')
+        self.assertEqual (r.line, 'zza zzzzzzc')
+        r.input ('"u"')
+        self.assertEqual (r.line, 'zza bbb ccc')
+        r.input ('"u"')
+        self.assertEqual (r.line, 'aaa bbb ccc')
+
+    def test_replace_backspace_and_dot (self):
+        r = ViModeTest ()
+        r._set_line ('aa bb')
+        r.input ('Escape')
+        r.input ('"0wRc"')
+        self.assertEqual (r.line, 'aa cb')
+        self.assertEqual (r.line_cursor, 4)
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('"c"')
+        self.assertEqual (r.line, 'aa cc')
+        self.assertEqual (r.line_cursor, 5)
+        r.input ('"c"')
+        self.assertEqual (r.line, 'aa ccc')
+        self.assertEqual (r.line_cursor, 6)
+        r.input ('BackSpace')
+        self.assertEqual (r.line, 'aa cc')
+        self.assertEqual (r.line_cursor, 5)
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('BackSpace')
+        self.assertEqual (r.line, 'aa cb')
+        self.assertEqual (r.line_cursor, 4)
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('BackSpace')
+        self.assertEqual (r.line, 'aa bb')
+        self.assertEqual (r.line_cursor, 3)
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('BackSpace')
+        self.assertEqual (r.line, 'aa bb')
+        self.assertEqual (r.line_cursor, 2)
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('"d"')
+        self.assertEqual (r.line, 'aadbb')
+        self.assertEqual (r.line_cursor, 3)
+        self.assert_ (r.vi_is_insert_mode)
+        r.input ('Escape')
+        self.assertEqual (r.line, 'aadbb')
+        self.assertEqual (r.line_cursor, 2)
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('"u"')
+        self.assertEqual (r.line, 'aa bb')
+        self.assertEqual (r.line_cursor, 3)
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('"hh"')
+        r.input ('"."')
+        self.assertEqual (r.line, 'da bb')
+        self.assert_ (not r.vi_is_insert_mode)
+
+    def test_yank_line (self):
+        r = ViModeTest ()
+        r._set_line ('aa bb')
+        r.input ('Escape')
+        r.input ('"0wY"')
+        self.assertEqual (r.line, 'aa bb')
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('"P"')
+        self.assertEqual (r.line, 'aa aa bbbb')
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('"u"')
+        self.assertEqual (r.line, 'aa bb')
+        self.assert_ (not r.vi_is_insert_mode)
+
+    def test_column (self):
+        r = ViModeTest ()
+        r._set_line ('aaa bbb')
+        r.input ('Escape')
+        r.input ('"099|"')
+        self.assertEqual (r.line, 'aaa bbb')
+        self.assertEqual (r.line_cursor, 6)
+        r.input ('"4|"')
+        self.assertEqual (r.line, 'aaa bbb')
+        self.assertEqual (r.line_cursor, 3)
+        r.input ('"d1|"')
+        self.assertEqual (r.line, ' bbb')
+        self.assertEqual (r.line_cursor, 0)
+        r.input ('"u"')
+        self.assertEqual (r.line, 'aaa bbb')
+        self.assertEqual (r.line_cursor, 3)
+        r.input ('"d7|"')
+        self.assertEqual (r.line, 'aaab')
+        self.assertEqual (r.line_cursor, 3)
+
+    def test_change_case (self):
+        r = ViModeTest ()
+        r._set_line ('aaa B7B ccc')
+        r.input ('Escape')
+        r.input ('"0~"')
+        self.assertEqual (r.line, 'Aaa B7B ccc')
+        self.assertEqual (r.line_cursor, 1)
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('"h."')
+        self.assertEqual (r.line, 'aaa B7B ccc')
+        self.assertEqual (r.line_cursor, 1)
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('"9~"')
+        self.assertEqual (r.line, 'aAA b7b CCc')
+        self.assertEqual (r.line_cursor, 10)
+        self.assert_ (not r.vi_is_insert_mode)
+        r.input ('"u"')
+        self.assertEqual (r.line, 'aaa B7B ccc')
+        self.assertEqual (r.line_cursor, 1)
+        self.assert_ (not r.vi_is_insert_mode)
+
+    def test_redo (self):
+        r = ViModeTest ()
+        r._set_line ('')
+        r.input ('Escape')
+        r.input ('"Saaa"')
+        self.assertEqual (r.line, 'aaa')
+        r.input ('Escape')
+        r.input ('"Sbbb"')
+        self.assertEqual (r.line, 'bbb')
+        r.input ('Escape')
+        r.input ('"Sccc"')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'ccc')
+        r.input ('"u"')
+        self.assertEqual (r.line, 'bbb')
+        r.input ('Control-r')
+        self.assertEqual (r.line, 'ccc')
+        r.input ('"u"')
+        self.assertEqual (r.line, 'bbb')
+        r.input ('"u"')
+        self.assertEqual (r.line, 'aaa')
+        r.input ('"u"')
+        self.assertEqual (r.line, '')
+        r.input ('"u"')
+        self.assertEqual (r.line, '')
+        r.input ('Control-r')
+        self.assertEqual (r.line, 'aaa')
+        r.input ('Control-r')
+        self.assertEqual (r.line, 'bbb')
+        r.input ('Control-r')
+        self.assertEqual (r.line, 'ccc')
+        r.input ('Control-r')
+        self.assertEqual (r.line, 'ccc')
+        r.input ('"u"')
+        self.assertEqual (r.line, 'bbb')
+        r.input ('"Szzz"')
+        r.input ('Escape')
+        self.assertEqual (r.line, 'zzz')
+        r.input ('"u"')
+        self.assertEqual (r.line, 'bbb')
+        r.input ('Control-r')
+        self.assertEqual (r.line, 'zzz')
+        r.input ('"U"')
+        self.assertEqual (r.line, '')
+        r.input ('Control-r')
+        self.assertEqual (r.line, 'aaa')
+        r.input ('Control-r')
+        self.assertEqual (r.line, 'bbb')
+        r.input ('Control-r')
+        self.assertEqual (r.line, 'zzz')
+        r.input ('Control-r')
+        self.assertEqual (r.line, 'zzz')
+
+#----------------------------------------------------------------------
+# utility functions
+
+
+#----------------------------------------------------------------------
+
+if __name__ == '__main__':
+    Tester()
+
+    tested=ViModeTest.tested_commands.keys()    
+    tested.sort()
+    print " Tested functions ".center(60,"-")
+    print "\n".join(tested)
+    print
+    
+    all_funcs=dict([(x.__name__,x) for x in ViModeTest().key_dispatch.values()])
+    all_funcs=all_funcs.keys()
+    not_tested=[x for x in all_funcs if x not in tested]
+    not_tested.sort()
+    print " Not tested functions ".center(60,"-")
+    print "\n".join(not_tested)
+    
+    
diff --git a/windows/fuzzbunch/redirection.py b/windows/fuzzbunch/redirection.py
new file mode 100644
index 0000000..2b818ae
--- /dev/null
+++ b/windows/fuzzbunch/redirection.py
@@ -0,0 +1,510 @@
+
+import string
+import uuid
+import random
+from util import iDict
+import exception
+
+
+# Nothing is validating the Redir section in the xml.  I may get nonexistent
+# params.
+#
+
+__all__ = ['RedirectionManager', 'LocalRedirection', 'RemoteRedirection']
+
+
+def str2bool(x):
+    if x is None:
+        return False
+    if x.lower() in ('true', 't', '1'):
+        return True
+    else:
+        return False
+
+def strip_xpath(x):
+    if not x:
+        return x
+    if x.startswith('/'):
+        return ""
+    else:
+        return x
+
+def is_identifier(x):
+    if not x:
+        return False
+    else:
+        if x[0] in string.digits:
+            return False
+        else:
+            return True
+
+def rand_port():
+    RAND_PORT_MIN = 1025
+    RAND_PORT_MAX = 65535
+    return str(random.randint(RAND_PORT_MIN, RAND_PORT_MAX))
+
+class LocalRedirection(object):
+    """
+    listenaddr: Name of parameter to give the IP addr of listening tunnel on local LP
+    listenport: Name of parameter to give the port of the listening tunnel on local LP
+    destaddr:   Name of parameter that contains the IP of the target computer
+    destport:   Name of parameter that contains the port on the target computer
+    """
+    def __init__(self, protocol, listenaddr, listenport, destaddr, destport,
+                    closeoncompletion="false", name="", srcport=None, srcportlist=None,
+                    srcportrange=None, *trashargs, **trashkargs):
+        self.protocol   = protocol
+        # XXX - The redirection section really shouldn't have XPath in it.
+        self.listenaddr = strip_xpath(listenaddr)
+        self.listenport = strip_xpath(listenport)
+        self.destaddr   = strip_xpath(destaddr)
+        self.destport   = strip_xpath(destport)
+        self.closeoncompletion = str2bool(closeoncompletion)
+        self.name = name
+
+        self.srcport = strip_xpath(srcport)
+        self.srcportlist = srcportlist
+        self.srcportrange = srcportrange
+
+    def __repr__(self):
+        return str(self.__dict__)
+
+
+class RemoteRedirection(object):
+    def __init__(self, protocol, listenaddr, destport, closeoncompletion="false",
+                    name="", listenport=None, listenportlist=None,
+                    listenportrange=None, listenportcount=None, destaddr="0.0.0.0",
+                    *trashargs, **trashkargs):
+        self.protocol   = protocol
+        self.listenaddr = strip_xpath(listenaddr)
+        self.listenport = strip_xpath(listenport)
+        self.destaddr   = strip_xpath(destaddr)
+        self.destport   = strip_xpath(destport)
+        self.closeoncompletion = str2bool(closeoncompletion)
+        self.name = name
+
+        # Need conversion?
+        self.listenportlist = listenportlist
+        self.listenportrange = listenportrange
+        self.listenportcount = listenportcount
+
+    def __repr__(self):
+        return str(self.__dict__)
+
+
+class RedirectionManager:
+    """This is something of a misnomer.  This is really a redirection manager rather than
+    a redirection object.  This is responsible for taking the defined tunnels in the 
+    plug-in's XML and 'swapping out' the parameters as they pertain to redirection.
+
+    A sample redirection section appears as follows:
+    <redirection>
+        <!-- (1) The "throwing" tunnel -->
+        <local name="Launch"
+               protocol="TCP"
+               listenaddr="TargetIp"        # IP of redirector
+               listenport="TargetPort"      # Port of redirector 
+               destaddr="TargetIp"          # IP of target computer
+               destport="TargetPort"        # Port of target computer
+               closeoncompletion="true"/>
+        <!-- (2) The "Callin" tunnel -->
+        <local name="Callin"
+               protocol="TCP"
+               listenaddr="TargetIp"        # IP on redirector
+               listenport="CallinPort"      # Port on redirector
+               destaddr="TargetIp"          # IP of target callin
+               destport="ListenPort"        # Port of target callin
+               closeoncompletion="false"/>
+        <!-- (3) The "callback" tunnel -->
+        <remote name="Callback"
+                protocol="TCP"
+                listenaddr="CallbackIp"         # IP opened by egg (last redirector)
+                listenport="CallbackPort"       # Port opened by egg (last redirector)
+                destport="CallbackLocalPort"    # Port for throwing side to listen
+                closeoncompletion="false"/>
+    </redirection>
+
+    For the "throwing" (launch) tunnel, we:
+        1: Ask for/retrieve the "Destination IP" and "Destination Port", which default to
+           the "TargetIp" and "TargetPort" parameters
+        2: Ask for the "Listen IP" (listenaddr) and "Listen Port" (listenport) 
+           and then swap them in "TargetIp" and "TargetPort"
+        3: After execution, restore the proper session parameters
+        * (listenaddr, listenport) = l(destaddr, destport)
+
+    For the "callin" tunnel, we:
+        1: Ask for/retrieve the "Destination IP" and Destination Port", which default to
+           the "TargetIp" and the "ListenPort" parameters
+        2: Ask for the "Listen IP" (listenaddr) and "Listen Port" (listenport) and
+           then swap them into "TargetIp" and "CallinPort" parameters
+        3: After execution, restore the proper session parameters
+        * (listenaddr, listenport) = l(destaddr, destport)
+
+    For the "callback" tunnel, we:
+        1: Ask for the Listen IP and Listen Port for which the payload will callback.
+           This is most likely the last hop redirector IP and a port on it
+        2: Ask for the Destination IP and Destination Port, which will likely be the
+           operator workstation.  Store the Destination port as "CallbackLocalPort", 
+           basically ignoring the DestinationIp
+        3: After execution, restore the proper session parameters
+        * (destaddr, destport) = l(listenaddr, listenport)
+
+    """
+    def __init__(self, io):
+        self.io = io
+        self.active = False
+        # A place to store parameters for the session.  We push the info, run the plug-in
+        # (with redirection), and then pop the info to restore it
+        self.session_cache = {}       
+
+    def on(self):
+        self.active = True
+
+    def off(self):
+        self.active = False
+
+    def is_active(self):
+        return self.active
+
+    def get_status(self):
+        if self.active:
+            return "ON"
+        else:
+            return "OFF"
+
+    def get_session(self, id):
+        return self.session_cache.get(id)
+        
+    def pre_exec(self, plugin):
+        if not plugin.canRedirect():
+            return 0
+        
+        if self.is_active():
+            self.io.print_msg("Redirection ON")
+            return self.config_redirect(plugin, True)
+        else:
+            self.io.print_msg("Redirection OFF")
+            return self.config_redirect(plugin, False)
+
+    def post_exec(self, plugin, id):
+        if id == 0:
+            return
+        # if plugin doesn't do redir, return
+
+        try:
+            stored_session_data = self.session_cache.pop(id)
+        except KeyError:
+            return
+
+        # Restore the old information to the session
+        for key,val in stored_session_data['params'].items():
+            plugin.set(key, val)
+
+    def print_session(self, id):
+        try:
+            session = self.session_cache[id]
+        except KeyError:
+            return
+        self.io.print_global_redir(session)
+
+    """
+    Pre plugin execution
+
+    """
+    def conv_param(self, val, params, session_data={}):
+        """Resolve a value from one of session, params, or the hard value"""
+        try:
+            # First try to find the session parameter
+            if val in session_data:
+                return session_data[val]
+            # Then try to find the context-specific parameter
+            if is_identifier(val):
+                return params[val]
+        except:
+            return None
+        # If it is neither a session or context parameter, return the value as is
+        return val
+
+    def prompt_redir_fake(self, msg, default):
+        done = None
+        while not done:
+            try:
+                line = self.io.prompt_user(msg, default)
+            except exception.PromptHelp, err:
+                self.io.print_warning('No help available')
+            except exception.PromptErr, err:
+                raise
+            except exception.CmdErr, err:
+                self.io.print_error(err.getErr())
+            if line:
+                return line
+
+    def prompt_redir(self, plugin, var, msg, default):
+        """Prompt for a redirect value and set it in Truantchild"""
+        done = None
+        while not done:
+            try:
+                line = self.io.prompt_user(msg, default)
+                plugin.set(var, line)
+                done = plugin.hasValidValue(var)
+            except exception.PromptHelp, err:
+                self.io.print_warning('No help available')
+            except exception.PromptErr, err:
+                raise
+            except exception.CmdErr, err:
+                self.io.print_error(err.getErr())
+        return plugin.get(var)
+
+    def straight_remote(self, r, plugin):
+        params = iDict(plugin.getParameters())
+        lport = self.conv_param(r.listenport, params)
+        dport = self.conv_param(r.destport, params)
+        laddr = self.conv_param(r.listenaddr, params)
+        if None in (lport, dport, laddr):
+            return
+
+        # Do we need to choose a random local port? 
+        # XXX - This won't happen unless lport is 0
+        if not lport or lport == "0":
+            lport = rand_port()
+
+        # Store off the old values so that we can restore them after the
+        # plug-in executes
+        cache = {r.listenaddr : plugin.get(r.listenaddr),
+                 r.listenport : plugin.get(r.listenport),
+                 r.destport   : plugin.get(r.destport)}
+        self.io.print_success("Remote Tunnel - %s" % r.name)
+        try:
+            # Modify the plugin and report success
+            callbackip = self.prompt_redir(plugin, r.listenaddr, 'Listen IP', laddr)
+            callbackport = self.prompt_redir(plugin, r.listenport, 'Listen Port', lport)
+            plugin.set(r.destport, callbackport)
+            self.io.print_success("(%s) Remote %s:%s" % (r.protocol, callbackip, callbackport))
+        except exception.PromptErr:
+            self.io.print_error("Aborted by user")
+            for (var,val) in cache.items():
+                try:
+                    plugin.set(var, val)
+                except:
+                    self.io.print_error("Error setting '%s' - May be in an inconsistent state" % var)
+            raise
+
+    def straight_local(self, l, plugin):
+        """Effectively just print the straight path to the target"""
+        params = iDict(plugin.getParameters())
+        laddr = self.conv_param(l.listenaddr, params)
+        lport = self.conv_param(l.listenport, params)
+        if not laddr or not lport:
+            return 
+        
+        # HACK HACK 
+        # The logic here was previously wrong, which meant that people didn't have to be careful
+        # about their redirection sections.  Until we get them fixed, we need a hack that will
+        # allow these invalid redirection sections if we try it the valid way and fail
+        enable_hack = False
+        try:
+            cache = {l.destaddr : plugin.get(l.destaddr),
+                     l.destport : plugin.get(l.destport)}
+            laddr = self.conv_param(l.destaddr, params)
+            lport = self.conv_param(l.destport, params)
+        except exception.CmdErr:
+            enable_hack = True
+            cache = {l.destaddr : plugin.get(l.listenaddr),
+                     l.destport : plugin.get(l.listenport)}
+        self.io.print_success("Local Tunnel - %s" % l.name)
+        try:
+            if not enable_hack:
+                targetip = self.prompt_redir(plugin, l.destaddr, 'Destination IP', laddr)
+                targetport = self.prompt_redir(plugin, l.destport, 'Destination Port', lport)
+                self.io.print_success("(%s) Local %s:%s" % (l.protocol, targetip, targetport))
+            else:
+                targetip = self.prompt_redir(plugin, l.listenaddr, 'Destination IP', laddr)
+                targetport = self.prompt_redir(plugin, l.listenport, 'Destination Port', lport)
+                self.io.print_success("(%s) Local %s:%s" % (l.protocol, targetip, targetport))
+        except exception.PromptErr:
+            self.io.print_error("Aborted by user")
+            for (var,val) in cache.items():
+                try:
+                    plugin.set(var, val)
+                except:
+                    self.io.print_error("Error setting '%s' - May be in an inconsistent state" % var)
+            raise
+        except Exception as e:
+            self.io.print_error("Error: {0}".format(str(type(e))))
+            
+
+    def redirect_remote(self, r, plugin, session_data):
+        """(destaddr, destport) = r-xform(listenaddr, listenport)
+        
+        * Each of the identifiers above specifies a variable for the plug-in
+
+        (1) Prompt for Listen IP            - Likely the ultimate redirector's IP
+        (2) Prompt for Listen Port          - Likely the ultimate redirector's port
+        (3) Prompt for Destination          - Likely 0.0.0.0
+        (4) Prompt for Destination Port     - Likely a local port
+
+        Lookup the variables specified by listenaddr and listenport, transform them with
+        a given transform function, and substitute the resulting values into the 
+        variables specified by destaddr and destport.
+
+        The plug-in will then have to open a port to listen on using the variables
+        specified by the destnation IP and destination port
+        """
+        params = iDict(plugin.getParameters())
+        lport = self.conv_param(r.listenport, params, session_data['params'])
+        dport = self.conv_param(r.destport, params, session_data['params'])
+        laddr = self.conv_param(r.listenaddr, params, session_data['params'])
+        daddr = self.conv_param(r.destaddr, params, session_data['params'])
+        if None in (lport, dport, laddr, daddr):
+            for p,n in (laddr, r.listenaddr), (lport, r.listenport), (daddr, r.destaddr), (dport, r.destport):
+                if p == None:
+                    self.io.print_warning("Parameter %s referenced by tunnel %s not found. This tunnel will "
+                                          "be ignored" % (n, r.name))
+            return
+
+        if not lport or lport == "0":
+            lport = rand_port()
+
+        self.io.print_success("Remote Tunnel - %s" % r.name)
+
+        #
+        # Prompt the user for the listenaddr and listenport
+        #
+        callbackip = self.prompt_redir(plugin, r.listenaddr, 'Listen IP', laddr)
+        callbackport = self.prompt_redir(plugin, r.listenport, 'Listen Port', lport)
+
+        #
+        # Do the substitution
+        #
+        session_data['params'][r.listenaddr] = callbackip
+        session_data['params'][r.listenport] = callbackport
+
+        # Get the other end of the tunnel, where the connection will eventually be made.
+        # This will likely be, but does not have to be, the local workstation
+        callbacklocalip = self.prompt_redir_fake('Destination IP', daddr)
+        if not dport:
+            dport = callbackport 
+        callbacklocalport = self.prompt_redir(plugin, r.destport, 'Destination Port', dport)
+        session_data['params'][r.destport] = callbacklocalport
+
+        session_data['remote'].append(RemoteRedirection(r.protocol, 
+                                                   callbackip, 
+                                                   callbacklocalport, 
+                                                   listenport=callbackport, 
+                                                   destaddr=callbacklocalip,
+                                                   name=r.name))
+
+        self.io.print_success("(%s) Remote %s:%s -> %s:%s" % 
+                (r.protocol, callbackip, callbackport, 
+                 callbacklocalip, callbacklocalport))
+
+    def redirect_local(self, l, plugin, session_data):
+        """
+        targetip    = Destination IP (on the target)
+        targetport  = Destination Port (on the target)
+        redirip     = IP of the LP
+        redirport   = Port on the LP
+
+        """
+
+        # listenaddr - name of variable containing the LP IP
+        # listenport - name of variable containing the LP Port
+        # destaddr   - name of variable containing the Target IP
+        # destport   - name of variable containing the Target Port
+
+        # targetip   - IP of the target
+        # targetport - Port of the target 
+        # redirip    - IP of the LP
+        # redirport  - Port of the LP
+
+        params = iDict(plugin.getParameters())
+
+        # Get the defaults for the user prompt
+        laddr = self.conv_param(l.listenaddr, params, session_data['params'])
+        lport = self.conv_param(l.listenport, params, session_data['params'])
+        daddr = self.conv_param(l.destaddr, params, session_data['params'])
+        dport = self.conv_param(l.destport, params, session_data['params'])
+        if None in (laddr, lport, daddr, dport):
+            for p,n in (laddr, l.listenaddr), (lport, l.listenport), (daddr, l.destaddr), (dport, l.destport):
+                if p == None:
+                    self.io.print_warning("Parameter %s referenced by tunnel %s not found. This tunnel will "
+                                          "be ignored" % (n, l.name))
+            return
+
+        self.io.print_success("Local Tunnel - %s" % l.name)
+
+        #
+        # Get the destination IP and port for the target
+        #
+        targetip = self.prompt_redir_fake('Destination IP', daddr)
+        targetport = self.prompt_redir_fake('Destination Port', dport)
+
+        #
+        # Get the redirection addresses
+        # 
+        redirip = self.prompt_redir(plugin, l.listenaddr, 'Listen IP', '127.0.0.1')
+        if not dport:
+            dport = targetport
+        redirport  = self.prompt_redir(plugin, l.listenport, 'Listen Port', lport)
+
+        #
+        # 
+        #
+        session_data['params'][l.listenaddr] = targetip
+        session_data['params'][l.listenport] = targetport
+
+        # 
+        # Record the redirection tunnel
+        # 
+        session_data['local'].append(LocalRedirection(l.protocol, redirip, 
+                                                 redirport, targetip, 
+                                                 targetport, name=l.name))
+
+        self.io.print_success("(%s) Local %s:%s -> %s:%s" % 
+                (l.protocol, redirip, redirport, targetip, targetport))
+
+    def config_redirect(self, plugin, do_redir):
+        """Configure whether the plug-in should perform redirection
+        plugin - An instance of a plugin
+        do_redir - Should we do redirection? (True or False)"""
+        redir  = plugin.getRedirection()
+
+        # Make a new session dictionary here
+        session_data = {
+                'params' : {},      # 
+                'remote' : [],      # 
+                'local'  : []       # 
+                }
+        if do_redir:
+            id = uuid.uuid4()
+        else:
+            id = 0
+
+        try:
+            self.io.newline()
+            self.io.print_success("Configure Plugin Local Tunnels")
+            for l in redir['local']:
+                if do_redir:
+                    self.redirect_local(l, plugin, session_data)
+                else:
+                    self.straight_local(l, plugin)
+
+            self.io.newline()
+            self.io.print_success("Configure Plugin Remote Tunnels")
+            for r in redir['remote']:
+                if do_redir:
+                    self.redirect_remote(r, plugin, session_data)
+                else:
+                    self.straight_remote(r, plugin)
+        except exception.PromptErr:
+            for key,val in session_data['params'].items():
+                plugin.set(key, val)
+            raise
+
+        self.io.newline()
+        # Store info into the cache so that we can restore it in post_exec
+        if id:
+            self.session_cache[id] = session_data
+        return id 
+
+
diff --git a/windows/fuzzbunch/session.py b/windows/fuzzbunch/session.py
new file mode 100644
index 0000000..a92638e
--- /dev/null
+++ b/windows/fuzzbunch/session.py
@@ -0,0 +1,316 @@
+"""Fuzzbunch Session handling
+
+General class relationships.  Currently Fuzzbunch only uses one session
+with the session history being composed of session items.
+
+    Session
+    |
+    |-- SessionItem (Plugin - Evadefred)
+        |
+        |-- SessionInfo (label=History)
+        \-- SessionInfo (label=Contract)
+
+For each SessionItem, Fuzzbunch maintains two lists of parameters:
+* History   - Input parameters
+* Contract  - Output parameters
+"""
+import uuid
+import exception
+import util
+import os
+
+__all__ = ['Session']
+
+try:
+    DEFAULT_TMP = os.environ['TMP']
+except KeyError:
+    DEFAULT_TMP = "/tmp"
+
+HISTORY_STR = "History"
+CONTRACT_STR = "Contract"
+
+class SessionInfo:
+    """Session info class.  Contains a single set of parameters, either input
+    (History) or output (Contract) as a label.
+
+    label  - label for this info item (Contract|History)
+    params - var,val parameter tuples
+    item   - parent item reference 
+
+    """
+    def __init__(self, label, params, item):
+        self.item   = item
+        self.label  = label
+        self.params = util.iDict()
+        for p in params:
+            self.set(p[0], p)
+
+    """
+    Printing
+
+    """
+    def get_item_info(self):
+        return "%s - %d" % (self.item.name,self.item.id)
+
+    def __str__(self):
+        return "%s - %d" % (self.item.name,self.item.id)
+
+    def __repr__(self):
+        string  = ">>> %d :: %s\n" % (self.item.id, self.item.name)
+        for v in self.params.itervalues():
+            string += "    %s\n" % (str(v))
+        return string
+
+    """
+    Marking
+
+    """
+    def mark_used(self):
+        """Mark the parent item as used"""
+        self.set_mark("USED")
+
+    def set_mark(self, value):
+        """Mark the parent item"""
+        self.item.set_status(value)
+
+    """
+    Labels
+
+    """
+    def get_label(self):
+        """Get the label for this info"""
+        return self.label
+
+    """
+    Parameter access
+
+    """
+    def set(self, var, val):
+        """Add a parameter with value"""
+        self.params[var] = val
+
+    def get(self, var):
+        """Get a parameter value"""
+        try:
+            return self.params[var]
+        except KeyError:
+            raise exception.CmdErr, "%s does not exist" % var
+
+    def get_paramlist(self):
+        """Get a list of all parameter var,vals"""
+        return self.params.items()
+
+
+class SessionItem(object):
+    """Session item class. Contains info items which have the actual parameters
+    of the session.  Items correspond to one execution of a given plugin and
+    maintain the state of the plugin execution.  Possible states are 
+        RUNNING - Plugin is still executing
+        FAIL    - Plugin has failed
+        READY   - Plugin is done executing and has generated a contract
+        USED    - Item contract has been used by another plugin
+    """
+    def __init__(self, name, id, description, sess):
+        self.sess = sess
+        self.name = name
+        self.id   = id
+        self.description = description
+        self.status = "RUNNING"
+        self._contract = None
+        self._history  = None       # Ends up containing the running history of sessions with this name
+
+    def __str__(self):
+        """The short view of what's going on"""
+        return "%s (%s)" % (self.name, self.status)
+
+    def __repr__(self):
+        """All information about the SessionItem"""
+        string  = "[%d] %s (%s)\n" % (self.id, self.name, self.status)
+        string += "    Description : %s\n" % (self.description)
+        string += "    Contract    : %s\n" % (str(self.contract))
+        string += "    History     : %s\n" % (str(self.history))
+        return string
+
+    """
+    Session Item Attributes
+
+    """
+    def get_name(self):
+        """Get the item name"""
+        return self.name
+
+    def get_description(self):
+        return self.description
+
+    def get_longname(self):
+        return self.name + "  " + self.description
+
+    def history():
+        doc = "Session item history params"
+        def fget(self):
+            return self._history
+        def fset(self, value):
+            self._history = SessionInfo(HISTORY_STR, value, self)
+        return locals()
+    history = property(**history())
+
+    def contract():
+        doc = "Session item contract params"
+        def fget(self):
+            return self._contract
+        def fset(self, value):
+            self._contract = SessionInfo(CONTRACT_STR, value, self)
+        return locals()
+    contract = property(**contract())
+
+    def get_info(self):
+        return (util.Param(HISTORY_STR, self.history), 
+                util.Param(CONTRACT_STR, self.contract))
+
+    """
+    Directories
+
+    """
+    def get_dirs(self):
+        """Return session directories"""
+        return self.sess.get_dirs()
+
+    """
+    Item status
+
+    """
+    def is_ready(self):
+        if self.status == "READY":
+            return True
+        else:
+            return False
+
+    def is_failed(self):
+        if self.status == "FAIL":
+            return True
+        else:
+            return False
+
+    def get_status(self):
+        """Get the item status"""
+        reason = ''
+        if self.is_failed():
+            try:
+                # This shouldn't happen, but weirder things have
+                for p in self.contract.get_paramlist():
+                    if p.name.lower() == 'returncode':
+                        reason = ' : ' + p.value.value
+                        break
+            except:
+                # Still say we failed, but don't say why
+                pass
+        return self.status + reason
+
+    def set_status(self, status):
+        """Set the status of the item"""
+        if status.upper() in ("RUNNING", "FAIL", "READY", "USED"):
+            self.status = status.upper()
+        else:
+            raise exception.CmdErr, "%s invalid status" % status
+
+    def mark_running(self):
+        self.set_status("RUNNING")
+
+    def mark_fail(self):
+        self.set_status("FAIL")
+
+    def mark_ready(self):
+        self.set_status("READY")
+
+    def mark_used(self):
+        self.set_status("USED")
+
+    """
+    Contract Handling
+
+    """
+    def has_opencontract(self):
+        if self.status in ("USED", "FAIL"):
+            return False
+        if self.status == "RUNNING":
+            return True
+
+        for p in self.contract.get_paramlist():
+            if p.name.lower() in ("connectedtcp", "rendezvous"):
+                return True
+        return False
+
+    def has_contract(self):
+        if self.contract:
+            return True
+        else:
+            return False
+
+
+class Session:
+    """Session class.  Contains complete history (items) for a session."""
+    def __init__(self, name):
+        self.name  = name
+        self.items = []
+        self.session_id = str(uuid.uuid4())
+        self.set_dirs(DEFAULT_TMP, DEFAULT_TMP)
+
+    def get_name(self):
+        """Get the name of the session"""
+        return self.name
+
+    """
+    Directories
+
+    """
+    def set_dirs(self, base_dir, log_dir):
+        """Set session directories"""
+        self.base_dir = os.path.normpath(base_dir)
+        self.log_dir  = os.path.normpath(log_dir)
+
+    def get_dirs(self):
+        """Return session directories"""
+        return (self.base_dir, self.log_dir)
+
+    """
+    Single Item Access
+
+    """
+    def add_item(self, name, description):
+        """Add a new item to the session"""
+        id = len(self.items)
+        self.items.append(SessionItem(name, id, description, self))
+        return self.items[-1]
+
+    def get_item(self, index):
+        """Get an item by index from the session"""
+        try:
+            return self.items[index]
+        except IndexError:
+            raise exception.CmdErr, "Bad index %d" % index
+
+    """
+    Bulk access
+
+    """
+    def get_itemlist(self):
+        """Get all of the items in the session"""
+        return [util.Param(item.get_name(), item) for item in self.items]
+
+    """
+    Contract Interface
+
+    """
+    def get_contractlist(self):
+        return [item.contract
+                for item in self.items
+                if item.contract and item.is_ready()]
+
+    def get_contract(self, index):
+        """Get a contract by index from the session"""
+        item = self.get_item(index)
+        if item.contract:
+            return item.contract
+        else:
+            raise exception.CmdErr, "Contract not available"
+
diff --git a/windows/fuzzbunch/truantchild.py b/windows/fuzzbunch/truantchild.py
new file mode 100644
index 0000000..2938e3e
--- /dev/null
+++ b/windows/fuzzbunch/truantchild.py
@@ -0,0 +1,962 @@
+"""
+Friendly wrapper around the TRUANTCHILD ctypes wrapper.  Provides classes for
+the different parameter structures with methods for access.
+"""
+
+import binascii
+import ctypes
+import exma
+import hashlib
+import os
+from util import superTuple, oParam
+import pytrch as trch
+
+try:
+    from pytrch import TrchError as TrchError
+except:
+    from pytrch import TrchError
+
+__all__ = ["attribute_convert", "Parameter", 
+           "Paramgroup", "Paramchoice",
+           "Config", "Params", "Param"]
+
+Param = superTuple('Param', 'name', 'value')
+
+def attribute_convert(val):
+    if val in ("1", 1, "TRUE", "true"):
+        return "YES"
+    else:
+        return "NO"
+
+class Parameter:
+    def __init__(self, paramStruct):
+        self.TypeListFnMap = {
+            "Boolean"   : { "getValue" : self.Boolean_List_getValue,
+                            "setValue" : self.Boolean_List_setValue },
+            "IPv4"      : { "getValue" : self.IPv4_List_getValue,
+                            "setValue" : self.IPv4_List_setValue },
+            "IPv6"      : { "getValue" : self.IPv6_List_getValue,
+                            "setValue" : self.IPv6_List_setValue },
+            "LocalFile" : { "getValue" : self.LocalFile_List_getValue,
+                            "setValue" : self.LocalFile_List_setValue },
+            "TcpPort"   : { "getValue" : self.TcpPort_List_getValue,
+                            "setValue" : self.TcpPort_List_setValue },
+            "UdpPort"   : { "getValue" : self.UdpPort_List_getValue,
+                            "setValue" : self.UdpPort_List_setValue },
+            "S16"       : { "getValue" : self.S16_List_getValue,
+                            "setValue" : self.S16_List_setValue },
+            "S32"       : { "getValue" : self.S32_List_getValue,
+                            "setValue" : self.S32_List_setValue },
+            "S64"       : { "getValue" : self.S64_List_getValue,
+                            "setValue" : self.S64_List_setValue },
+            "S8"        : { "getValue" : self.S8_List_getValue,
+                            "setValue" : self.S8_List_setValue },
+            "Socket"    : { "getValue" : self.Socket_List_getValue,
+                            "setValue" : self.Socket_List_setValue },
+            "String"    : { "getValue" : self.String_List_getValue,
+                            "setValue" : self.String_List_setValue },
+            "U16"       : { "getValue" : self.U16_List_getValue,
+                            "setValue" : self.U16_List_setValue },
+            "U32"       : { "getValue" : self.U32_List_getValue,
+                            "setValue" : self.U32_List_setValue },
+            "U64"       : { "getValue" : self.U64_List_getValue,
+                            "setValue" : self.U64_List_setValue },
+            "U8"        : { "getValue" : self.U8_List_getValue,
+                            "setValue" : self.U8_List_setValue },
+            "UString"   : { "getValue" : self.UString_List_getValue,
+                            "setValue" : self.UString_List_setValue },
+            "Buffer"    : { "getValue" : self.Buffer_List_getValue,
+                            "setValue" : self.Buffer_List_setValue },
+            }
+        self.TypeFnMap = {
+            "Boolean"   : { "getValue" : self.Boolean_getValue,
+                            "setValue" : self.Boolean_setValue },
+            "IPv4"      : { "getValue" : self.IPv4_getValue,
+                            "setValue" : self.IPv4_setValue },
+            "IPv6"      : { "getValue" : self.IPv6_getValue,
+                            "setValue" : self.IPv6_setValue },
+            "LocalFile" : { "getValue" : self.LocalFile_getValue,
+                            "setValue" : self.LocalFile_setValue },
+            "TcpPort"   : { "getValue" : self.TcpPort_getValue,
+                            "setValue" : self.TcpPort_setValue },
+            "UdpPort"   : { "getValue" : self.UdpPort_getValue,
+                            "setValue" : self.UdpPort_setValue },
+            "S16"       : { "getValue" : self.S16_getValue,
+                            "setValue" : self.S16_setValue },
+            "S32"       : { "getValue" : self.S32_getValue,
+                            "setValue" : self.S32_setValue },
+            "S64"       : { "getValue" : self.S64_getValue,
+                            "setValue" : self.S64_setValue },
+            "S8"        : { "getValue" : self.S8_getValue,
+                            "setValue" : self.S8_setValue },
+            "Socket"    : { "getValue" : self.Socket_getValue,
+                            "setValue" : self.Socket_setValue },
+            "String"    : { "getValue" : self.String_getValue,
+                            "setValue" : self.String_setValue },
+            "U16"       : { "getValue" : self.U16_getValue,
+                            "setValue" : self.U16_setValue },
+            "U32"       : { "getValue" : self.U32_getValue,
+                            "setValue" : self.U32_setValue },
+            "U64"       : { "getValue" : self.U64_getValue,
+                            "setValue" : self.U64_setValue },
+            "U8"        : { "getValue" : self.U8_getValue,
+                            "setValue" : self.U8_setValue },
+            "UString"   : { "getValue" : self.UString_getValue,
+                            "setValue" : self.UString_setValue },
+            "Buffer"    : { "getValue" : self.Buffer_getValue,
+                            "setValue" : self.Buffer_setValue },
+            }
+        self.param = paramStruct
+
+    def __repr__(self):
+        if self.isHidden():
+            return ""
+        else:
+            return "%s : %s\n" % (self.getName(), self.getValue())
+
+    def _tokenize_list(self, l):
+        # Verify [ .. ] and remove
+        if l[0] != '[' or l[-1] != ']':
+            return None
+        l = l[1:-1]
+
+        # tokens are 'token',  "token", ...
+        # quoted strings with comma and (optional) whitespace delimiters
+        tokens = []
+        while l:
+            if l[0] not in "'\"":
+                if l[0] in (' ', ','):
+                    l = l[1:]
+                    continue
+                else:
+                    return None
+            else:
+                delim = l[0]
+                l = l[1:]
+            try:
+                pos = l.index(delim)
+            except ValueError:
+                return None
+            tokens.append(l[:pos])
+            l = l[pos+1:]
+        return tokens
+
+    def _tokenize_barelist(self, l):
+        # Verify [ .. ] and remove
+        if l[0] != '[' or l[-1] != ']':
+            return None
+        l = l[1:-1]
+
+        # tokens are token, token, ..., token
+        # Non-quoted strings with comma and (optional) whitespace delimiters
+        return [x.strip() for x in l.split(',')]
+
+    def getDescription(self):
+        return trch.Parameter_getDescription(self.param)
+
+    def getFormat(self):
+        return trch.Parameter_getFormat(self.param)
+
+    def getName(self):
+        return trch.Parameter_getName(self.param)
+
+    def getType(self):
+        return trch.Parameter_getType(self.param)
+
+    def getMarshalledDefault(self):
+        return trch.Parameter_getMarshalledDefault(self.param)
+
+    def getValue(self):
+        if self.hasValue():
+            if self.getFormat().lower() == "list":
+                try:
+                    return str(self.TypeListFnMap[self.getType()]['getValue']())
+                except KeyError:
+                    return ""
+            else:
+                return str(self.TypeFnMap[self.getType()]['getValue']())
+        else:
+            return ""
+
+    def hasValue(self):
+        return trch.Parameter_hasValue(self.param)
+
+    def hasValidValue(self):
+        return trch.Parameter_hasValidValue(self.param)
+
+    def getAttributeList(self):
+        if self.getFormat().lower() == "list":
+            extendedtype = " List"
+        else:
+            extendedtype = ""
+        alist = [("Name",       self.getName()),
+                 ("Value",      self.getValue()),
+                 ("Type",       self.getType() + extendedtype),
+                 ("Description", self.getDescription()),
+                 ("Is Valid",   attribute_convert(self.hasValidValue())),
+                 ("Required",   attribute_convert(self.isRequired()))]
+        return alist 
+
+    def getAttributeValueList(self):
+        return []
+
+    def getParameterList(self):
+        #if not self.isHidden():
+        #    return [Param(self.getName(), self.getValue())]
+        #else:
+        #    return []
+        return [Param(self.getName(), self.getValue())]
+
+    def getParameterListExt(self):
+        #if not self.isHidden():
+        return [oParam(self.getName(), self.getValue(), 
+                    self.getType(), self.getFormat())]
+        #else:
+        #    return []
+
+    def isHidden(self):
+        return trch.Parameter_isHidden(self.param)
+
+    def isRequired(self):
+        return trch.Parameter_isRequired(self.param)
+
+    def isValid(self):
+        return trch.Parameter_isValid(self.param)
+
+    def markInvalid(self):
+        trch.Parameter_markInvalid(self.param)
+
+    def matchName(self, name):
+        return trch.Parameter_matchName(self.param, name)
+
+    def matchType(self, type):
+        return trch.Parameter_matchType(self.param, type)
+
+    def setValue(self, value):
+        if self.getFormat().lower() == "list":
+            try:
+                self.TypeListFnMap[self.getType()]['setValue'](value)
+            except KeyError:
+                pass
+        else:
+            self.TypeFnMap[self.getType()]['setValue'](value)
+
+    def resetValue(self):
+        trch.Parameter_resetValue(self.param)
+    
+    # Value accessors
+    def Boolean_getValue(self):
+        b = trch.Parameter_Boolean_getValue(self.param)
+        if b:
+            return "True"
+        else:
+            return "False"
+
+    def Boolean_setValue(self, value):
+        if value.lower() in ("false", "f", "0", "off"):
+            value = 0
+        elif value.lower() in ("true", "t", "1", "on"):
+            value = 1
+        else:
+            value = ""
+        trch.Parameter_Boolean_setValue(self.param, int(value))
+
+    def IPv4_getValue(self):
+        return trch.Parameter_IPv4_getValue(self.param)
+
+    def IPv4_setValue(self, value):
+        trch.Parameter_IPv4_setValue(self.param, value)
+
+    def IPv6_getValue(self):
+        return trch.Parameter_IPv6_getValue(self.param)
+
+    def IPv6_setValue(self, value):
+        trch.Parameter_IPv6_setValue(self.param, value)
+
+    def LocalFile_getValue(self):
+        return os.path.normpath(trch.Parameter_LocalFile_getValue(self.param))
+
+    def LocalFile_setValue(self, value):
+        trch.Parameter_LocalFile_setValue(self.param, os.path.normpath(value))
+
+    def TcpPort_getValue(self):
+        return str(trch.Parameter_Port_getValue(self.param))
+
+    def TcpPort_setValue(self, value):
+        trch.Parameter_Port_setValue(self.param, int(value))
+
+    def UdpPort_getValue(self):
+        return str(trch.Parameter_Port_getValue(self.param))
+
+    def UdpPort_setValue(self, value):
+        trch.Parameter_Port_setValue(self.param, int(value))
+
+    def S16_getValue(self):
+        return str(trch.Parameter_S16_getValue(self.param))
+
+    def S16_setValue(self, value):
+        trch.Parameter_S16_setValue(self.param, int(value))
+
+    def S32_getValue(self):
+        return str(trch.Parameter_S32_getValue(self.param))
+
+    def S32_setValue(self, value):
+        trch.Parameter_S32_setValue(self.param, int(value))
+
+    def S64_getValue(self):
+        return str(trch.Parameter_S64_getValue(self.param))
+
+    def S64_setValue(self, value):
+        trch.Parameter_S64_setValue(self.param, long(value))
+
+    def S8_getValue(self):
+        return str(trch.Parameter_S8_getValue(self.param))
+
+    def S8_setValue(self, value):
+        trch.Parameter_S8_setValue(self.param, int(value))
+
+    def Socket_getValue(self):
+        return str(trch.Parameter_Socket_getValue(self.param))
+
+    def Socket_setValue(self, value):
+        trch.Parameter_Socket_setValue(self.param, int(value))
+
+    def String_getValue(self):
+        return trch.Parameter_String_getValue(self.param)
+
+    def String_setValue(self, value):
+        trch.Parameter_String_setValue(self.param, value)
+
+    def U16_getValue(self):
+        return str(trch.Parameter_U16_getValue(self.param))
+
+    def U16_setValue(self, value):
+        trch.Parameter_U16_setValue(self.param, int(value))
+
+    def U32_getValue(self):
+        return str(trch.Parameter_U32_getValue(self.param))
+
+    def U32_setValue(self, value):
+        trch.Parameter_U32_setValue(self.param, int(value))
+
+    def U64_getValue(self):
+        return str(trch.Parameter_U64_getValue(self.param))
+
+    def U64_setValue(self, value):
+        trch.Parameter_U64_setValue(self.param, long(value))
+
+    def U8_getValue(self):
+        return str(trch.Parameter_U8_getValue(self.param))
+
+    def U8_setValue(self, value):
+        trch.Parameter_U8_setValue(self.param, int(value))
+
+    def UString_getValue(self):
+        bytes = trch.Parameter_UString_getValue(self.param)
+        if bytes:
+            return binascii.hexlify(bytes)
+        else:
+            return ""
+
+    def UString_setValue(self, value):
+        if value.startswith("\\x"):
+            decoded_val = value.decode('string-escape')
+        else:
+            decoded_val = binascii.unhexlify(value)
+        trch.Parameter_UString_setValue(self.param, decoded_val)
+
+    def Buffer_getValue(self):
+        bytes = trch.Parameter_Buffer_getValue(self.param)
+        if bytes:
+            return binascii.hexlify(bytes)
+        else:
+            return ""
+
+    def Buffer_setValue(self, value):
+        if value.startswith("\\x"):
+            decoded_val = value.decode('string-escape')
+        else:
+            decoded_val = binascii.unhexlify(value)
+        trch.Parameter_Buffer_setValue(self.param, decoded_val)
+
+    def Boolean_List_setValue(self, value):
+        values = []
+        for v in self._tokenize_barelist(value):
+            if v.lower() in ("false", "f", "0", "off"):
+                x = 0 
+            elif v.lower() in ("true", "t", "1", "on"):
+                x = 1
+            else:
+                x = ""
+            values.append(int(x))
+        trch.Parameter_Boolean_List_setValue(self.param, values)
+
+    def Boolean_List_getValue(self):
+        token = trch.Parameter_Boolean_List_getValue(self.param)
+        values = []
+        for tok in token:
+            if tok:
+                values.append("True")
+            else:
+                values.append("False")
+        return '[' + ', '.join(values) + ']'
+
+    def IPv4_List_setValue(self, value):
+        arg = self._tokenize_list(value)
+        trch.Parameter_IPv4_List_setValue(self.param, arg)
+
+    def IPv4_List_getValue(self):
+        tokens = trch.Parameter_IPv4_List_getValue(self.param)
+        twrapped = ["'" + x + "'" for x in tokens]
+        return '[' + ', '.join(twrapped) + ']'
+
+    def IPv6_List_setValue(self, value):
+        arg = self._tokenize_list(value)
+        trch.Parameter_IPv6_List_setValue(self.param, arg)
+
+    def IPv6_List_getValue(self):
+        tokens = trch.Parameter_IPv6_List_getValue(self.param)
+        twrapped = ["'" + x + "'" for x in tokens]
+        return '[' + ', '.join(twrapped) + ']'
+
+    def LocalFile_List_setValue(self, value):
+        arg = self._tokenize_list(value)
+        trch.Parameter_LocalFile_List_setValue(self.param, arg)
+
+    def LocalFile_List_getValue(self):
+        tokens = trch.Parameter_LocalFile_List_getValue(self.param)
+        twrapped = ["'" + x + "'" for x in tokens]
+        return '[' + ', '.join(twrapped) + ']'
+
+    def TcpPort_List_setValue(self, value):
+        tokens = [int(x) for x in self._tokenize_barelist(value)]
+        trch.Parameter_Port_List_setValue(self.param, tokens)
+
+    def TcpPort_List_getValue(self):
+        tokens = trch.Parameter_Port_List_getValue(self.param)
+        return '[' + ', '.join(str(x) for x in tokens) + ']'
+
+    def UdpPort_List_setValue(self, value):
+        self.TcpPort_List_setValue(value)
+
+    def UdpPort_List_getValue(self):
+        return self.TcpPort_List_getValue()
+
+    def S16_List_setValue(self, value):
+        tokens = [int(x) for x in self._tokenize_barelist(value)]
+        trch.Parameter_S16_List_setValue(self.param, tokens)
+
+    def S16_List_getValue(self):
+        tokens = trch.Parameter_S16_List_getValue(self.param)
+        return '[' + ', '.join(str(x) for x in tokens) + ']'
+
+    def S32_List_setValue(self, value):
+        tokens = [int(x) for x in self._tokenize_barelist(value)]
+        trch.Parameter_S32_List_setValue(self.param, tokens)
+
+    def S32_List_getValue(self):
+        tokens = trch.Parameter_S32_List_getValue(self.param)
+        return '[' + ', '.join(str(x) for x in tokens) + ']'
+
+    def S64_List_setValue(self, value):
+        tokens = [long(x) for x in self._tokenize_barelist(value)]
+        trch.Parameter_S64_List_setValue(self.param, tokens)
+
+    def S64_List_getValue(self):
+        tokens = trch.Parameter_S64_List_getValue(self.param)
+        return '[' + ', '.join(str(x) for x in tokens) + ']'
+
+    def S8_List_setValue(self, value):
+        tokens = [int(x) for x in self._tokenize_barelist(value)]
+        trch.Parameter_S8_List_setValue(self.param, tokens)
+
+    def S8_List_getValue(self):
+        tokens = trch.Parameter_S8_List_getValue(self.param)
+        return '[' + ', '.join(str(x) for x in tokens) + ']'
+
+    def Socket_List_setValue(self, value):
+        tokens = [int(x) for x in self._tokenize_barelist(value)]
+        trch.Parameter_Socket_List_setValue(self.param, tokens)
+
+    def Socket_List_getValue(self):
+        tokens = trch.Parameter_Socket_List_getValue(self.param)
+        return '[' + ', '.join(str(x) for x in tokens) + ']'
+
+    def String_List_setValue(self, value):
+        arg = self._tokenize_list(value)
+        trch.Parameter_String_List_setValue(self.param, arg)
+
+    def String_List_getValue(self):
+        tokens = trch.Parameter_String_List_getValue(self.param)
+        twrapped = ["'" + x + "'" for x in tokens]
+        return '[' + ', '.join(twrapped) + ']'
+
+    def U16_List_setValue(self, value):
+        tokens = [int(x) for x in self._tokenize_barelist(value)]
+        trch.Parameter_U16_List_setValue(self.param, tokens)
+
+    def U16_List_getValue(self):
+        tokens = trch.Parameter_U16_List_getValue(self.param)
+        return '[' + ', '.join(str(x) for x in tokens) + ']'
+
+    def U32_List_setValue(self, value):
+        tokens = [int(x) for x in self._tokenize_barelist(value)]
+        trch.Parameter_U32_List_setValue(self.param, tokens)
+
+    def U32_List_getValue(self):
+        tokens = trch.Parameter_U32_List_getValue(self.param)
+        return '[' + ', '.join(str(x) for x in tokens) + ']'
+
+    def U64_List_setValue(self, value):
+        tokens = [long(x) for x in self._tokenize_barelist(value)]
+        trch.Parameter_U64_List_setValue(self.param, tokens)
+
+    def U64_List_getValue(self):
+        tokens = trch.Parameter_U64_List_getValue(self.param)
+        return '[' + ', '.join(str(x) for x in tokens) + ']'
+
+    def U8_List_setValue(self, value):
+        tokens = [int(x) for x in self._tokenize_barelist(value)]
+        trch.Parameter_U8_List_setValue(self.param, tokens)
+
+    def U8_List_getValue(self):
+        tokens = trch.Parameter_U8_List_getValue(self.param)
+        return '[' + ', '.join(str(x) for x in tokens) + ']'
+    
+    def UString_List_setValue(self, value):
+        tokens = self._tokenize_list(value)
+        values = []
+        for tok in tokens:
+            if tok.startswith("\\x"):
+                decoded_val = tok.decode('string-escape')
+            else:
+                decoded_val = binascii.unhexlify(tok)
+            values.append(decoded_val)
+        trch.Parameter_UString_List_setValue(self.param, values)
+
+    def UString_List_getValue(self):
+        tokens = trch.Parameter_UString_List_getValue(self.param)
+        strlist = ("'" + binascii.hexlify(l) + "'" for l in tokens)
+        return '[' + ', '.join(strlist) + ']'
+
+    def Buffer_List_setValue(self, value):
+        tokens = self._tokenize_list(value)
+        values = []
+        for tok in tokens:
+            if tok.startswith("\\x"):
+                decoded_val = tok.decode('string-escape')
+            else:
+                decoded_val = binascii.unhexlify(tok)
+            values.append(decoded_val)
+        trch.Parameter_Buffer_List_setValue(self.param, values)
+
+    def Buffer_List_getValue(self):
+        tokens = trch.Parameter_Buffer_List_getValue(self.param)
+        strlist = ("'" + binascii.hexlify(l) + "'" for l in tokens)
+        return '[' + ', '.join(strlist) + ']'
+
+
+class Paramgroup:
+    def __init__(self, paramGroup):
+        self.group       = paramGroup
+        self.choiceList  = {}
+        self.paramList   = {}
+
+        for i in xrange(0, self.getNumParameters()):
+            param = trch.Paramgroup_getParameter(paramGroup, i)
+            name = trch.Parameter_getName(param)
+            self.paramList[name.lower()] = Parameter(param)
+
+        for i in xrange(0, self.getNumParamchoices()):
+            paramChoice = trch.Paramgroup_getParamchoice(paramGroup, i)
+            name = trch.Paramchoice_getName(paramChoice)
+            self.choiceList[name.lower()] = Paramchoice(paramChoice)
+
+    def __repr__(self):
+        items = []
+        for param in self.paramList:
+            items.append(repr(self.paramList[param]))
+
+        for choice in self.choiceList:
+            items.append(repr(self.choiceList[choice]))
+
+        return "".join(items)
+
+    def getDescription(self):
+        return trch.Paramgroup_getDescription(self.group)
+
+    def getName(self):
+        return trch.Paramgroup_getName(self.group)
+
+    def getNumParamchoices(self):
+        return trch.Paramgroup_getNumParamchoices(self.group)
+
+    def getNumParameters(self):
+        return trch.Paramgroup_getNumParameters(self.group)
+
+    def getParameter(self, name):
+        return self.paramList[name.lower()]
+        
+    def getParamchoice(self, name):
+        return self.choiceList[name.lower()]
+
+    def getAttributeList(self):
+        return []
+
+    def getAttributeValueList(self):
+        alist = [Param(self.getName(), self.getDescription())]
+        return alist
+
+    def getParameterList(self):
+        plist = []
+        for key in self.paramList:
+            plist.extend(self.paramList[key].getParameterList())
+        for key in self.choiceList:
+            plist.extend(self.choiceList[key].getParameterList())
+        return plist
+
+    def getParameterListExt(self):
+        plist = []
+        for key in self.paramList:
+            plist.extend(self.paramList[key].getParameterListExt())
+        for key in self.choiceList:
+            plist.extend(self.choiceList[key].getParameterListExt())
+        return plist
+        
+    def hasValidValue(self):
+        return self.isValid()
+
+    def isValid(self):
+        return trch.Paramgroup_isValid(self.group)
+
+    def matchName(self, name):
+        return trch.Paramgroup_matchName(self.group, str(name))
+
+    def hasValue(self):
+        return 1
+
+
+class Paramchoice:
+    def __init__(self, paramChoice):
+        self.choice     = paramChoice
+        self.groupList  = {}
+        
+        self.groupNames = []
+        for i in xrange(0, self.getNumParamgroups()):
+            paramGroup = trch.Paramchoice_getParamgroup(paramChoice, i)
+            name = trch.Paramgroup_getName(paramGroup)
+            self.groupNames.append(name.lower())
+            self.groupList[name.lower()] = Paramgroup(paramGroup)
+    
+    def __repr__(self):
+        items = []
+        if self.hasValidValue():
+            items.append("%s : %s\n" % (self.getName(), self.getValue()))
+            items.append(repr(self.groupList[self.getValue().lower()]))
+        else:
+            items.append("%s : %s\n" % (self.getName(), ""))
+
+        return "".join(items)
+
+    def getDefaultValue(self):
+        return trch.Paramchoice_getDefaultValue(self.choice)
+
+    def getDescription(self):
+        return trch.Paramchoice_getDescription(self.choice)
+
+    def getName(self):
+        return trch.Paramchoice_getName(self.choice)
+
+    def getNumParamgroups(self):
+        return trch.Paramchoice_getNumParamgroups(self.choice)
+
+    def getParamgroup(self, name):
+        return self.groupList[name.lower()]
+
+    def getValue(self):
+        if self.hasValue():
+            return trch.Paramchoice_getValue(self.choice)
+        else:
+            return ""
+
+    def getAttributeList(self):
+        alist = [("Name",        self.getName()),
+                 ("Description", self.getDescription()),
+                 ("Value",       self.getValue()),
+                 ("Is Valid",    attribute_convert(self.hasValidValue())),
+                 ("Required",    "YES")]
+        return alist
+
+    def getAttributeValueList(self):
+        alist = []
+        for group in self.groupNames:
+            alist.extend(self.groupList[group].getAttributeValueList())
+        return alist
+
+    def getParameterList(self):
+        item = Param(self.getName(), self.getValue())
+        plist = [item]
+        if self.hasValidValue():
+            plist.extend(self.groupList[self.getValue().lower()].getParameterList())
+
+        return plist
+
+    def getParameterListExt(self):
+        item = oParam(self.getName(), self.getValue(), self.getType(), 'Scalar')
+        plist = [item]
+        if self.hasValidValue():
+            plist.extend(self.groupList[self.getValue().lower()].getParameterListExt())
+
+        return plist
+
+    def hasValidValue(self):
+        return trch.Paramchoice_hasValidValue(self.choice)
+
+    def isValid(self):
+        return trch.Paramchoice_isValid(self.choice)
+
+    def matchName(self, name):
+        return trch.Paramchoice_matchName(self.choice, str(name))
+
+    def setValue(self, value):
+        trch.Paramchoice_setValue(self.choice, str(value))
+
+    def resetValue(self):
+        v = self.getDefaultValue()
+        if not v:
+            v = ''
+        self.setValue(v)
+
+    def hasValue(self):
+        return trch.Paramchoice_hasValue(self.choice)
+
+    def getType(self):
+        return 'choice'
+
+    def getFormat(self):
+        return 'Scalar'
+
+class Config:
+    """
+    Representation of a parsed XML file.
+
+    Contains inputs, outputs constants.
+    Does not contain logic, redirection.
+    """
+    def __init__(self, files):
+        self.xmlInConfig  = files[0]
+        if len(files) > 1:
+            self.executable = files[1]
+        else:
+            self.executable = ""
+        self.init_config()
+
+    def init_config(self):
+        self.configXML     = exma.readParamsFromEM(ctypes.c_char_p(self.xmlInConfig))
+        # Config_unmarshal can fail and return None, which 
+        # raises TrchError when passed to Config_getID
+        try:
+            self.config        = trch.Config_unmarshal(self.configXML)
+            if self.config is None:
+                raise TrchError("Parse error in the output configuration")
+            self.id            = trch.Config_getID(self.config)
+            self.name          = trch.Config_getName(self.config)
+            self.version       = trch.Config_getVersion(self.config)
+            self.configVersion = trch.Config_getConfigVersion(self.config)
+            self.namespaceUri  = trch.Config_getNamespaceUri(self.config)
+            self.schemaVersion = trch.Config_getSchemaVersion(self.config)
+        except TrchError:
+            raise
+
+        self._inputParams   = Params(trch.Config_getInputParams(self.config), 
+                                     self.namespaceUri, self.schemaVersion)
+        self._outputParams  = Params(trch.Config_getOutputParams(self.config),
+                                     self.namespaceUri, self.schemaVersion)
+        #self._constants     = Params(trch.Config_getConstants(self.config),
+        #                             self.namespaceUri, self.schemaVersion)
+        self._constants = None
+
+
+    def __repr__(self):
+        items = []
+        items.append("Name : %s\n" % self.name)
+        items.append("ID : %s\n" % self.id)
+        items.append("Version : %s\n" % self.version)
+        items.append("Config Version : %s\n" % self.configVersion)
+        return "".join(items)
+
+    def getMarshalledInConfig(self):
+        c = trch.Config_marshal(self.config, "t", None)
+        return c
+
+    def putMarshalledConfig(self, filename):
+        c = trch.Config_marshal(self.config, "t", None)
+        if isinstance(filename, str):
+            with open(filename, "wb") as fh:
+                fh.write(c)
+        elif isinstance(filename, file):
+            filename.write(c)
+
+    def getName(self):
+        return self.name
+
+    def getVersion(self):
+        return self.version
+
+    def getConfigVersion(self):
+        return self.configVersion
+
+    def getBinaryHash(self):
+        return "%s %s %s" % (hashlib.sha1(open(self.executable, 'rb').read()).hexdigest(),
+                             os.lstat(self.executable).st_size,
+                             os.path.basename(self.executable))
+
+    def getConfigHash(self):
+        return "%s %s %s" % (hashlib.sha1(open(self.xmlInConfig, 'rb').read()).hexdigest(),
+                                      os.lstat(self.xmlInConfig).st_size,
+                                      os.path.basename(self.xmlInConfig))
+
+
+class Params:
+    def __init__(self, params, ns, ver):
+        self.choiceList = {}
+        self.paramList  = {}
+        self.parameters = params
+        self.namespaceUri = ns
+        self.schemaVersion = ver
+        
+        for i in xrange(0, self.getNumParameters()):
+            param = trch.Params_getParameter(self.parameters, i)
+            name = trch.Parameter_getName(param)
+            self.paramList[name.lower()] = Parameter(param)
+
+        for i in xrange(0, self.getNumParamchoices()):
+            paramChoice = trch.Params_getParamchoice(self.parameters, i)
+            name = trch.Paramchoice_getName(paramChoice)
+            self.choiceList[name.lower()] = Paramchoice(paramChoice)
+
+    def __repr__(self):
+        items = []
+        for param in self.paramList:
+            items.append(repr(self.paramList[param]))
+
+        for choice in self.choiceList:
+            items.append(repr(self.choiceList[choice]))
+
+        return "".join(items)
+        
+    def findParamchoice(self, name):
+        param = trch.Params_findParamchoice(self.parameters, str(name))
+        if param:
+            return Paramchoice(param)
+        else:
+            return None
+
+    def findParameter(self, name):
+        param = trch.Params_findParameter(self.parameters, str(name))
+        if param:
+            return Parameter(param)
+        else:
+            return None
+
+    def getNumParamchoices(self):
+        return trch.Params_getNumParamchoices(self.parameters)
+
+    def getNumParameters(self):
+        return trch.Params_getNumParameters(self.parameters)
+
+    def hasValidValue(self, name=None):
+        return self.findOption(name).hasValidValue()
+
+    def isValid(self, name=None):
+        if name == None:
+            return trch.Params_isValid(self.parameters)
+        else:
+            return self.findOption(name).isValid()
+
+    def hasValue(self, name):
+        param = self.findOption(name)
+        return param.hasValue()
+
+    def isParamchoice(self, name):
+        if self.findParamchoice(name):
+            return True
+        else:
+            return False
+
+    def isParameter(self, name):
+        if self.findParameter(name):
+            return True
+        else:
+            return False
+
+    def findOption(self, name):
+        param = self.findParameter(name)
+        if param is None:
+            param = self.findParamchoice(name)
+        return param
+
+    def getDescription(self, name):
+        return self.findOption(name).getDescription()
+
+    def getType(self, name):
+        return self.findOption(name).getType()
+
+    def getFormat(self, name):
+        return self.findOption(name).getFormat()
+
+    def set(self, name, value):
+        return self.findOption(name).setValue(value)
+
+    def reset(self, name):
+        self.findOption(name).resetValue()
+
+    def get(self, name):
+        if self.hasValue(name):
+            return self.findOption(name).getValue()
+        else:
+            return ""
+
+    def getAttributeList(self, name):
+        return self.findOption(name).getAttributeList()
+
+    def getRootParameterList(self):
+        plist = []
+        for key in self.paramList:
+            plist.extend(self.paramList[key].getParameterList())
+        return plist
+
+    def getParameterList(self):
+        plist = []
+        for key in self.paramList:
+            plist.extend(self.paramList[key].getParameterList())
+        for key in self.choiceList:
+            plist.extend(self.choiceList[key].getParameterList())
+        return plist
+
+    def getParameterListExt(self):
+        plist = []
+        for key in self.paramList:
+            plist.extend(self.paramList[key].getParameterListExt())
+        for key in self.choiceList:
+            plist.extend(self.choiceList[key].getParameterListExt())
+        return plist
+
+    #def add(self, type, value):
+
+    def addRendezvousParam(self, value):
+        if not self.findOption("Rendezvous"):
+            param = trch.Parameter_U16_create("Rendezvous", 
+                                              "Rendezvous location", 
+                                              1, 
+                                              value,
+                                              self.namespaceUri,
+                                              self.schemaVersion)
+            a = trch.Params_addParameter(self.parameters, param)
+            del a
+            self.paramList["rendezvous"] = self.findParameter("rendezvous")
+
+        self.set("Rendezvous", value)
+        
+
+
diff --git a/windows/fuzzbunch/util.py b/windows/fuzzbunch/util.py
new file mode 100644
index 0000000..cb56f1e
--- /dev/null
+++ b/windows/fuzzbunch/util.py
@@ -0,0 +1,285 @@
+"""
+Utility classes and functions
+
+- iDict : Case insensitive dictionary
+- 
+"""
+import datetime
+import re
+import string
+
+from operator import itemgetter
+
+GVAR_CHAR = '$'
+
+__all__ = ['charconvert', 
+           'superTuple', 
+           'Param', 
+           'oParam', 
+           'iDict', 
+           'validateip', 
+           'convert_consolemode', 
+           'consolemode_map',
+           'CONSOLE_REUSE', 
+           'CONSOLE_NEW', 
+           'CONSOLE_DEFAULT',
+           'formattime', 
+           'parseinput', 
+           'variable_replace',
+           'has_nonprintable',
+           'parse_param_list',
+           'scalar_to_list',
+           ]
+"""
+string converters
+"""
+def convert_hexstring(input):
+    return input
+
+def convert_wstring(input):
+    import binascii
+    return binascii.hexlify(input.encode('utf-16le') + '\x00\x00')
+
+def convert_ascii(input):
+    import binascii
+    return binascii.hexlify(input + '\x00')
+
+def convert_filename(input):
+    """Treat input as a filename; return the raw bytes from that file [in hex]."""
+    import binascii
+    try:
+        with open(input, 'rb') as fd:
+            return binascii.hexlify(fd.read())
+    except IOError:
+        raise TypeError
+
+
+"""
+Decorators
+
+"""
+def charconvert(f):
+    conv = iDict([('L:', convert_wstring),
+                  ('A:', convert_ascii),
+                  ('H:', convert_hexstring),
+                  ('F:', convert_filename)])
+    def wrap(self, input):
+        inputList = input.strip().split()
+        if len(inputList) > 1:
+            arg = ' '.join(inputList[1:])
+            try:
+                arg = conv[arg[:2]](arg[2:])
+            except (KeyError, TypeError):
+                pass
+            else:
+                input = ''.join(inputList[:1]) + ' ' + arg
+        return f(self, input)
+    wrap.__doc__ = f.__doc__
+    return wrap
+
+
+def superTuple(typename, *attribute_names):
+    """
+    Create and return a subclass of tuple with named attributes.
+    From O'Reilly Python Cookbook.
+
+    """
+    nargs = len(attribute_names)
+    class supertup(tuple):
+        __slots__ = ()
+        def __new__(cls, *args):
+            if len(args) != nargs:
+                raise TypeError, '%s takes %d args (%d given)' % (typename, nargs, len(args))
+            return tuple.__new__(cls, args)
+        def __repr__(self):
+            return '%s(%s)' % (typename, ', '.join(map(repr, self)))
+        def __eq__(self, other):
+            if hasattr(self, 'name') and hasattr(other, 'name'):
+                if self.name.upper() == other.name.upper():
+                    return True
+                else:
+                    return False
+            else:
+                return tuple.__eq__(self, other)
+
+    for index, attr_name in enumerate(attribute_names):
+        setattr(supertup, attr_name, property(itemgetter(index)))
+    supertup.__name__ = typename
+    return supertup
+
+
+Param = superTuple('Param', 'name', 'value')
+oParam = superTuple('Param', 'name', 'value', 'type', 'format')
+
+class iDict(dict):
+    """
+    Extension of the standard Python dictionary to support case insensitive
+    keys.  Still tries to store the keys in their original case but allows
+    accesses and lookups to be case insensitive.
+
+    """
+    def real_key(self, val):
+        for k in self.keys():
+            if k.lower() == val.lower():
+                return k
+        return val
+
+    def __contains__(self, i):
+        return dict.__contains__(self, self.real_key(i))
+
+    def __delitem__(self, i):
+        return dict.__delitem__(self, self.real_key(i))
+
+    def __getitem__(self, i):
+        return dict.__getitem__(self, self.real_key(i))
+
+    def __setitem__(self, i, value):
+        return dict.__setitem__(self, self.real_key(i), value)
+
+    def get(self, k, defval):
+        return dict.get(self, self.real_key(k), defval)
+
+    def has_key(self, val):
+        return dict.has_key(self, self.real_key(val))
+
+    def items(self):
+        return [Param(key,val) for key,val in dict.items(self)]
+
+
+"""
+IP Address Validation
+
+"""
+import socket
+
+def validateip(ip):
+    
+    if ip == '':
+        # This is here because Windows getaddrinfo() thinks '' is a valid IP
+        return None
+
+    try:
+        # Figure out whether we have a valid IP.  This should not throw an exception
+        socket.getaddrinfo(ip, None)
+    except Exception as e:
+        print "Address %s not valid: %s" % (ip, e)
+        return None
+    return ip
+
+
+"""
+Console mode constants and functions
+
+"""
+CONSOLE_REUSE = 1
+CONSOLE_NEW   = 2
+CONSOLE_DEFAULT = CONSOLE_REUSE
+
+consolemode_map = {"new"     : CONSOLE_NEW,
+                   "reuse"   : CONSOLE_REUSE,
+                   "default" : CONSOLE_DEFAULT}
+
+
+def convert_consolemode(str):
+    try:
+        return consolemode_map[str.lower()]
+    except:
+        return consolemode_map["default"]
+
+
+"""
+Time formatting
+
+"""
+def formattime(timestamp=None):
+    if timestamp is None:
+        timestamp = datetime.datetime.now()
+    timestamp = str(timestamp)
+    timestamp = timestamp.replace(' ', '.')
+    return timestamp.replace(':', '.')
+
+"""
+Arg line parsing
+
+"""
+def parseinput(line, count):
+    _list = line.strip().split()
+    params = []
+    for i in range(0, count):
+        try:
+            params.append(_list[i])
+        except IndexError:
+            params.append(None)
+    return (len(params) - params.count(None), params)
+
+def variable_replace(line, gvars):
+    patterns = ["(\$[A-Za-z0-9_]+)", "(\$\{[A-Za-z0-9_]+\})"]
+    newline = line.strip()
+    for p in patterns:
+        group = re.split(p, newline)
+        linelist = []
+        for g in group:
+            try:
+                if g[0] == GVAR_CHAR and g[1:] in gvars:
+                    linelist.append(gvars[g[1:]])
+                elif g[0] == GVAR_CHAR and g[2:-1] in gvars:
+                    linelist.append(gvars[g[2:-1]])
+                else:
+                    linelist.append(g)
+            except IndexError:
+                pass
+        newline = "".join(linelist)
+    return newline
+
+    
+"""
+Misc functions
+
+"""
+def has_nonprintable(line):
+    for i in line:
+        if i not in string.printable:
+            return True
+    return False
+
+
+def parse_param_list(l, ltype):
+    # Verify [ .. ] and remove
+    if not l:
+        return None
+    if l[0] != '[' or l[-1] != ']':
+        return None
+    l = l[1:-1]
+
+
+    tokens = []
+    if ltype in ('IPv4', 'IPv6', 'LocalFile', 'String', 'UString', 'Buffer'):
+        # tokens are 'token',  "token", ...
+        # quoted strings with comma and (optional) whitespace delimiters
+        while l:
+            if l[0] not in "'\"":
+                if l[0] in (' ', ','):
+                    l = l[1:]
+                    continue
+                else:
+                    return None
+            else:
+                delim = l[0]
+                l = l[1:]
+            try:
+                pos = l.index(delim)
+            except ValueError:
+                return None
+            tokens.append(l[:pos])
+            l = l[pos+1:]
+    else:
+        tokens = [t.strip() for t in l.split(',')]
+
+    return tokens
+
+def scalar_to_list(param):
+    if param.type in ('IPv4', 'IPv6', 'LocalFile', 'String', 'UString', 'Buffer'):
+        return "['" + param.value + "']"
+    else:
+        return "[" + param.value + "]"
+