Now IPython works with OS X 10.5 (Leopards) libedit based readline module.

IPython/iplib.py

@@ -6,21 +6,21 b' Requires Python 2.3 or newer.'
 
 This file contains all the classes and helper functions specific to IPython.
 
-$Id: iplib.py 2846 2007-10-24 14:44:48Z vivainio $
+$Id: iplib.py 2854 2007-11-01 20:19:34Z bgranger $
 """
 
 #*****************************************************************************
-#       Copyright (C) 2001 Janko Hauser <[e-mail]> and
-#       Copyright (C) 2001-2006 Fernando Perez. <[e-mail]>
+#		Copyright (C) 2001 Janko Hauser <[e-mail]> and
+#		Copyright (C) 2001-2006 Fernando Perez. <[e-mail]>
 #
-#  Distributed under the terms of the BSD License.  The full license is in
+#  Distributed under the terms of the BSD License.	The full license is in
 #  the file COPYING, distributed as part of this software.
 #
 # Note: this code originally subclassed code.InteractiveConsole from the
-# Python standard library.  Over time, all of that class has been copied
+# Python standard library.	Over time, all of that class has been copied
 # verbatim here for modifications which could not be accomplished by
-# subclassing.  At this point, there are no dependencies at all on the code
-# module anymore (it is not even imported).  The Python License (sec. 2)
+# subclassing.	At this point, there are no dependencies at all on the code
+# module anymore (it is not even imported).	 The Python License (sec. 2)
 # allows for this, but it's always nice to acknowledge credit where credit is
 # due.
 #*****************************************************************************
@@ -29,8 +29,8 b' $Id: iplib.py 2846 2007-10-24 14:44:48Z vivainio $'
 # Modules and globals
 
 from IPython import Release
-__author__  = '%s <%s>\n%s <%s>' % \
-              ( Release.authors['Janko'] + Release.authors['Fernando'] )
+__author__	= '%s <%s>\n%s <%s>' % \
+			  ( Release.authors['Janko'] + Release.authors['Fernando'] )
 __license__ = Release.license
 __version__ = Release.version
 
@@ -62,7 +62,7 b' from pprint import pprint, pformat'
 # IPython's own modules
 #import IPython
 from IPython import Debugger,OInspect,PyColorize,ultraTB
-from IPython.ColorANSI import ColorScheme,ColorSchemeTable  # too long names
+from IPython.ColorANSI import ColorScheme,ColorSchemeTable	# too long names
 from IPython.FakeModule import FakeModule
 from IPython.Itpl import Itpl,itpl,printpl,ItplNS,itplns
 from IPython.Logger import Logger
@@ -93,28 +93,28 b" dedent_re = re.compile(r'^\\s+raise|^\\s+return|^\\s+pass')"
 ini_spaces_re = re.compile(r'^(\s+)')
 
 def num_ini_spaces(strng):
-    """Return the number of initial spaces in a string"""
+	"""Return the number of initial spaces in a string"""
 
-    ini_spaces = ini_spaces_re.match(strng)
-    if ini_spaces:
-        return ini_spaces.end()
-    else:
-        return 0
+	ini_spaces = ini_spaces_re.match(strng)
+	if ini_spaces:
+		return ini_spaces.end()
+	else:
+		return 0
 
 def softspace(file, newvalue):
-    """Copied from code.py, to remove the dependency"""
+	"""Copied from code.py, to remove the dependency"""
 
-    oldvalue = 0
-    try:
-        oldvalue = file.softspace
-    except AttributeError:
-        pass
-    try:
-        file.softspace = newvalue
-    except (AttributeError, TypeError):
-        # "attribute-less object" or "read-only attributes"
-        pass
-    return oldvalue
+	oldvalue = 0
+	try:
+		oldvalue = file.softspace
+	except AttributeError:
+		pass
+	try:
+		file.softspace = newvalue
+	except (AttributeError, TypeError):
+		# "attribute-less object" or "read-only attributes"
+		pass
+	return oldvalue
 
 
 #****************************************************************************
@@ -129,64 +129,64 b' class Bunch: pass'
 class Undefined: pass
 
 class Quitter(object):
-    """Simple class to handle exit, similar to Python 2.5's.
-
-    It handles exiting in an ipython-safe manner, which the one in Python 2.5
-    doesn't do (obviously, since it doesn't know about ipython)."""
-    
-    def __init__(self,shell,name):
-        self.shell = shell
-        self.name = name
-        
-    def __repr__(self):
-        return 'Type %s() to exit.' % self.name
-    __str__ = __repr__
-
-    def __call__(self):
-        self.shell.exit()
+	"""Simple class to handle exit, similar to Python 2.5's.
+
+	It handles exiting in an ipython-safe manner, which the one in Python 2.5
+	doesn't do (obviously, since it doesn't know about ipython)."""
+	
+	def __init__(self,shell,name):
+		self.shell = shell
+		self.name = name
+		
+	def __repr__(self):
+		return 'Type %s() to exit.' % self.name
+	__str__ = __repr__
+
+	def __call__(self):
+		self.shell.exit()
 
 class InputList(list):
-    """Class to store user input.
+	"""Class to store user input.
 
-    It's basically a list, but slices return a string instead of a list, thus
-    allowing things like (assuming 'In' is an instance):
+	It's basically a list, but slices return a string instead of a list, thus
+	allowing things like (assuming 'In' is an instance):
 
-    exec In[4:7]
+	exec In[4:7]
 
-    or
+	or
 
-    exec In[5:9] + In[14] + In[21:25]"""
+	exec In[5:9] + In[14] + In[21:25]"""
 
-    def __getslice__(self,i,j):
-        return ''.join(list.__getslice__(self,i,j))
+	def __getslice__(self,i,j):
+		return ''.join(list.__getslice__(self,i,j))
 
 class SyntaxTB(ultraTB.ListTB):
-    """Extension which holds some state: the last exception value"""
+	"""Extension which holds some state: the last exception value"""
 
-    def __init__(self,color_scheme = 'NoColor'):
-        ultraTB.ListTB.__init__(self,color_scheme)
-        self.last_syntax_error = None
+	def __init__(self,color_scheme = 'NoColor'):
+		ultraTB.ListTB.__init__(self,color_scheme)
+		self.last_syntax_error = None
 
-    def __call__(self, etype, value, elist):
-        self.last_syntax_error = value
-        ultraTB.ListTB.__call__(self,etype,value,elist)
+	def __call__(self, etype, value, elist):
+		self.last_syntax_error = value
+		ultraTB.ListTB.__call__(self,etype,value,elist)
 
-    def clear_err_state(self):
-        """Return the current error state and clear it"""
-        e = self.last_syntax_error
-        self.last_syntax_error = None
-        return e
+	def clear_err_state(self):
+		"""Return the current error state and clear it"""
+		e = self.last_syntax_error
+		self.last_syntax_error = None
+		return e
 
 #****************************************************************************
 # Main IPython class
 
 # FIXME: the Magic class is a mixin for now, and will unfortunately remain so
-# until a full rewrite is made.  I've cleaned all cross-class uses of
+# until a full rewrite is made.	 I've cleaned all cross-class uses of
 # attributes and methods, but too much user code out there relies on the
 # equlity %foo == __IP.magic_foo, so I can't actually remove the mixin usage.
 #
 # But at least now, all the pieces have been separated and we could, in
-# principle, stop using the mixin.  This will ease the transition to the
+# principle, stop using the mixin.	This will ease the transition to the
 # chainsaw branch.
 
 # For reference, the following is the list of 'self.foo' uses in the Magic
@@ -199,278 +199,278 b' class SyntaxTB(ultraTB.ListTB):'
 #  'self.value']
 
 class InteractiveShell(object,Magic):
-    """An enhanced console for Python."""
-
-    # class attribute to indicate whether the class supports threads or not.
-    # Subclasses with thread support should override this as needed.
-    isthreaded = False
-
-    def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
-                 user_ns = None,user_global_ns=None,banner2='',
-                 custom_exceptions=((),None),embedded=False):
-
-        # log system
-        self.logger = Logger(self,logfname='ipython_log.py',logmode='rotate')
-
-        # some minimal strict typechecks.  For some core data structures, I
-        # want actual basic python types, not just anything that looks like
-        # one.  This is especially true for namespaces.
-        for ns in (user_ns,user_global_ns):
-            if ns is not None and type(ns) != types.DictType:
-                raise TypeError,'namespace must be a dictionary'
-
-        # Job manager (for jobs run as background threads)
-        self.jobs = BackgroundJobManager()
-
-        # Store the actual shell's name
-        self.name = name
-
-        # We need to know whether the instance is meant for embedding, since
-        # global/local namespaces need to be handled differently in that case
-        self.embedded = embedded
-        if embedded:
-            # Control variable so users can, from within the embedded instance,
-            # permanently deactivate it.
-            self.embedded_active = True
-
-        # command compiler
-        self.compile = codeop.CommandCompiler()
-
-        # User input buffer
-        self.buffer = []
-
-        # Default name given in compilation of code
-        self.filename = '<ipython console>'
-
-        # Install our own quitter instead of the builtins.  For python2.3-2.4,
-        # this brings in behavior like 2.5, and for 2.5 it's identical.
-        __builtin__.exit = Quitter(self,'exit')
-        __builtin__.quit = Quitter(self,'quit')
-        
-        # Make an empty namespace, which extension writers can rely on both
-        # existing and NEVER being used by ipython itself.  This gives them a
-        # convenient location for storing additional information and state
-        # their extensions may require, without fear of collisions with other
-        # ipython names that may develop later.
-        self.meta = Struct()
-
-        # Create the namespace where the user will operate.  user_ns is
-        # normally the only one used, and it is passed to the exec calls as
-        # the locals argument.  But we do carry a user_global_ns namespace
-        # given as the exec 'globals' argument,  This is useful in embedding
-        # situations where the ipython shell opens in a context where the
-        # distinction between locals and globals is meaningful.
-
-        # FIXME. For some strange reason, __builtins__ is showing up at user
-        # level as a dict instead of a module. This is a manual fix, but I
-        # should really track down where the problem is coming from. Alex
-        # Schmolck reported this problem first.
-
-        # A useful post by Alex Martelli on this topic:
-        # Re: inconsistent value from __builtins__
-        # Von: Alex Martelli <[e-mail]>
-        # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
-        # Gruppen: comp.lang.python
-
-        # Michael Hohn <[e-mail]> wrote:
-        # > >>> print type(builtin_check.get_global_binding('__builtins__'))
-        # > <type 'dict'>
-        # > >>> print type(__builtins__)
-        # > <type 'module'>
-        # > Is this difference in return value intentional?
-
-        # Well, it's documented that '__builtins__' can be either a dictionary
-        # or a module, and it's been that way for a long time. Whether it's
-        # intentional (or sensible), I don't know. In any case, the idea is
-        # that if you need to access the built-in namespace directly, you
-        # should start with "import __builtin__" (note, no 's') which will
-        # definitely give you a module. Yeah, it's somewhat confusing:-(.
-
-        # These routines return properly built dicts as needed by the rest of
-        # the code, and can also be used by extension writers to generate
-        # properly initialized namespaces.
-        user_ns = IPython.ipapi.make_user_ns(user_ns)
-        user_global_ns = IPython.ipapi.make_user_global_ns(user_global_ns)
-            
-        # Assign namespaces
-        # This is the namespace where all normal user variables live
-        self.user_ns = user_ns
-        # Embedded instances require a separate namespace for globals.
-        # Normally this one is unused by non-embedded instances.
-        self.user_global_ns = user_global_ns
-        # A namespace to keep track of internal data structures to prevent
-        # them from cluttering user-visible stuff.  Will be updated later
-        self.internal_ns = {}
-
-        # Namespace of system aliases.  Each entry in the alias
-        # table must be a 2-tuple of the form (N,name), where N is the number
-        # of positional arguments of the alias.
-        self.alias_table = {}
-
-        # A table holding all the namespaces IPython deals with, so that
-        # introspection facilities can search easily.
-        self.ns_table = {'user':user_ns,
-                         'user_global':user_global_ns,
-                         'alias':self.alias_table,
-                         'internal':self.internal_ns,
-                         'builtin':__builtin__.__dict__
-                         }
-        # The user namespace MUST have a pointer to the shell itself.
-        self.user_ns[name] = self
-
-        # We need to insert into sys.modules something that looks like a
-        # module but which accesses the IPython namespace, for shelve and
-        # pickle to work interactively. Normally they rely on getting
-        # everything out of __main__, but for embedding purposes each IPython
-        # instance has its own private namespace, so we can't go shoving
-        # everything into __main__.
-
-        # note, however, that we should only do this for non-embedded
-        # ipythons, which really mimic the __main__.__dict__ with their own
-        # namespace.  Embedded instances, on the other hand, should not do
-        # this because they need to manage the user local/global namespaces
-        # only, but they live within a 'normal' __main__ (meaning, they
-        # shouldn't overtake the execution environment of the script they're
-        # embedded in).
-
-        if not embedded:
-            try:
-                main_name = self.user_ns['__name__']
-            except KeyError:
-                raise KeyError,'user_ns dictionary MUST have a "__name__" key'
-            else:
-                #print "pickle hack in place"  # dbg
-                #print 'main_name:',main_name # dbg
-                sys.modules[main_name] = FakeModule(self.user_ns)
-
-        # Now that FakeModule produces a real module, we've run into a nasty
-        # problem: after script execution (via %run), the module where the user
-        # code ran is deleted.  Now that this object is a true module (needed
-        # so docetst and other tools work correctly), the Python module
-        # teardown mechanism runs over it, and sets to None every variable
-        # present in that module.  This means that later calls to functions
-        # defined in the script (which have become interactively visible after
-        # script exit) fail, because they hold references to objects that have
-        # become overwritten into None.  The only solution I see right now is
-        # to protect every FakeModule used by %run by holding an internal
-        # reference to it.  This private list will be used for that.  The
-        # %reset command will flush it as well.
-        self._user_main_modules = []
-
-        # List of input with multi-line handling.
-        # Fill its zero entry, user counter starts at 1
-        self.input_hist = InputList(['\n'])
-        # This one will hold the 'raw' input history, without any
-        # pre-processing.  This will allow users to retrieve the input just as
-        # it was exactly typed in by the user, with %hist -r.
-        self.input_hist_raw = InputList(['\n'])
-
-        # list of visited directories
-        try:
-            self.dir_hist = [os.getcwd()]
-        except OSError:
-            self.dir_hist = []
-
-        # dict of output history
-        self.output_hist = {}
-
-        # Get system encoding at startup time.  Certain terminals (like Emacs
-        # under Win32 have it set to None, and we need to have a known valid
-        # encoding to use in the raw_input() method
-        self.stdin_encoding = sys.stdin.encoding or 'ascii'
-
-        # dict of things NOT to alias (keywords, builtins and some magics)
-        no_alias = {}
-        no_alias_magics = ['cd','popd','pushd','dhist','alias','unalias']
-        for key in keyword.kwlist + no_alias_magics:
-            no_alias[key] = 1
-        no_alias.update(__builtin__.__dict__)
-        self.no_alias = no_alias
-                
-        # make global variables for user access to these
-        self.user_ns['_ih'] = self.input_hist
-        self.user_ns['_oh'] = self.output_hist
-        self.user_ns['_dh'] = self.dir_hist
-
-        # user aliases to input and output histories
-        self.user_ns['In']  = self.input_hist
-        self.user_ns['Out'] = self.output_hist
-
-        self.user_ns['_sh'] = IPython.shadowns
-        # Object variable to store code object waiting execution.  This is
-        # used mainly by the multithreaded shells, but it can come in handy in
-        # other situations.  No need to use a Queue here, since it's a single
-        # item which gets cleared once run.
-        self.code_to_run = None
-        
-        # escapes for automatic behavior on the command line
-        self.ESC_SHELL  = '!'
-        self.ESC_SH_CAP = '!!'
-        self.ESC_HELP   = '?'
-        self.ESC_MAGIC  = '%'
-        self.ESC_QUOTE  = ','
-        self.ESC_QUOTE2 = ';'
-        self.ESC_PAREN  = '/'
-
-        # And their associated handlers
-        self.esc_handlers = {self.ESC_PAREN  : self.handle_auto,
-                             self.ESC_QUOTE  : self.handle_auto,
-                             self.ESC_QUOTE2 : self.handle_auto,
-                             self.ESC_MAGIC  : self.handle_magic,
-                             self.ESC_HELP   : self.handle_help,
-                             self.ESC_SHELL  : self.handle_shell_escape,
-                             self.ESC_SH_CAP : self.handle_shell_escape,
-                             }
-
-        # class initializations
-        Magic.__init__(self,self)
-
-        # Python source parser/formatter for syntax highlighting
-        pyformat = PyColorize.Parser().format
-        self.pycolorize = lambda src: pyformat(src,'str',self.rc['colors'])
-
-        # hooks holds pointers used for user-side customizations
-        self.hooks = Struct()
-        
-        self.strdispatchers = {}
-        
-        # Set all default hooks, defined in the IPython.hooks module.
-        hooks = IPython.hooks
-        for hook_name in hooks.__all__:
-            # default hooks have priority 100, i.e. low; user hooks should have
-            # 0-100 priority
-            self.set_hook(hook_name,getattr(hooks,hook_name), 100)
-            #print "bound hook",hook_name
-
-        # Flag to mark unconditional exit
-        self.exit_now = False
-
-        self.usage_min =  """\
-        An enhanced console for Python.
-        Some of its features are:
-        - Readline support if the readline library is present.
-        - Tab completion in the local namespace.
-        - Logging of input, see command-line options.
-        - System shell escape via ! , eg !ls.
-        - Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)
-        - Keeps track of locally defined variables via %who, %whos.
-        - Show object information with a ? eg ?x or x? (use ?? for more info).
-        """
-        if usage: self.usage = usage
-        else: self.usage = self.usage_min
-
-        # Storage
-        self.rc = rc   # This will hold all configuration information
-        self.pager = 'less'
-        # temporary files used for various purposes.  Deleted at exit.
-        self.tempfiles = []
-
-        # Keep track of readline usage (later set by init_readline)
-        self.has_readline = False
-
-        # template for logfile headers.  It gets resolved at runtime by the
-        # logstart method.
-        self.loghead_tpl = \
+	"""An enhanced console for Python."""
+
+	# class attribute to indicate whether the class supports threads or not.
+	# Subclasses with thread support should override this as needed.
+	isthreaded = False
+
+	def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
+				 user_ns = None,user_global_ns=None,banner2='',
+				 custom_exceptions=((),None),embedded=False):
+
+		# log system
+		self.logger = Logger(self,logfname='ipython_log.py',logmode='rotate')
+
+		# some minimal strict typechecks.  For some core data structures, I
+		# want actual basic python types, not just anything that looks like
+		# one.	This is especially true for namespaces.
+		for ns in (user_ns,user_global_ns):
+			if ns is not None and type(ns) != types.DictType:
+				raise TypeError,'namespace must be a dictionary'
+
+		# Job manager (for jobs run as background threads)
+		self.jobs = BackgroundJobManager()
+
+		# Store the actual shell's name
+		self.name = name
+
+		# We need to know whether the instance is meant for embedding, since
+		# global/local namespaces need to be handled differently in that case
+		self.embedded = embedded
+		if embedded:
+			# Control variable so users can, from within the embedded instance,
+			# permanently deactivate it.
+			self.embedded_active = True
+
+		# command compiler
+		self.compile = codeop.CommandCompiler()
+
+		# User input buffer
+		self.buffer = []
+
+		# Default name given in compilation of code
+		self.filename = '<ipython console>'
+
+		# Install our own quitter instead of the builtins.	For python2.3-2.4,
+		# this brings in behavior like 2.5, and for 2.5 it's identical.
+		__builtin__.exit = Quitter(self,'exit')
+		__builtin__.quit = Quitter(self,'quit')
+		
+		# Make an empty namespace, which extension writers can rely on both
+		# existing and NEVER being used by ipython itself.	This gives them a
+		# convenient location for storing additional information and state
+		# their extensions may require, without fear of collisions with other
+		# ipython names that may develop later.
+		self.meta = Struct()
+
+		# Create the namespace where the user will operate.	 user_ns is
+		# normally the only one used, and it is passed to the exec calls as
+		# the locals argument.	But we do carry a user_global_ns namespace
+		# given as the exec 'globals' argument,	 This is useful in embedding
+		# situations where the ipython shell opens in a context where the
+		# distinction between locals and globals is meaningful.
+
+		# FIXME. For some strange reason, __builtins__ is showing up at user
+		# level as a dict instead of a module. This is a manual fix, but I
+		# should really track down where the problem is coming from. Alex
+		# Schmolck reported this problem first.
+
+		# A useful post by Alex Martelli on this topic:
+		# Re: inconsistent value from __builtins__
+		# Von: Alex Martelli <[e-mail]>
+		# Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
+		# Gruppen: comp.lang.python
+
+		# Michael Hohn <[e-mail]> wrote:
+		# > >>> print type(builtin_check.get_global_binding('__builtins__'))
+		# > <type 'dict'>
+		# > >>> print type(__builtins__)
+		# > <type 'module'>
+		# > Is this difference in return value intentional?
+
+		# Well, it's documented that '__builtins__' can be either a dictionary
+		# or a module, and it's been that way for a long time. Whether it's
+		# intentional (or sensible), I don't know. In any case, the idea is
+		# that if you need to access the built-in namespace directly, you
+		# should start with "import __builtin__" (note, no 's') which will
+		# definitely give you a module. Yeah, it's somewhat confusing:-(.
+
+		# These routines return properly built dicts as needed by the rest of
+		# the code, and can also be used by extension writers to generate
+		# properly initialized namespaces.
+		user_ns = IPython.ipapi.make_user_ns(user_ns)
+		user_global_ns = IPython.ipapi.make_user_global_ns(user_global_ns)
+			
+		# Assign namespaces
+		# This is the namespace where all normal user variables live
+		self.user_ns = user_ns
+		# Embedded instances require a separate namespace for globals.
+		# Normally this one is unused by non-embedded instances.
+		self.user_global_ns = user_global_ns
+		# A namespace to keep track of internal data structures to prevent
+		# them from cluttering user-visible stuff.	Will be updated later
+		self.internal_ns = {}
+
+		# Namespace of system aliases.	Each entry in the alias
+		# table must be a 2-tuple of the form (N,name), where N is the number
+		# of positional arguments of the alias.
+		self.alias_table = {}
+
+		# A table holding all the namespaces IPython deals with, so that
+		# introspection facilities can search easily.
+		self.ns_table = {'user':user_ns,
+						 'user_global':user_global_ns,
+						 'alias':self.alias_table,
+						 'internal':self.internal_ns,
+						 'builtin':__builtin__.__dict__
+						 }
+		# The user namespace MUST have a pointer to the shell itself.
+		self.user_ns[name] = self
+
+		# We need to insert into sys.modules something that looks like a
+		# module but which accesses the IPython namespace, for shelve and
+		# pickle to work interactively. Normally they rely on getting
+		# everything out of __main__, but for embedding purposes each IPython
+		# instance has its own private namespace, so we can't go shoving
+		# everything into __main__.
+
+		# note, however, that we should only do this for non-embedded
+		# ipythons, which really mimic the __main__.__dict__ with their own
+		# namespace.  Embedded instances, on the other hand, should not do
+		# this because they need to manage the user local/global namespaces
+		# only, but they live within a 'normal' __main__ (meaning, they
+		# shouldn't overtake the execution environment of the script they're
+		# embedded in).
+
+		if not embedded:
+			try:
+				main_name = self.user_ns['__name__']
+			except KeyError:
+				raise KeyError,'user_ns dictionary MUST have a "__name__" key'
+			else:
+				#print "pickle hack in place"  # dbg
+				#print 'main_name:',main_name # dbg
+				sys.modules[main_name] = FakeModule(self.user_ns)
+
+		# Now that FakeModule produces a real module, we've run into a nasty
+		# problem: after script execution (via %run), the module where the user
+		# code ran is deleted.	Now that this object is a true module (needed
+		# so docetst and other tools work correctly), the Python module
+		# teardown mechanism runs over it, and sets to None every variable
+		# present in that module.  This means that later calls to functions
+		# defined in the script (which have become interactively visible after
+		# script exit) fail, because they hold references to objects that have
+		# become overwritten into None.	 The only solution I see right now is
+		# to protect every FakeModule used by %run by holding an internal
+		# reference to it.	This private list will be used for that.  The
+		# %reset command will flush it as well.
+		self._user_main_modules = []
+
+		# List of input with multi-line handling.
+		# Fill its zero entry, user counter starts at 1
+		self.input_hist = InputList(['\n'])
+		# This one will hold the 'raw' input history, without any
+		# pre-processing.  This will allow users to retrieve the input just as
+		# it was exactly typed in by the user, with %hist -r.
+		self.input_hist_raw = InputList(['\n'])
+
+		# list of visited directories
+		try:
+			self.dir_hist = [os.getcwd()]
+		except OSError:
+			self.dir_hist = []
+
+		# dict of output history
+		self.output_hist = {}
+
+		# Get system encoding at startup time.	Certain terminals (like Emacs
+		# under Win32 have it set to None, and we need to have a known valid
+		# encoding to use in the raw_input() method
+		self.stdin_encoding = sys.stdin.encoding or 'ascii'
+
+		# dict of things NOT to alias (keywords, builtins and some magics)
+		no_alias = {}
+		no_alias_magics = ['cd','popd','pushd','dhist','alias','unalias']
+		for key in keyword.kwlist + no_alias_magics:
+			no_alias[key] = 1
+		no_alias.update(__builtin__.__dict__)
+		self.no_alias = no_alias
+				
+		# make global variables for user access to these
+		self.user_ns['_ih'] = self.input_hist
+		self.user_ns['_oh'] = self.output_hist
+		self.user_ns['_dh'] = self.dir_hist
+
+		# user aliases to input and output histories
+		self.user_ns['In']	= self.input_hist
+		self.user_ns['Out'] = self.output_hist
+
+		self.user_ns['_sh'] = IPython.shadowns
+		# Object variable to store code object waiting execution.  This is
+		# used mainly by the multithreaded shells, but it can come in handy in
+		# other situations.	 No need to use a Queue here, since it's a single
+		# item which gets cleared once run.
+		self.code_to_run = None
+		
+		# escapes for automatic behavior on the command line
+		self.ESC_SHELL	= '!'
+		self.ESC_SH_CAP = '!!'
+		self.ESC_HELP	= '?'
+		self.ESC_MAGIC	= '%'
+		self.ESC_QUOTE	= ','
+		self.ESC_QUOTE2 = ';'
+		self.ESC_PAREN	= '/'
+
+		# And their associated handlers
+		self.esc_handlers = {self.ESC_PAREN	 : self.handle_auto,
+							 self.ESC_QUOTE	 : self.handle_auto,
+							 self.ESC_QUOTE2 : self.handle_auto,
+							 self.ESC_MAGIC	 : self.handle_magic,
+							 self.ESC_HELP	 : self.handle_help,
+							 self.ESC_SHELL	 : self.handle_shell_escape,
+							 self.ESC_SH_CAP : self.handle_shell_escape,
+							 }
+
+		# class initializations
+		Magic.__init__(self,self)
+
+		# Python source parser/formatter for syntax highlighting
+		pyformat = PyColorize.Parser().format
+		self.pycolorize = lambda src: pyformat(src,'str',self.rc['colors'])
+
+		# hooks holds pointers used for user-side customizations
+		self.hooks = Struct()
+		
+		self.strdispatchers = {}
+		
+		# Set all default hooks, defined in the IPython.hooks module.
+		hooks = IPython.hooks
+		for hook_name in hooks.__all__:
+			# default hooks have priority 100, i.e. low; user hooks should have
+			# 0-100 priority
+			self.set_hook(hook_name,getattr(hooks,hook_name), 100)
+			#print "bound hook",hook_name
+
+		# Flag to mark unconditional exit
+		self.exit_now = False
+
+		self.usage_min =  """\
+		An enhanced console for Python.
+		Some of its features are:
+		- Readline support if the readline library is present.
+		- Tab completion in the local namespace.
+		- Logging of input, see command-line options.
+		- System shell escape via ! , eg !ls.
+		- Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)
+		- Keeps track of locally defined variables via %who, %whos.
+		- Show object information with a ? eg ?x or x? (use ?? for more info).
+		"""
+		if usage: self.usage = usage
+		else: self.usage = self.usage_min
+
+		# Storage
+		self.rc = rc   # This will hold all configuration information
+		self.pager = 'less'
+		# temporary files used for various purposes.  Deleted at exit.
+		self.tempfiles = []
+
+		# Keep track of readline usage (later set by init_readline)
+		self.has_readline = False
+
+		# template for logfile headers.	 It gets resolved at runtime by the
+		# logstart method.
+		self.loghead_tpl = \
 """#log# Automatic Logger file. *** THIS MUST BE THE FIRST LINE ***
 #log# DO NOT CHANGE THIS LINE OR THE TWO BELOW
 #log# opts = %s
@@ -478,635 +478,635 b' class InteractiveShell(object,Magic):'
 #log# It is safe to make manual edits below here.
 #log#-----------------------------------------------------------------------
 """
-        # for pushd/popd management
-        try:
-            self.home_dir = get_home_dir()
-        except HomeDirError,msg:
-            fatal(msg)
-
-        self.dir_stack = []
-
-        # Functions to call the underlying shell.
-
-        # The first is similar to os.system, but it doesn't return a value,
-        # and it allows interpolation of variables in the user's namespace.
-        self.system = lambda cmd: \
-                      shell(self.var_expand(cmd,depth=2),
-                            header=self.rc.system_header,
-                            verbose=self.rc.system_verbose)
-
-        # These are for getoutput and getoutputerror:
-        self.getoutput = lambda cmd: \
-                         getoutput(self.var_expand(cmd,depth=2),
-                                   header=self.rc.system_header,
-                                   verbose=self.rc.system_verbose)
-
-        self.getoutputerror = lambda cmd: \
-                              getoutputerror(self.var_expand(cmd,depth=2),
-                                             header=self.rc.system_header,
-                                             verbose=self.rc.system_verbose)
+		# for pushd/popd management
+		try:
+			self.home_dir = get_home_dir()
+		except HomeDirError,msg:
+			fatal(msg)
+
+		self.dir_stack = []
+
+		# Functions to call the underlying shell.
+
+		# The first is similar to os.system, but it doesn't return a value,
+		# and it allows interpolation of variables in the user's namespace.
+		self.system = lambda cmd: \
+					  shell(self.var_expand(cmd,depth=2),
+							header=self.rc.system_header,
+							verbose=self.rc.system_verbose)
+
+		# These are for getoutput and getoutputerror:
+		self.getoutput = lambda cmd: \
+						 getoutput(self.var_expand(cmd,depth=2),
+								   header=self.rc.system_header,
+								   verbose=self.rc.system_verbose)
+
+		self.getoutputerror = lambda cmd: \
+							  getoutputerror(self.var_expand(cmd,depth=2),
+											 header=self.rc.system_header,
+											 verbose=self.rc.system_verbose)
  
 
-        # keep track of where we started running (mainly for crash post-mortem)
-        self.starting_dir = os.getcwd()
-
-        # Various switches which can be set
-        self.CACHELENGTH = 5000  # this is cheap, it's just text
-        self.BANNER = "Python %(version)s on %(platform)s\n" % sys.__dict__
-        self.banner2 = banner2
-
-        # TraceBack handlers:
-
-        # Syntax error handler.
-        self.SyntaxTB = SyntaxTB(color_scheme='NoColor')
-        
-        # The interactive one is initialized with an offset, meaning we always
-        # want to remove the topmost item in the traceback, which is our own
-        # internal code. Valid modes: ['Plain','Context','Verbose']
-        self.InteractiveTB = ultraTB.AutoFormattedTB(mode = 'Plain',
-                                                     color_scheme='NoColor',
-                                                     tb_offset = 1)
-
-        # IPython itself shouldn't crash. This will produce a detailed
-        # post-mortem if it does.  But we only install the crash handler for
-        # non-threaded shells, the threaded ones use a normal verbose reporter
-        # and lose the crash handler.  This is because exceptions in the main
-        # thread (such as in GUI code) propagate directly to sys.excepthook,
-        # and there's no point in printing crash dumps for every user exception.
-        if self.isthreaded:
-            ipCrashHandler = ultraTB.FormattedTB()
-        else:
-            from IPython import CrashHandler
-            ipCrashHandler = CrashHandler.IPythonCrashHandler(self)
-        self.set_crash_handler(ipCrashHandler)
-
-        # and add any custom exception handlers the user may have specified
-        self.set_custom_exc(*custom_exceptions)
-
-        # indentation management
-        self.autoindent = False
-        self.indent_current_nsp = 0
-
-        # Make some aliases automatically
-        # Prepare list of shell aliases to auto-define
-        if os.name == 'posix':
-            auto_alias = ('mkdir mkdir', 'rmdir rmdir',
-                          'mv mv -i','rm rm -i','cp cp -i',
-                          'cat cat','less less','clear clear',
-                          # a better ls
-                          'ls ls -F',
-                          # long ls
-                          'll ls -lF')
-            # Extra ls aliases with color, which need special treatment on BSD
-            # variants
-            ls_extra = ( # color ls
-                         'lc ls -F -o --color',
-                         # ls normal files only
-                         'lf ls -F -o --color %l | grep ^-',
-                         # ls symbolic links
-                         'lk ls -F -o --color %l | grep ^l',
-                         # directories or links to directories,
-                         'ldir ls -F -o --color %l | grep /$',
-                         # things which are executable
-                         'lx ls -F -o --color %l | grep ^-..x',
-                         )
-            # The BSDs don't ship GNU ls, so they don't understand the
-            # --color switch out of the box
-            if 'bsd' in sys.platform:
-                ls_extra = ( # ls normal files only
-                             'lf ls -lF | grep ^-',
-                             # ls symbolic links
-                             'lk ls -lF | grep ^l',
-                             # directories or links to directories,
-                             'ldir ls -lF | grep /$',
-                             # things which are executable
-                             'lx ls -lF | grep ^-..x',
-                             )
-            auto_alias = auto_alias + ls_extra
-        elif os.name in ['nt','dos']:
-            auto_alias = ('ls dir /on',
-                          'ddir dir /ad /on', 'ldir dir /ad /on',
-                          'mkdir mkdir','rmdir rmdir','echo echo',
-                          'ren ren','cls cls','copy copy')
-        else:
-            auto_alias = ()
-        self.auto_alias = [s.split(None,1) for s in auto_alias]
-
-        # Produce a public API instance
-        self.api = IPython.ipapi.IPApi(self)
-
-        # Call the actual (public) initializer
-        self.init_auto_alias()
-
-        # track which builtins we add, so we can clean up later
-        self.builtins_added = {}
-        # This method will add the necessary builtins for operation, but
-        # tracking what it did via the builtins_added dict.
-        self.add_builtins()
-
-        
-
-    # end __init__
-
-    def var_expand(self,cmd,depth=0):
-        """Expand python variables in a string.
-
-        The depth argument indicates how many frames above the caller should
-        be walked to look for the local namespace where to expand variables.
-
-        The global namespace for expansion is always the user's interactive
-        namespace.
-        """
-
-        return str(ItplNS(cmd.replace('#','\#'),
-                          self.user_ns,  # globals
-                          # Skip our own frame in searching for locals:
-                          sys._getframe(depth+1).f_locals # locals
-                          ))
-
-    def pre_config_initialization(self):
-        """Pre-configuration init method
-
-        This is called before the configuration files are processed to
-        prepare the services the config files might need.
-        
-        self.rc already has reasonable default values at this point.
-        """
-        rc = self.rc
-        try:
-            self.db = pickleshare.PickleShareDB(rc.ipythondir + "/db")            
-        except exceptions.UnicodeDecodeError:
-            print "Your ipythondir can't be decoded to unicode!"
-            print "Please set HOME environment variable to something that"
-            print r"only has ASCII characters, e.g. c:\home"
-            print "Now it is",rc.ipythondir
-            sys.exit()
-        self.shadowhist = IPython.history.ShadowHist(self.db)            
-            
-    
-    def post_config_initialization(self):
-        """Post configuration init method
-
-        This is called after the configuration files have been processed to
-        'finalize' the initialization."""
-
-        rc = self.rc
-
-        # Object inspector
-        self.inspector = OInspect.Inspector(OInspect.InspectColors,
-                                            PyColorize.ANSICodeColors,
-                                            'NoColor',
-                                            rc.object_info_string_level)
-        
-        self.rl_next_input = None
-        self.rl_do_indent = False
-        # Load readline proper
-        if rc.readline:
-            self.init_readline()
-
-        
-        # local shortcut, this is used a LOT
-        self.log = self.logger.log
-
-        # Initialize cache, set in/out prompts and printing system
-        self.outputcache = CachedOutput(self,
-                                        rc.cache_size,
-                                        rc.pprint,
-                                        input_sep = rc.separate_in,
-                                        output_sep = rc.separate_out,
-                                        output_sep2 = rc.separate_out2,
-                                        ps1 = rc.prompt_in1,
-                                        ps2 = rc.prompt_in2,
-                                        ps_out = rc.prompt_out,
-                                        pad_left = rc.prompts_pad_left)
-
-        # user may have over-ridden the default print hook:
-        try:
-            self.outputcache.__class__.display = self.hooks.display
-        except AttributeError:
-            pass
-
-        # I don't like assigning globally to sys, because it means when
-        # embedding instances, each embedded instance overrides the previous
-        # choice. But sys.displayhook seems to be called internally by exec,
-        # so I don't see a way around it.  We first save the original and then
-        # overwrite it.
-        self.sys_displayhook = sys.displayhook
-        sys.displayhook = self.outputcache
-
-        # Do a proper resetting of doctest, including the necessary displayhook
-        # monkeypatching
-        doctest_reload()
-        
-        # Set user colors (don't do it in the constructor above so that it
-        # doesn't crash if colors option is invalid)
-        self.magic_colors(rc.colors)
-
-        # Set calling of pdb on exceptions
-        self.call_pdb = rc.pdb
-
-        # Load user aliases
-        for alias in rc.alias:
-            self.magic_alias(alias)
-        
-        self.hooks.late_startup_hook()
-        
-        batchrun = False
-        for batchfile in [path(arg) for arg in self.rc.args 
-            if arg.lower().endswith('.ipy')]:
-            if not batchfile.isfile():
-                print "No such batch file:", batchfile
-                continue
-            self.api.runlines(batchfile.text())
-            batchrun = True
-        # without -i option, exit after running the batch file
-        if batchrun and not self.rc.interact:
-            self.exit_now = True            
-
-    def add_builtins(self):
-        """Store ipython references into the builtin namespace.
-
-        Some parts of ipython operate via builtins injected here, which hold a
-        reference to IPython itself."""
-
-        # TODO: deprecate all except _ip; 'jobs' should be installed 
-        # by an extension and the rest are under _ip, ipalias is redundant
-        builtins_new  = dict(__IPYTHON__ = self,
-             ip_set_hook = self.set_hook, 
-             jobs = self.jobs,
-             ipmagic = wrap_deprecated(self.ipmagic,'_ip.magic()'),  
-             ipalias = wrap_deprecated(self.ipalias),  
-             ipsystem = wrap_deprecated(self.ipsystem,'_ip.system()'),
-             _ip = self.api
-             )
-        for biname,bival in builtins_new.items():
-            try:
-                # store the orignal value so we can restore it
-                self.builtins_added[biname] =  __builtin__.__dict__[biname]
-            except KeyError:
-                # or mark that it wasn't defined, and we'll just delete it at
-                # cleanup
-                self.builtins_added[biname] = Undefined
-            __builtin__.__dict__[biname] = bival
-            
-        # Keep in the builtins a flag for when IPython is active.  We set it
-        # with setdefault so that multiple nested IPythons don't clobber one
-        # another.  Each will increase its value by one upon being activated,
-        # which also gives us a way to determine the nesting level.
-        __builtin__.__dict__.setdefault('__IPYTHON__active',0)
-
-    def clean_builtins(self):
-        """Remove any builtins which might have been added by add_builtins, or
-        restore overwritten ones to their previous values."""
-        for biname,bival in self.builtins_added.items():
-            if bival is Undefined:
-                del __builtin__.__dict__[biname]
-            else:
-                __builtin__.__dict__[biname] = bival
-        self.builtins_added.clear()
-    
-    def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
-        """set_hook(name,hook) -> sets an internal IPython hook.
-
-        IPython exposes some of its internal API as user-modifiable hooks.  By
-        adding your function to one of these hooks, you can modify IPython's 
-        behavior to call at runtime your own routines."""
-
-        # At some point in the future, this should validate the hook before it
-        # accepts it.  Probably at least check that the hook takes the number
-        # of args it's supposed to.
-        
-        f = new.instancemethod(hook,self,self.__class__)
-
-        # check if the hook is for strdispatcher first
-        if str_key is not None:
-            sdp = self.strdispatchers.get(name, StrDispatch())
-            sdp.add_s(str_key, f, priority )
-            self.strdispatchers[name] = sdp
-            return
-        if re_key is not None:
-            sdp = self.strdispatchers.get(name, StrDispatch())
-            sdp.add_re(re.compile(re_key), f, priority )
-            self.strdispatchers[name] = sdp
-            return
-            
-        dp = getattr(self.hooks, name, None)
-        if name not in IPython.hooks.__all__:
-            print "Warning! Hook '%s' is not one of %s" % (name, IPython.hooks.__all__ )
-        if not dp:
-            dp = IPython.hooks.CommandChainDispatcher()
-        
-        try:
-            dp.add(f,priority)
-        except AttributeError:
-            # it was not commandchain, plain old func - replace
-            dp = f
-
-        setattr(self.hooks,name, dp)
-        
-        
-        #setattr(self.hooks,name,new.instancemethod(hook,self,self.__class__))
-
-    def set_crash_handler(self,crashHandler):
-        """Set the IPython crash handler.
-
-        This must be a callable with a signature suitable for use as
-        sys.excepthook."""
-
-        # Install the given crash handler as the Python exception hook
-        sys.excepthook = crashHandler
-        
-        # The instance will store a pointer to this, so that runtime code
-        # (such as magics) can access it.  This is because during the
-        # read-eval loop, it gets temporarily overwritten (to deal with GUI
-        # frameworks).
-        self.sys_excepthook = sys.excepthook
-
-
-    def set_custom_exc(self,exc_tuple,handler):
-        """set_custom_exc(exc_tuple,handler)
-
-        Set a custom exception handler, which will be called if any of the
-        exceptions in exc_tuple occur in the mainloop (specifically, in the
-        runcode() method.
-
-        Inputs:
-
-          - exc_tuple: a *tuple* of valid exceptions to call the defined
-          handler for.  It is very important that you use a tuple, and NOT A
-          LIST here, because of the way Python's except statement works.  If
-          you only want to trap a single exception, use a singleton tuple:
-
-            exc_tuple == (MyCustomException,)
-
-          - handler: this must be defined as a function with the following
-          basic interface: def my_handler(self,etype,value,tb).
-
-          This will be made into an instance method (via new.instancemethod)
-          of IPython itself, and it will be called if any of the exceptions
-          listed in the exc_tuple are caught.  If the handler is None, an
-          internal basic one is used, which just prints basic info.
-
-        WARNING: by putting in your own exception handler into IPython's main
-        execution loop, you run a very good chance of nasty crashes.  This
-        facility should only be used if you really know what you are doing."""
-
-        assert type(exc_tuple)==type(()) , \
-               "The custom exceptions must be given AS A TUPLE."
-
-        def dummy_handler(self,etype,value,tb):
-            print '*** Simple custom exception handler ***'
-            print 'Exception type :',etype
-            print 'Exception value:',value
-            print 'Traceback      :',tb
-            print 'Source code    :','\n'.join(self.buffer)
-
-        if handler is None: handler = dummy_handler
-
-        self.CustomTB = new.instancemethod(handler,self,self.__class__)
-        self.custom_exceptions = exc_tuple
-
-    def set_custom_completer(self,completer,pos=0):
-        """set_custom_completer(completer,pos=0)
-
-        Adds a new custom completer function.
-
-        The position argument (defaults to 0) is the index in the completers
-        list where you want the completer to be inserted."""
-
-        newcomp = new.instancemethod(completer,self.Completer,
-                                     self.Completer.__class__)
-        self.Completer.matchers.insert(pos,newcomp)
-
-    def set_completer(self):
-        """reset readline's completer to be our own."""
-        self.readline.set_completer(self.Completer.complete)
-        
-    def _get_call_pdb(self):
-        return self._call_pdb
-
-    def _set_call_pdb(self,val):
-
-        if val not in (0,1,False,True):
-            raise ValueError,'new call_pdb value must be boolean'
-
-        # store value in instance
-        self._call_pdb = val
+		# keep track of where we started running (mainly for crash post-mortem)
+		self.starting_dir = os.getcwd()
+
+		# Various switches which can be set
+		self.CACHELENGTH = 5000	 # this is cheap, it's just text
+		self.BANNER = "Python %(version)s on %(platform)s\n" % sys.__dict__
+		self.banner2 = banner2
+
+		# TraceBack handlers:
+
+		# Syntax error handler.
+		self.SyntaxTB = SyntaxTB(color_scheme='NoColor')
+		
+		# The interactive one is initialized with an offset, meaning we always
+		# want to remove the topmost item in the traceback, which is our own
+		# internal code. Valid modes: ['Plain','Context','Verbose']
+		self.InteractiveTB = ultraTB.AutoFormattedTB(mode = 'Plain',
+													 color_scheme='NoColor',
+													 tb_offset = 1)
+
+		# IPython itself shouldn't crash. This will produce a detailed
+		# post-mortem if it does.  But we only install the crash handler for
+		# non-threaded shells, the threaded ones use a normal verbose reporter
+		# and lose the crash handler.  This is because exceptions in the main
+		# thread (such as in GUI code) propagate directly to sys.excepthook,
+		# and there's no point in printing crash dumps for every user exception.
+		if self.isthreaded:
+			ipCrashHandler = ultraTB.FormattedTB()
+		else:
+			from IPython import CrashHandler
+			ipCrashHandler = CrashHandler.IPythonCrashHandler(self)
+		self.set_crash_handler(ipCrashHandler)
+
+		# and add any custom exception handlers the user may have specified
+		self.set_custom_exc(*custom_exceptions)
+
+		# indentation management
+		self.autoindent = False
+		self.indent_current_nsp = 0
+
+		# Make some aliases automatically
+		# Prepare list of shell aliases to auto-define
+		if os.name == 'posix':
+			auto_alias = ('mkdir mkdir', 'rmdir rmdir',
+						  'mv mv -i','rm rm -i','cp cp -i',
+						  'cat cat','less less','clear clear',
+						  # a better ls
+						  'ls ls -F',
+						  # long ls
+						  'll ls -lF')
+			# Extra ls aliases with color, which need special treatment on BSD
+			# variants
+			ls_extra = ( # color ls
+						 'lc ls -F -o --color',
+						 # ls normal files only
+						 'lf ls -F -o --color %l | grep ^-',
+						 # ls symbolic links
+						 'lk ls -F -o --color %l | grep ^l',
+						 # directories or links to directories,
+						 'ldir ls -F -o --color %l | grep /$',
+						 # things which are executable
+						 'lx ls -F -o --color %l | grep ^-..x',
+						 )
+			# The BSDs don't ship GNU ls, so they don't understand the
+			# --color switch out of the box
+			if 'bsd' in sys.platform:
+				ls_extra = ( # ls normal files only
+							 'lf ls -lF | grep ^-',
+							 # ls symbolic links
+							 'lk ls -lF | grep ^l',
+							 # directories or links to directories,
+							 'ldir ls -lF | grep /$',
+							 # things which are executable
+							 'lx ls -lF | grep ^-..x',
+							 )
+			auto_alias = auto_alias + ls_extra
+		elif os.name in ['nt','dos']:
+			auto_alias = ('ls dir /on',
+						  'ddir dir /ad /on', 'ldir dir /ad /on',
+						  'mkdir mkdir','rmdir rmdir','echo echo',
+						  'ren ren','cls cls','copy copy')
+		else:
+			auto_alias = ()
+		self.auto_alias = [s.split(None,1) for s in auto_alias]
+
+		# Produce a public API instance
+		self.api = IPython.ipapi.IPApi(self)
+
+		# Call the actual (public) initializer
+		self.init_auto_alias()
+
+		# track which builtins we add, so we can clean up later
+		self.builtins_added = {}
+		# This method will add the necessary builtins for operation, but
+		# tracking what it did via the builtins_added dict.
+		self.add_builtins()
+
+		
+
+	# end __init__
+
+	def var_expand(self,cmd,depth=0):
+		"""Expand python variables in a string.
+
+		The depth argument indicates how many frames above the caller should
+		be walked to look for the local namespace where to expand variables.
+
+		The global namespace for expansion is always the user's interactive
+		namespace.
+		"""
+
+		return str(ItplNS(cmd.replace('#','\#'),
+						  self.user_ns,	 # globals
+						  # Skip our own frame in searching for locals:
+						  sys._getframe(depth+1).f_locals # locals
+						  ))
+
+	def pre_config_initialization(self):
+		"""Pre-configuration init method
+
+		This is called before the configuration files are processed to
+		prepare the services the config files might need.
+		
+		self.rc already has reasonable default values at this point.
+		"""
+		rc = self.rc
+		try:
+			self.db = pickleshare.PickleShareDB(rc.ipythondir + "/db")			  
+		except exceptions.UnicodeDecodeError:
+			print "Your ipythondir can't be decoded to unicode!"
+			print "Please set HOME environment variable to something that"
+			print r"only has ASCII characters, e.g. c:\home"
+			print "Now it is",rc.ipythondir
+			sys.exit()
+		self.shadowhist = IPython.history.ShadowHist(self.db)			 
+			
+	
+	def post_config_initialization(self):
+		"""Post configuration init method
+
+		This is called after the configuration files have been processed to
+		'finalize' the initialization."""
+
+		rc = self.rc
+
+		# Object inspector
+		self.inspector = OInspect.Inspector(OInspect.InspectColors,
+											PyColorize.ANSICodeColors,
+											'NoColor',
+											rc.object_info_string_level)
+		
+		self.rl_next_input = None
+		self.rl_do_indent = False
+		# Load readline proper
+		if rc.readline:
+			self.init_readline()
+
+		
+		# local shortcut, this is used a LOT
+		self.log = self.logger.log
+
+		# Initialize cache, set in/out prompts and printing system
+		self.outputcache = CachedOutput(self,
+										rc.cache_size,
+										rc.pprint,
+										input_sep = rc.separate_in,
+										output_sep = rc.separate_out,
+										output_sep2 = rc.separate_out2,
+										ps1 = rc.prompt_in1,
+										ps2 = rc.prompt_in2,
+										ps_out = rc.prompt_out,
+										pad_left = rc.prompts_pad_left)
+
+		# user may have over-ridden the default print hook:
+		try:
+			self.outputcache.__class__.display = self.hooks.display
+		except AttributeError:
+			pass
+
+		# I don't like assigning globally to sys, because it means when
+		# embedding instances, each embedded instance overrides the previous
+		# choice. But sys.displayhook seems to be called internally by exec,
+		# so I don't see a way around it.  We first save the original and then
+		# overwrite it.
+		self.sys_displayhook = sys.displayhook
+		sys.displayhook = self.outputcache
+
+		# Do a proper resetting of doctest, including the necessary displayhook
+		# monkeypatching
+		doctest_reload()
+		
+		# Set user colors (don't do it in the constructor above so that it
+		# doesn't crash if colors option is invalid)
+		self.magic_colors(rc.colors)
+
+		# Set calling of pdb on exceptions
+		self.call_pdb = rc.pdb
+
+		# Load user aliases
+		for alias in rc.alias:
+			self.magic_alias(alias)
+		
+		self.hooks.late_startup_hook()
+		
+		batchrun = False
+		for batchfile in [path(arg) for arg in self.rc.args 
+			if arg.lower().endswith('.ipy')]:
+			if not batchfile.isfile():
+				print "No such batch file:", batchfile
+				continue
+			self.api.runlines(batchfile.text())
+			batchrun = True
+		# without -i option, exit after running the batch file
+		if batchrun and not self.rc.interact:
+			self.exit_now = True			
+
+	def add_builtins(self):
+		"""Store ipython references into the builtin namespace.
+
+		Some parts of ipython operate via builtins injected here, which hold a
+		reference to IPython itself."""
+
+		# TODO: deprecate all except _ip; 'jobs' should be installed 
+		# by an extension and the rest are under _ip, ipalias is redundant
+		builtins_new  = dict(__IPYTHON__ = self,
+			 ip_set_hook = self.set_hook, 
+			 jobs = self.jobs,
+			 ipmagic = wrap_deprecated(self.ipmagic,'_ip.magic()'),	 
+			 ipalias = wrap_deprecated(self.ipalias),  
+			 ipsystem = wrap_deprecated(self.ipsystem,'_ip.system()'),
+			 _ip = self.api
+			 )
+		for biname,bival in builtins_new.items():
+			try:
+				# store the orignal value so we can restore it
+				self.builtins_added[biname] =  __builtin__.__dict__[biname]
+			except KeyError:
+				# or mark that it wasn't defined, and we'll just delete it at
+				# cleanup
+				self.builtins_added[biname] = Undefined
+			__builtin__.__dict__[biname] = bival
+			
+		# Keep in the builtins a flag for when IPython is active.  We set it
+		# with setdefault so that multiple nested IPythons don't clobber one
+		# another.	Each will increase its value by one upon being activated,
+		# which also gives us a way to determine the nesting level.
+		__builtin__.__dict__.setdefault('__IPYTHON__active',0)
+
+	def clean_builtins(self):
+		"""Remove any builtins which might have been added by add_builtins, or
+		restore overwritten ones to their previous values."""
+		for biname,bival in self.builtins_added.items():
+			if bival is Undefined:
+				del __builtin__.__dict__[biname]
+			else:
+				__builtin__.__dict__[biname] = bival
+		self.builtins_added.clear()
+	
+	def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
+		"""set_hook(name,hook) -> sets an internal IPython hook.
+
+		IPython exposes some of its internal API as user-modifiable hooks.	By
+		adding your function to one of these hooks, you can modify IPython's 
+		behavior to call at runtime your own routines."""
+
+		# At some point in the future, this should validate the hook before it
+		# accepts it.  Probably at least check that the hook takes the number
+		# of args it's supposed to.
+		
+		f = new.instancemethod(hook,self,self.__class__)
+
+		# check if the hook is for strdispatcher first
+		if str_key is not None:
+			sdp = self.strdispatchers.get(name, StrDispatch())
+			sdp.add_s(str_key, f, priority )
+			self.strdispatchers[name] = sdp
+			return
+		if re_key is not None:
+			sdp = self.strdispatchers.get(name, StrDispatch())
+			sdp.add_re(re.compile(re_key), f, priority )
+			self.strdispatchers[name] = sdp
+			return
+			
+		dp = getattr(self.hooks, name, None)
+		if name not in IPython.hooks.__all__:
+			print "Warning! Hook '%s' is not one of %s" % (name, IPython.hooks.__all__ )
+		if not dp:
+			dp = IPython.hooks.CommandChainDispatcher()
+		
+		try:
+			dp.add(f,priority)
+		except AttributeError:
+			# it was not commandchain, plain old func - replace
+			dp = f
+
+		setattr(self.hooks,name, dp)
+		
+		
+		#setattr(self.hooks,name,new.instancemethod(hook,self,self.__class__))
+
+	def set_crash_handler(self,crashHandler):
+		"""Set the IPython crash handler.
+
+		This must be a callable with a signature suitable for use as
+		sys.excepthook."""
+
+		# Install the given crash handler as the Python exception hook
+		sys.excepthook = crashHandler
+		
+		# The instance will store a pointer to this, so that runtime code
+		# (such as magics) can access it.  This is because during the
+		# read-eval loop, it gets temporarily overwritten (to deal with GUI
+		# frameworks).
+		self.sys_excepthook = sys.excepthook
+
+
+	def set_custom_exc(self,exc_tuple,handler):
+		"""set_custom_exc(exc_tuple,handler)
+
+		Set a custom exception handler, which will be called if any of the
+		exceptions in exc_tuple occur in the mainloop (specifically, in the
+		runcode() method.
+
+		Inputs:
+
+		  - exc_tuple: a *tuple* of valid exceptions to call the defined
+		  handler for.	It is very important that you use a tuple, and NOT A
+		  LIST here, because of the way Python's except statement works.  If
+		  you only want to trap a single exception, use a singleton tuple:
+
+			exc_tuple == (MyCustomException,)
+
+		  - handler: this must be defined as a function with the following
+		  basic interface: def my_handler(self,etype,value,tb).
+
+		  This will be made into an instance method (via new.instancemethod)
+		  of IPython itself, and it will be called if any of the exceptions
+		  listed in the exc_tuple are caught.  If the handler is None, an
+		  internal basic one is used, which just prints basic info.
+
+		WARNING: by putting in your own exception handler into IPython's main
+		execution loop, you run a very good chance of nasty crashes.  This
+		facility should only be used if you really know what you are doing."""
+
+		assert type(exc_tuple)==type(()) , \
+			   "The custom exceptions must be given AS A TUPLE."
+
+		def dummy_handler(self,etype,value,tb):
+			print '*** Simple custom exception handler ***'
+			print 'Exception type :',etype
+			print 'Exception value:',value
+			print 'Traceback	  :',tb
+			print 'Source code	  :','\n'.join(self.buffer)
+
+		if handler is None: handler = dummy_handler
+
+		self.CustomTB = new.instancemethod(handler,self,self.__class__)
+		self.custom_exceptions = exc_tuple
+
+	def set_custom_completer(self,completer,pos=0):
+		"""set_custom_completer(completer,pos=0)
+
+		Adds a new custom completer function.
+
+		The position argument (defaults to 0) is the index in the completers
+		list where you want the completer to be inserted."""
+
+		newcomp = new.instancemethod(completer,self.Completer,
+									 self.Completer.__class__)
+		self.Completer.matchers.insert(pos,newcomp)
+
+	def set_completer(self):
+		"""reset readline's completer to be our own."""
+		self.readline.set_completer(self.Completer.complete)
+		
+	def _get_call_pdb(self):
+		return self._call_pdb
+
+	def _set_call_pdb(self,val):
+
+		if val not in (0,1,False,True):
+			raise ValueError,'new call_pdb value must be boolean'
+
+		# store value in instance
+		self._call_pdb = val
 
-        # notify the actual exception handlers
-        self.InteractiveTB.call_pdb = val
-        if self.isthreaded:
-            try:
-                self.sys_excepthook.call_pdb = val
-            except:
-                warn('Failed to activate pdb for threaded exception handler')
+		# notify the actual exception handlers
+		self.InteractiveTB.call_pdb = val
+		if self.isthreaded:
+			try:
+				self.sys_excepthook.call_pdb = val
+			except:
+				warn('Failed to activate pdb for threaded exception handler')
 
-    call_pdb = property(_get_call_pdb,_set_call_pdb,None,
-                        'Control auto-activation of pdb at exceptions')
+	call_pdb = property(_get_call_pdb,_set_call_pdb,None,
+						'Control auto-activation of pdb at exceptions')
  
 
-    # These special functions get installed in the builtin namespace, to
-    # provide programmatic (pure python) access to magics, aliases and system
-    # calls.  This is important for logging, user scripting, and more.
+	# These special functions get installed in the builtin namespace, to
+	# provide programmatic (pure python) access to magics, aliases and system
+	# calls.  This is important for logging, user scripting, and more.
 
-    # We are basically exposing, via normal python functions, the three
-    # mechanisms in which ipython offers special call modes (magics for
-    # internal control, aliases for direct system access via pre-selected
-    # names, and !cmd for calling arbitrary system commands).
-
-    def ipmagic(self,arg_s):
-        """Call a magic function by name.
-
-        Input: a string containing the name of the magic function to call and any
-        additional arguments to be passed to the magic.
-
-        ipmagic('name -opt foo bar') is equivalent to typing at the ipython
-        prompt:
-
-        In[1]: %name -opt foo bar
-
-        To call a magic without arguments, simply use ipmagic('name').
-
-        This provides a proper Python function to call IPython's magics in any
-        valid Python code you can type at the interpreter, including loops and
-        compound statements.  It is added by IPython to the Python builtin
-        namespace upon initialization."""
-
-        args = arg_s.split(' ',1)
-        magic_name = args[0]
-        magic_name = magic_name.lstrip(self.ESC_MAGIC)
-
-        try:
-            magic_args = args[1]
-        except IndexError:
-            magic_args = ''
-        fn = getattr(self,'magic_'+magic_name,None)
-        if fn is None:
-            error("Magic function `%s` not found." % magic_name)
-        else:
-            magic_args = self.var_expand(magic_args,1)
-            return fn(magic_args)
-
-    def ipalias(self,arg_s):
-        """Call an alias by name.
-
-        Input: a string containing the name of the alias to call and any
-        additional arguments to be passed to the magic.
-
-        ipalias('name -opt foo bar') is equivalent to typing at the ipython
-        prompt:
-
-        In[1]: name -opt foo bar
-
-        To call an alias without arguments, simply use ipalias('name').
-
-        This provides a proper Python function to call IPython's aliases in any
-        valid Python code you can type at the interpreter, including loops and
-        compound statements.  It is added by IPython to the Python builtin
-        namespace upon initialization."""
-
-        args = arg_s.split(' ',1)
-        alias_name = args[0]
-        try:
-            alias_args = args[1]
-        except IndexError:
-            alias_args = ''
-        if alias_name in self.alias_table:
-            self.call_alias(alias_name,alias_args)
-        else:
-            error("Alias `%s` not found." % alias_name)
-
-    def ipsystem(self,arg_s):
-        """Make a system call, using IPython."""
-
-        self.system(arg_s)
-
-    def complete(self,text):
-        """Return a sorted list of all possible completions on text.
-
-        Inputs:
-
-          - text: a string of text to be completed on.
-
-        This is a wrapper around the completion mechanism, similar to what
-        readline does at the command line when the TAB key is hit.  By
-        exposing it as a method, it can be used by other non-readline
-        environments (such as GUIs) for text completion.
-
-        Simple usage example:
-
-        In [1]: x = 'hello'
-
-        In [2]: __IP.complete('x.l')
-        Out[2]: ['x.ljust', 'x.lower', 'x.lstrip']"""
-        
-        complete = self.Completer.complete
-        state = 0
-        # use a dict so we get unique keys, since ipyhton's multiple
-        # completers can return duplicates.  When we make 2.4 a requirement,
-        # start using sets instead, which are faster.
-        comps = {}
-        while True:
-            newcomp = complete(text,state,line_buffer=text)
-            if newcomp is None:
-                break
-            comps[newcomp] = 1
-            state += 1
-        outcomps = comps.keys()
-        outcomps.sort()
-        return outcomps
-        
-    def set_completer_frame(self, frame=None):
-        if frame:
-            self.Completer.namespace = frame.f_locals
-            self.Completer.global_namespace = frame.f_globals
-        else:
-            self.Completer.namespace = self.user_ns
-            self.Completer.global_namespace = self.user_global_ns
-
-    def init_auto_alias(self):
-        """Define some aliases automatically.
-
-        These are ALL parameter-less aliases"""
-
-        for alias,cmd in self.auto_alias:
-            self.getapi().defalias(alias,cmd)
-            
-
-    def alias_table_validate(self,verbose=0):
-        """Update information about the alias table.
-
-        In particular, make sure no Python keywords/builtins are in it."""
-
-        no_alias = self.no_alias
-        for k in self.alias_table.keys():
-            if k in no_alias:
-                del self.alias_table[k]
-                if verbose:
-                    print ("Deleting alias <%s>, it's a Python "
-                           "keyword or builtin." % k)
-    
-    def set_autoindent(self,value=None):
-        """Set the autoindent flag, checking for readline support.
-
-        If called with no arguments, it acts as a toggle."""
-
-        if not self.has_readline:
-            if os.name == 'posix':
-                warn("The auto-indent feature requires the readline library")
-            self.autoindent = 0
-            return
-        if value is None:
-            self.autoindent = not self.autoindent
-        else:
-            self.autoindent = value
-
-    def rc_set_toggle(self,rc_field,value=None):
-        """Set or toggle a field in IPython's rc config. structure.
-
-        If called with no arguments, it acts as a toggle.
-
-        If called with a non-existent field, the resulting AttributeError
-        exception will propagate out."""
-
-        rc_val = getattr(self.rc,rc_field)
-        if value is None:
-            value = not rc_val
-        setattr(self.rc,rc_field,value)
-
-    def user_setup(self,ipythondir,rc_suffix,mode='install'):
-        """Install the user configuration directory.
-
-        Can be called when running for the first time or to upgrade the user's
-        .ipython/ directory with the mode parameter. Valid modes are 'install'
-        and 'upgrade'."""
-
-        def wait():
-            try:
-                raw_input("Please press <RETURN> to start IPython.")
-            except EOFError:
-                print >> Term.cout
-            print '*'*70
-
-        cwd = os.getcwd()  # remember where we started
-        glb = glob.glob
-        print '*'*70
-        if mode == 'install':
-            print \
+	# We are basically exposing, via normal python functions, the three
+	# mechanisms in which ipython offers special call modes (magics for
+	# internal control, aliases for direct system access via pre-selected
+	# names, and !cmd for calling arbitrary system commands).
+
+	def ipmagic(self,arg_s):
+		"""Call a magic function by name.
+
+		Input: a string containing the name of the magic function to call and any
+		additional arguments to be passed to the magic.
+
+		ipmagic('name -opt foo bar') is equivalent to typing at the ipython
+		prompt:
+
+		In[1]: %name -opt foo bar
+
+		To call a magic without arguments, simply use ipmagic('name').
+
+		This provides a proper Python function to call IPython's magics in any
+		valid Python code you can type at the interpreter, including loops and
+		compound statements.  It is added by IPython to the Python builtin
+		namespace upon initialization."""
+
+		args = arg_s.split(' ',1)
+		magic_name = args[0]
+		magic_name = magic_name.lstrip(self.ESC_MAGIC)
+
+		try:
+			magic_args = args[1]
+		except IndexError:
+			magic_args = ''
+		fn = getattr(self,'magic_'+magic_name,None)
+		if fn is None:
+			error("Magic function `%s` not found." % magic_name)
+		else:
+			magic_args = self.var_expand(magic_args,1)
+			return fn(magic_args)
+
+	def ipalias(self,arg_s):
+		"""Call an alias by name.
+
+		Input: a string containing the name of the alias to call and any
+		additional arguments to be passed to the magic.
+
+		ipalias('name -opt foo bar') is equivalent to typing at the ipython
+		prompt:
+
+		In[1]: name -opt foo bar
+
+		To call an alias without arguments, simply use ipalias('name').
+
+		This provides a proper Python function to call IPython's aliases in any
+		valid Python code you can type at the interpreter, including loops and
+		compound statements.  It is added by IPython to the Python builtin
+		namespace upon initialization."""
+
+		args = arg_s.split(' ',1)
+		alias_name = args[0]
+		try:
+			alias_args = args[1]
+		except IndexError:
+			alias_args = ''
+		if alias_name in self.alias_table:
+			self.call_alias(alias_name,alias_args)
+		else:
+			error("Alias `%s` not found." % alias_name)
+
+	def ipsystem(self,arg_s):
+		"""Make a system call, using IPython."""
+
+		self.system(arg_s)
+
+	def complete(self,text):
+		"""Return a sorted list of all possible completions on text.
+
+		Inputs:
+
+		  - text: a string of text to be completed on.
+
+		This is a wrapper around the completion mechanism, similar to what
+		readline does at the command line when the TAB key is hit.	By
+		exposing it as a method, it can be used by other non-readline
+		environments (such as GUIs) for text completion.
+
+		Simple usage example:
+
+		In [1]: x = 'hello'
+
+		In [2]: __IP.complete('x.l')
+		Out[2]: ['x.ljust', 'x.lower', 'x.lstrip']"""
+		
+		complete = self.Completer.complete
+		state = 0
+		# use a dict so we get unique keys, since ipyhton's multiple
+		# completers can return duplicates.	 When we make 2.4 a requirement,
+		# start using sets instead, which are faster.
+		comps = {}
+		while True:
+			newcomp = complete(text,state,line_buffer=text)
+			if newcomp is None:
+				break
+			comps[newcomp] = 1
+			state += 1
+		outcomps = comps.keys()
+		outcomps.sort()
+		return outcomps
+		
+	def set_completer_frame(self, frame=None):
+		if frame:
+			self.Completer.namespace = frame.f_locals
+			self.Completer.global_namespace = frame.f_globals
+		else:
+			self.Completer.namespace = self.user_ns
+			self.Completer.global_namespace = self.user_global_ns
+
+	def init_auto_alias(self):
+		"""Define some aliases automatically.
+
+		These are ALL parameter-less aliases"""
+
+		for alias,cmd in self.auto_alias:
+			self.getapi().defalias(alias,cmd)
+			
+
+	def alias_table_validate(self,verbose=0):
+		"""Update information about the alias table.
+
+		In particular, make sure no Python keywords/builtins are in it."""
+
+		no_alias = self.no_alias
+		for k in self.alias_table.keys():
+			if k in no_alias:
+				del self.alias_table[k]
+				if verbose:
+					print ("Deleting alias <%s>, it's a Python "
+						   "keyword or builtin." % k)
+	
+	def set_autoindent(self,value=None):
+		"""Set the autoindent flag, checking for readline support.
+
+		If called with no arguments, it acts as a toggle."""
+
+		if not self.has_readline:
+			if os.name == 'posix':
+				warn("The auto-indent feature requires the readline library")
+			self.autoindent = 0
+			return
+		if value is None:
+			self.autoindent = not self.autoindent
+		else:
+			self.autoindent = value
+
+	def rc_set_toggle(self,rc_field,value=None):
+		"""Set or toggle a field in IPython's rc config. structure.
+
+		If called with no arguments, it acts as a toggle.
+
+		If called with a non-existent field, the resulting AttributeError
+		exception will propagate out."""
+
+		rc_val = getattr(self.rc,rc_field)
+		if value is None:
+			value = not rc_val
+		setattr(self.rc,rc_field,value)
+
+	def user_setup(self,ipythondir,rc_suffix,mode='install'):
+		"""Install the user configuration directory.
+
+		Can be called when running for the first time or to upgrade the user's
+		.ipython/ directory with the mode parameter. Valid modes are 'install'
+		and 'upgrade'."""
+
+		def wait():
+			try:
+				raw_input("Please press <RETURN> to start IPython.")
+			except EOFError:
+				print >> Term.cout
+			print '*'*70
+
+		cwd = os.getcwd()  # remember where we started
+		glb = glob.glob
+		print '*'*70
+		if mode == 'install':
+			print \
 """Welcome to IPython. I will try to create a personal configuration directory
 where you can customize many aspects of IPython's functionality in:\n"""
-        else:
-            print 'I am going to upgrade your configuration in:'
-
-        print ipythondir
-
-        rcdirend = os.path.join('IPython','UserConfig')
-        cfg = lambda d: os.path.join(d,rcdirend)
-        try:
-            rcdir = filter(os.path.isdir,map(cfg,sys.path))[0]
-            print "Initializing from configuration",rcdir
-        except IndexError:
-            warning = """
+		else:
+			print 'I am going to upgrade your configuration in:'
+
+		print ipythondir
+
+		rcdirend = os.path.join('IPython','UserConfig')
+		cfg = lambda d: os.path.join(d,rcdirend)
+		try:
+			rcdir = filter(os.path.isdir,map(cfg,sys.path))[0]
+			print "Initializing from configuration",rcdir
+		except IndexError:
+			warning = """
 Installation error. IPython's directory was not found.
 
 Check the following:
@@ -1118,89 +1118,89 b' belonging to sys.path). You can copy it explicitly there or just link to it.'
 IPython will create a minimal default configuration for you.
 
 """
-            warn(warning)
-            wait()
-            
-            if sys.platform =='win32':
-                inif = 'ipythonrc.ini'
-            else:
-                inif = 'ipythonrc'
-            minimal_setup = {'ipy_user_conf.py' : 'import ipy_defaults', inif : '# intentionally left blank' }    
-            os.makedirs(ipythondir)
-            for f, cont in minimal_setup.items():
-                open(ipythondir + '/' + f,'w').write(cont)
-                             
-            return
-
-        if mode == 'install':
-            try:
-                shutil.copytree(rcdir,ipythondir)
-                os.chdir(ipythondir)
-                rc_files = glb("ipythonrc*")
-                for rc_file in rc_files:
-                    os.rename(rc_file,rc_file+rc_suffix)
-            except:
-                warning = """
+			warn(warning)
+			wait()
+			
+			if sys.platform =='win32':
+				inif = 'ipythonrc.ini'
+			else:
+				inif = 'ipythonrc'
+			minimal_setup = {'ipy_user_conf.py' : 'import ipy_defaults', inif : '# intentionally left blank' }	  
+			os.makedirs(ipythondir)
+			for f, cont in minimal_setup.items():
+				open(ipythondir + '/' + f,'w').write(cont)
+							 
+			return
+
+		if mode == 'install':
+			try:
+				shutil.copytree(rcdir,ipythondir)
+				os.chdir(ipythondir)
+				rc_files = glb("ipythonrc*")
+				for rc_file in rc_files:
+					os.rename(rc_file,rc_file+rc_suffix)
+			except:
+				warning = """
 
 There was a problem with the installation:
 %s
 Try to correct it or contact the developers if you think it's a bug.
 IPython will proceed with builtin defaults.""" % sys.exc_info()[1]
-                warn(warning)
-                wait()
-                return
-
-        elif mode == 'upgrade':
-            try:
-                os.chdir(ipythondir)
-            except:
-                print """
+				warn(warning)
+				wait()
+				return
+
+		elif mode == 'upgrade':
+			try:
+				os.chdir(ipythondir)
+			except:
+				print """
 Can not upgrade: changing to directory %s failed. Details:
 %s
 """ % (ipythondir,sys.exc_info()[1])
-                wait()
-                return
-            else:
-                sources = glb(os.path.join(rcdir,'[A-Za-z]*'))
-                for new_full_path in sources:
-                    new_filename = os.path.basename(new_full_path)
-                    if new_filename.startswith('ipythonrc'):
-                        new_filename = new_filename + rc_suffix
-                    # The config directory should only contain files, skip any
-                    # directories which may be there (like CVS)
-                    if os.path.isdir(new_full_path):
-                        continue
-                    if os.path.exists(new_filename):
-                        old_file = new_filename+'.old'
-                        if os.path.exists(old_file):
-                            os.remove(old_file)
-                        os.rename(new_filename,old_file)
-                    shutil.copy(new_full_path,new_filename)
-        else:
-            raise ValueError,'unrecognized mode for install:',`mode`
-
-        # Fix line-endings to those native to each platform in the config
-        # directory.
-        try:
-            os.chdir(ipythondir)
-        except:
-            print """
+				wait()
+				return
+			else:
+				sources = glb(os.path.join(rcdir,'[A-Za-z]*'))
+				for new_full_path in sources:
+					new_filename = os.path.basename(new_full_path)
+					if new_filename.startswith('ipythonrc'):
+						new_filename = new_filename + rc_suffix
+					# The config directory should only contain files, skip any
+					# directories which may be there (like CVS)
+					if os.path.isdir(new_full_path):
+						continue
+					if os.path.exists(new_filename):
+						old_file = new_filename+'.old'
+						if os.path.exists(old_file):
+							os.remove(old_file)
+						os.rename(new_filename,old_file)
+					shutil.copy(new_full_path,new_filename)
+		else:
+			raise ValueError,'unrecognized mode for install:',`mode`
+
+		# Fix line-endings to those native to each platform in the config
+		# directory.
+		try:
+			os.chdir(ipythondir)
+		except:
+			print """
 Problem: changing to directory %s failed.
 Details:
 %s
 
 Some configuration files may have incorrect line endings.  This should not
 cause any problems during execution.  """ % (ipythondir,sys.exc_info()[1])
-            wait()
-        else:
-            for fname in glb('ipythonrc*'):
-                try:
-                    native_line_ends(fname,backup=0)
-                except IOError:
-                    pass
-
-        if mode == 'install':
-            print """
+			wait()
+		else:
+			for fname in glb('ipythonrc*'):
+				try:
+					native_line_ends(fname,backup=0)
+				except IOError:
+					pass
+
+		if mode == 'install':
+			print """
 Successful installation!
 
 Please read the sections 'Initial Configuration' and 'Quick Tips' in the
@@ -1214,1357 +1214,1365 b' still in place, but its setting may be partly overridden by the settings in'
 if some of the new settings bother you. 
 
 """
-        else:
-            print """
+		else:
+			print """
 Successful upgrade!
 
 All files in your directory:
 %(ipythondir)s
 which would have been overwritten by the upgrade were backed up with a .old
-extension.  If you had made particular customizations in those files you may
+extension.	If you had made particular customizations in those files you may
 want to merge them back into the new files.""" % locals()
-        wait()
-        os.chdir(cwd)
-        # end user_setup()
-
-    def atexit_operations(self):
-        """This will be executed at the time of exit.
-
-        Saving of persistent data should be performed here. """
-
-        #print '*** IPython exit cleanup ***' # dbg
-        # input history
-        self.savehist()
-
-        # Cleanup all tempfiles left around
-        for tfile in self.tempfiles:
-            try:
-                os.unlink(tfile)
-            except OSError:
-                pass
-
-        self.hooks.shutdown_hook()
-        
-    def savehist(self):
-        """Save input history to a file (via readline library)."""
-        try:
-            self.readline.write_history_file(self.histfile)
-        except:
-            print 'Unable to save IPython command history to file: ' + \
-                  `self.histfile`
-
-    def reloadhist(self):
-        """Reload the input history from disk file."""
-
-        if self.has_readline:
-            self.readline.clear_history()
-            self.readline.read_history_file(self.shell.histfile)
-
-    def history_saving_wrapper(self, func):
-        """ Wrap func for readline history saving
-        
-        Convert func into callable that saves & restores
-        history around the call """
-        
-        if not self.has_readline:
-            return func
-        
-        def wrapper():
-            self.savehist()
-            try:
-                func()
-            finally:
-                readline.read_history_file(self.histfile)
-        return wrapper
-                
-            
-    def pre_readline(self):
-        """readline hook to be used at the start of each line.
-
-        Currently it handles auto-indent only."""
-
-        #debugx('self.indent_current_nsp','pre_readline:')
-
-        if self.rl_do_indent:
-            self.readline.insert_text(self.indent_current_str())
-        if self.rl_next_input is not None:
-            self.readline.insert_text(self.rl_next_input)
-            self.rl_next_input = None
-
-    def init_readline(self):
-        """Command history completion/saving/reloading."""
-
-
-        import IPython.rlineimpl as readline
-                  
-        if not readline.have_readline:
-            self.has_readline = 0
-            self.readline = None
-            # no point in bugging windows users with this every time:
-            warn('Readline services not available on this platform.')
-        else:
-            sys.modules['readline'] = readline
-            import atexit
-            from IPython.completer import IPCompleter
-            self.Completer = IPCompleter(self,
-                                            self.user_ns,
-                                            self.user_global_ns,
-                                            self.rc.readline_omit__names,
-                                            self.alias_table)
-            sdisp = self.strdispatchers.get('complete_command', StrDispatch())
-            self.strdispatchers['complete_command'] = sdisp
-            self.Completer.custom_completers = sdisp
-            # Platform-specific configuration
-            if os.name == 'nt':
-                self.readline_startup_hook = readline.set_pre_input_hook
-            else:
-                self.readline_startup_hook = readline.set_startup_hook
-
-            # Load user's initrc file (readline config)
-            inputrc_name = os.environ.get('INPUTRC')
-            if inputrc_name is None:
-                home_dir = get_home_dir()
-                if home_dir is not None:
-                    inputrc_name = os.path.join(home_dir,'.inputrc')
-            if os.path.isfile(inputrc_name):
-                try:
-                    readline.read_init_file(inputrc_name)
-                except:
-                    warn('Problems reading readline initialization file <%s>'
-                         % inputrc_name)
-            
-            self.has_readline = 1
-            self.readline = readline
-            # save this in sys so embedded copies can restore it properly
-            sys.ipcompleter = self.Completer.complete
-            self.set_completer()
-
-            # Configure readline according to user's prefs
-            for rlcommand in self.rc.readline_parse_and_bind:
-                readline.parse_and_bind(rlcommand)
-
-            # remove some chars from the delimiters list
-            delims = readline.get_completer_delims()
-            delims = delims.translate(string._idmap,
-                                      self.rc.readline_remove_delims)
-            readline.set_completer_delims(delims)
-            # otherwise we end up with a monster history after a while:
-            readline.set_history_length(1000)
-            try:
-                #print '*** Reading readline history'  # dbg
-                readline.read_history_file(self.histfile)
-            except IOError:
-                pass  # It doesn't exist yet.
-
-            atexit.register(self.atexit_operations)
-            del atexit
-
-        # Configure auto-indent for all platforms
-        self.set_autoindent(self.rc.autoindent)
-
-    def ask_yes_no(self,prompt,default=True):
-        if self.rc.quiet:
-            return True
-        return ask_yes_no(prompt,default)
-    
-    def _should_recompile(self,e):
-        """Utility routine for edit_syntax_error"""
-
-        if e.filename in ('<ipython console>','<input>','<string>',
-                          '<console>','<BackgroundJob compilation>',
-                          None):
-                              
-            return False
-        try:
-            if (self.rc.autoedit_syntax and 
-                not self.ask_yes_no('Return to editor to correct syntax error? '
-                              '[Y/n] ','y')):
-                return False
-        except EOFError:
-            return False
-
-        def int0(x):
-            try:
-                return int(x)
-            except TypeError:
-                return 0
-        # always pass integer line and offset values to editor hook
-        self.hooks.fix_error_editor(e.filename,
-            int0(e.lineno),int0(e.offset),e.msg)
-        return True
-        
-    def edit_syntax_error(self):
-        """The bottom half of the syntax error handler called in the main loop.
-
-        Loop until syntax error is fixed or user cancels.
-        """
-
-        while self.SyntaxTB.last_syntax_error:
-            # copy and clear last_syntax_error
-            err = self.SyntaxTB.clear_err_state()
-            if not self._should_recompile(err):
-                return
-            try:
-                # may set last_syntax_error again if a SyntaxError is raised
-                self.safe_execfile(err.filename,self.user_ns)
-            except:
-                self.showtraceback()
-            else:
-                try:
-                    f = file(err.filename)
-                    try:
-                        sys.displayhook(f.read())
-                    finally:
-                        f.close()
-                except:
-                    self.showtraceback()
-
-    def showsyntaxerror(self, filename=None):
-        """Display the syntax error that just occurred.
-
-        This doesn't display a stack trace because there isn't one.
-
-        If a filename is given, it is stuffed in the exception instead
-        of what was there before (because Python's parser always uses
-        "<string>" when reading from a string).
-        """
-        etype, value, last_traceback = sys.exc_info()
-
-        # See note about these variables in showtraceback() below
-        sys.last_type = etype
-        sys.last_value = value
-        sys.last_traceback = last_traceback
-        
-        if filename and etype is SyntaxError:
-            # Work hard to stuff the correct filename in the exception
-            try:
-                msg, (dummy_filename, lineno, offset, line) = value
-            except:
-                # Not the format we expect; leave it alone
-                pass
-            else:
-                # Stuff in the right filename
-                try:
-                    # Assume SyntaxError is a class exception
-                    value = SyntaxError(msg, (filename, lineno, offset, line))
-                except:
-                    # If that failed, assume SyntaxError is a string
-                    value = msg, (filename, lineno, offset, line)
-        self.SyntaxTB(etype,value,[])
-
-    def debugger(self,force=False):
-        """Call the pydb/pdb debugger.
-
-        Keywords:
-
-          - force(False): by default, this routine checks the instance call_pdb
-          flag and does not actually invoke the debugger if the flag is false.
-          The 'force' option forces the debugger to activate even if the flag
-          is false.
-        """
-
-        if not (force or self.call_pdb):
-            return
-
-        if not hasattr(sys,'last_traceback'):
-            error('No traceback has been produced, nothing to debug.')
-            return
-
-        # use pydb if available
-        if Debugger.has_pydb:
-            from pydb import pm
-        else:
-            # fallback to our internal debugger
-            pm = lambda : self.InteractiveTB.debugger(force=True)
-        self.history_saving_wrapper(pm)()
-
-    def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None):
-        """Display the exception that just occurred.
-
-        If nothing is known about the exception, this is the method which
-        should be used throughout the code for presenting user tracebacks,
-        rather than directly invoking the InteractiveTB object.
-
-        A specific showsyntaxerror() also exists, but this method can take
-        care of calling it if needed, so unless you are explicitly catching a
-        SyntaxError exception, don't try to analyze the stack manually and
-        simply call this method."""
-
-        
-        # Though this won't be called by syntax errors in the input line,
-        # there may be SyntaxError cases whith imported code.
-        
-        
-        if exc_tuple is None:
-            etype, value, tb = sys.exc_info()
-        else:
-            etype, value, tb = exc_tuple
-
-        if etype is SyntaxError:
-            self.showsyntaxerror(filename)
-        elif etype is IPython.ipapi.UsageError:
-            print "UsageError:", value
-        else:
-            # WARNING: these variables are somewhat deprecated and not
-            # necessarily safe to use in a threaded environment, but tools
-            # like pdb depend on their existence, so let's set them.  If we
-            # find problems in the field, we'll need to revisit their use.
-            sys.last_type = etype
-            sys.last_value = value
-            sys.last_traceback = tb
-
-            if etype in self.custom_exceptions:
-                self.CustomTB(etype,value,tb)
-            else:
-                self.InteractiveTB(etype,value,tb,tb_offset=tb_offset)
-                if self.InteractiveTB.call_pdb and self.has_readline:
-                    # pdb mucks up readline, fix it back
-                    self.set_completer()
-        
-
-    def mainloop(self,banner=None):
-        """Creates the local namespace and starts the mainloop.
-
-        If an optional banner argument is given, it will override the
-        internally created default banner."""
-
-        if self.rc.c:  # Emulate Python's -c option
-            self.exec_init_cmd()
-        if banner is None:
-            if not self.rc.banner:
-                banner = ''
-            # banner is string? Use it directly!
-            elif isinstance(self.rc.banner,basestring):
-                banner = self.rc.banner
-            else:                
-                banner = self.BANNER+self.banner2
-
-        self.interact(banner)
-
-    def exec_init_cmd(self):
-        """Execute a command given at the command line.
-
-        This emulates Python's -c option."""
-
-        #sys.argv = ['-c']
-        self.push(self.prefilter(self.rc.c, False))
-        if not self.rc.interact:
-            self.exit_now = True
-
-    def embed_mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):
-        """Embeds IPython into a running python program.
-
-        Input:
-
-          - header: An optional header message can be specified.
-
-          - local_ns, global_ns: working namespaces. If given as None, the
-          IPython-initialized one is updated with __main__.__dict__, so that
-          program variables become visible but user-specific configuration
-          remains possible.
-
-          - stack_depth: specifies how many levels in the stack to go to
-          looking for namespaces (when local_ns and global_ns are None).  This
-          allows an intermediate caller to make sure that this function gets
-          the namespace from the intended level in the stack.  By default (0)
-          it will get its locals and globals from the immediate caller.
-
-        Warning: it's possible to use this in a program which is being run by
-        IPython itself (via %run), but some funny things will happen (a few
-        globals get overwritten). In the future this will be cleaned up, as
-        there is no fundamental reason why it can't work perfectly."""
-
-        # Get locals and globals from caller
-        if local_ns is None or global_ns is None:
-            call_frame = sys._getframe(stack_depth).f_back
-
-            if local_ns is None:
-                local_ns = call_frame.f_locals
-            if global_ns is None:
-                global_ns = call_frame.f_globals
-
-        # Update namespaces and fire up interpreter
-
-        # The global one is easy, we can just throw it in
-        self.user_global_ns = global_ns
-
-        # but the user/local one is tricky: ipython needs it to store internal
-        # data, but we also need the locals.  We'll copy locals in the user
-        # one, but will track what got copied so we can delete them at exit.
-        # This is so that a later embedded call doesn't see locals from a
-        # previous call (which most likely existed in a separate scope).
-        local_varnames = local_ns.keys()
-        self.user_ns.update(local_ns)
-
-        # Patch for global embedding to make sure that things don't overwrite
-        # user globals accidentally. Thanks to Richard <[e-mail]>
-        # FIXME. Test this a bit more carefully (the if.. is new)
-        if local_ns is None and global_ns is None:
-            self.user_global_ns.update(__main__.__dict__)
-
-        # make sure the tab-completer has the correct frame information, so it
-        # actually completes using the frame's locals/globals
-        self.set_completer_frame()
-
-        # before activating the interactive mode, we need to make sure that
-        # all names in the builtin namespace needed by ipython point to
-        # ourselves, and not to other instances.
-        self.add_builtins()
-
-        self.interact(header)
-        
-        # now, purge out the user namespace from anything we might have added
-        # from the caller's local namespace
-        delvar = self.user_ns.pop
-        for var in local_varnames:
-            delvar(var,None)
-        # and clean builtins we may have overridden
-        self.clean_builtins()
-
-    def interact(self, banner=None):
-        """Closely emulate the interactive Python console.
-
-        The optional banner argument specify the banner to print
-        before the first interaction; by default it prints a banner
-        similar to the one printed by the real Python interpreter,
-        followed by the current class name in parentheses (so as not
-        to confuse this with the real interpreter -- since it's so
-        close!).
-
-        """
-        
-        if self.exit_now:
-            # batch run -> do not interact
-            return
-        cprt = 'Type "copyright", "credits" or "license" for more information.'
-        if banner is None:
-            self.write("Python %s on %s\n%s\n(%s)\n" %
-                       (sys.version, sys.platform, cprt,
-                        self.__class__.__name__))
-        else:
-            self.write(banner)
-
-        more = 0
-        
-        # Mark activity in the builtins
-        __builtin__.__dict__['__IPYTHON__active'] += 1
-        
-        if self.has_readline:
-            self.readline_startup_hook(self.pre_readline)
-        # exit_now is set by a call to %Exit or %Quit
-        
-        while not self.exit_now:
-            if more:
-                prompt = self.hooks.generate_prompt(True)
-                if self.autoindent:
-                    self.rl_do_indent = True
-                    
-            else:
-                prompt = self.hooks.generate_prompt(False)
-            try:
-                line = self.raw_input(prompt,more)
-                if self.exit_now:
-                    # quick exit on sys.std[in|out] close
-                    break
-                if self.autoindent:
-                    self.rl_do_indent = False
-                    
-            except KeyboardInterrupt:
-                self.write('\nKeyboardInterrupt\n')
-                self.resetbuffer()
-                # keep cache in sync with the prompt counter:
-                self.outputcache.prompt_count -= 1
-
-                if self.autoindent:
-                    self.indent_current_nsp = 0
-                more = 0
-            except EOFError:
-                if self.autoindent:
-                    self.rl_do_indent = False
-                    self.readline_startup_hook(None)
-                self.write('\n')
-                self.exit()
-            except bdb.BdbQuit:
-                warn('The Python debugger has exited with a BdbQuit exception.\n'
-                     'Because of how pdb handles the stack, it is impossible\n'
-                     'for IPython to properly format this particular exception.\n'
-                     'IPython will resume normal operation.')
-            except:
-                # exceptions here are VERY RARE, but they can be triggered
-                # asynchronously by signal handlers, for example.
-                self.showtraceback()
-            else:
-                more = self.push(line)
-                if (self.SyntaxTB.last_syntax_error and
-                    self.rc.autoedit_syntax):
-                    self.edit_syntax_error()
-            
-        # We are off again...
-        __builtin__.__dict__['__IPYTHON__active'] -= 1
-
-    def excepthook(self, etype, value, tb):
-      """One more defense for GUI apps that call sys.excepthook.
-
-      GUI frameworks like wxPython trap exceptions and call
-      sys.excepthook themselves.  I guess this is a feature that
-      enables them to keep running after exceptions that would
-      otherwise kill their mainloop. This is a bother for IPython
-      which excepts to catch all of the program exceptions with a try:
-      except: statement.
-
-      Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
-      any app directly invokes sys.excepthook, it will look to the user like
-      IPython crashed.  In order to work around this, we can disable the
-      CrashHandler and replace it with this excepthook instead, which prints a
-      regular traceback using our InteractiveTB.  In this fashion, apps which
-      call sys.excepthook will generate a regular-looking exception from
-      IPython, and the CrashHandler will only be triggered by real IPython
-      crashes.
-
-      This hook should be used sparingly, only in places which are not likely
-      to be true IPython errors.
-      """
-      self.showtraceback((etype,value,tb),tb_offset=0)
-
-    def expand_aliases(self,fn,rest):
-        """ Expand multiple levels of aliases:
-        
-        if:
-        
-        alias foo bar /tmp
-        alias baz foo
-        
-        then:
-        
-        baz huhhahhei -> bar /tmp huhhahhei
-        
-        """
-        line = fn + " " + rest
-        
-        done = Set()
-        while 1:
-            pre,fn,rest = prefilter.splitUserInput(line,
-                                                   prefilter.shell_line_split)
-            if fn in self.alias_table:
-                if fn in done:
-                    warn("Cyclic alias definition, repeated '%s'" % fn)
-                    return ""
-                done.add(fn)
-
-                l2 = self.transform_alias(fn,rest)
-                # dir -> dir 
-                # print "alias",line, "->",l2  #dbg
-                if l2 == line:
-                    break
-                # ls -> ls -F should not recurse forever
-                if l2.split(None,1)[0] == line.split(None,1)[0]:
-                    line = l2
-                    break
-                
-                line=l2
-                
-                
-                # print "al expand to",line #dbg
-            else:
-                break
-                
-        return line
-
-    def transform_alias(self, alias,rest=''):
-        """ Transform alias to system command string.
-        """
-        trg = self.alias_table[alias]
-
-        nargs,cmd = trg
-        # print trg #dbg
-        if ' ' in cmd and os.path.isfile(cmd):
-            cmd = '"%s"' % cmd
-
-        # Expand the %l special to be the user's input line
-        if cmd.find('%l') >= 0:
-            cmd = cmd.replace('%l',rest)
-            rest = ''
-        if nargs==0:
-            # Simple, argument-less aliases
-            cmd = '%s %s' % (cmd,rest)
-        else:
-            # Handle aliases with positional arguments
-            args = rest.split(None,nargs)
-            if len(args)< nargs:
-                error('Alias <%s> requires %s arguments, %s given.' %
-                      (alias,nargs,len(args)))
-                return None
-            cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))
-        # Now call the macro, evaluating in the user's namespace
-        #print 'new command: <%r>' % cmd  # dbg
-        return cmd
-        
-    def call_alias(self,alias,rest=''):
-        """Call an alias given its name and the rest of the line.
-
-        This is only used to provide backwards compatibility for users of
-        ipalias(), use of which is not recommended for anymore."""
-
-        # Now call the macro, evaluating in the user's namespace
-        cmd = self.transform_alias(alias, rest)
-        try:
-            self.system(cmd)
-        except:
-            self.showtraceback()
-
-    def indent_current_str(self):
-        """return the current level of indentation as a string"""
-        return self.indent_current_nsp * ' '
-
-    def autoindent_update(self,line):
-        """Keep track of the indent level."""
-
-        #debugx('line')
-        #debugx('self.indent_current_nsp')
-        if self.autoindent:
-            if line:
-                inisp = num_ini_spaces(line)
-                if inisp < self.indent_current_nsp:
-                    self.indent_current_nsp = inisp
-
-                if line[-1] == ':':
-                    self.indent_current_nsp += 4
-                elif dedent_re.match(line):
-                    self.indent_current_nsp -= 4
-            else:
-                self.indent_current_nsp = 0
-    def runlines(self,lines):
-        """Run a string of one or more lines of source.
-
-        This method is capable of running a string containing multiple source
-        lines, as if they had been entered at the IPython prompt.  Since it
-        exposes IPython's processing machinery, the given strings can contain
-        magic calls (%magic), special shell access (!cmd), etc."""
-
-        # We must start with a clean buffer, in case this is run from an
-        # interactive IPython session (via a magic, for example).
-        self.resetbuffer()
-        lines = lines.split('\n')
-        more = 0
-    
-        for line in lines:
-            # skip blank lines so we don't mess up the prompt counter, but do
-            # NOT skip even a blank line if we are in a code block (more is
-            # true)
-            
-            
-            if line or more:
-                # push to raw history, so hist line numbers stay in sync
-                self.input_hist_raw.append("# " + line + "\n")
-                more = self.push(self.prefilter(line,more))
-                # IPython's runsource returns None if there was an error
-                # compiling the code.  This allows us to stop processing right
-                # away, so the user gets the error message at the right place.
-                if more is None:
-                    break
-            else:
-                self.input_hist_raw.append("\n")
-        # final newline in case the input didn't have it, so that the code
-        # actually does get executed
-        if more:
-            self.push('\n')
-
-    def runsource(self, source, filename='<input>', symbol='single'):
-        """Compile and run some source in the interpreter.
-
-        Arguments are as for compile_command().
-
-        One several things can happen:
-
-        1) The input is incorrect; compile_command() raised an
-        exception (SyntaxError or OverflowError).  A syntax traceback
-        will be printed by calling the showsyntaxerror() method.
-
-        2) The input is incomplete, and more input is required;
-        compile_command() returned None.  Nothing happens.
-
-        3) The input is complete; compile_command() returned a code
-        object.  The code is executed by calling self.runcode() (which
-        also handles run-time exceptions, except for SystemExit).
-
-        The return value is:
-
-          - True in case 2
-
-          - False in the other cases, unless an exception is raised, where
-          None is returned instead.  This can be used by external callers to
-          know whether to continue feeding input or not.
-
-        The return value can be used to decide whether to use sys.ps1 or
-        sys.ps2 to prompt the next line."""
-
-        # if the source code has leading blanks, add 'if 1:\n' to it
-        # this allows execution of indented pasted code. It is tempting
-        # to add '\n' at the end of source to run commands like ' a=1'
-        # directly, but this fails for more complicated scenarios
-        source=source.encode(self.stdin_encoding)
-        if source[:1] in [' ', '\t']:
-            source = 'if 1:\n%s' % source
-
-        try:
-            code = self.compile(source,filename,symbol)
-        except (OverflowError, SyntaxError, ValueError):
-            # Case 1
-            self.showsyntaxerror(filename)
-            return None
-
-        if code is None:
-            # Case 2
-            return True
-
-        # Case 3
-        # We store the code object so that threaded shells and
-        # custom exception handlers can access all this info if needed.
-        # The source corresponding to this can be obtained from the
-        # buffer attribute as '\n'.join(self.buffer).
-        self.code_to_run = code
-        # now actually execute the code object
-        if self.runcode(code) == 0:
-            return False
-        else:
-            return None
-
-    def runcode(self,code_obj):
-        """Execute a code object.
-
-        When an exception occurs, self.showtraceback() is called to display a
-        traceback.
-
-        Return value: a flag indicating whether the code to be run completed
-        successfully:
-
-          - 0: successful execution.
-          - 1: an error occurred.
-        """
-
-        # Set our own excepthook in case the user code tries to call it
-        # directly, so that the IPython crash handler doesn't get triggered
-        old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
-
-        # we save the original sys.excepthook in the instance, in case config
-        # code (such as magics) needs access to it.
-        self.sys_excepthook = old_excepthook
-        outflag = 1  # happens in more places, so it's easier as default
-        try:
-            try:
-                # Embedded instances require separate global/local namespaces
-                # so they can see both the surrounding (local) namespace and
-                # the module-level globals when called inside another function.
-                if self.embedded:
-                    exec code_obj in self.user_global_ns, self.user_ns
-                # Normal (non-embedded) instances should only have a single
-                # namespace for user code execution, otherwise functions won't
-                # see interactive top-level globals.
-                else:
-                    exec code_obj in self.user_ns
-            finally:
-                # Reset our crash handler in place
-                sys.excepthook = old_excepthook
-        except SystemExit:
-            self.resetbuffer()
-            self.showtraceback()
-            warn("Type %exit or %quit to exit IPython "
-                 "(%Exit or %Quit do so unconditionally).",level=1)
-        except self.custom_exceptions:
-            etype,value,tb = sys.exc_info()
-            self.CustomTB(etype,value,tb)
-        except:
-            self.showtraceback()
-        else:
-            outflag = 0
-            if softspace(sys.stdout, 0):
-                print
-        # Flush out code object which has been run (and source)
-        self.code_to_run = None
-        return outflag
-        
-    def push(self, line):
-        """Push a line to the interpreter.
-
-        The line should not have a trailing newline; it may have
-        internal newlines.  The line is appended to a buffer and the
-        interpreter's runsource() method is called with the
-        concatenated contents of the buffer as source.  If this
-        indicates that the command was executed or invalid, the buffer
-        is reset; otherwise, the command is incomplete, and the buffer
-        is left as it was after the line was appended.  The return
-        value is 1 if more input is required, 0 if the line was dealt
-        with in some way (this is the same as runsource()).
-        """
-
-        # autoindent management should be done here, and not in the
-        # interactive loop, since that one is only seen by keyboard input.  We
-        # need this done correctly even for code run via runlines (which uses
-        # push).
-
-        #print 'push line: <%s>' % line  # dbg
-        for subline in line.splitlines():
-            self.autoindent_update(subline)
-        self.buffer.append(line)
-        more = self.runsource('\n'.join(self.buffer), self.filename)
-        if not more:
-            self.resetbuffer()
-        return more
-
-    def split_user_input(self, line):
-        # This is really a hold-over to support ipapi and some extensions
-        return prefilter.splitUserInput(line)
-
-    def resetbuffer(self):
-        """Reset the input buffer."""
-        self.buffer[:] = []
-        
-    def raw_input(self,prompt='',continue_prompt=False):
-        """Write a prompt and read a line.
-
-        The returned line does not include the trailing newline.
-        When the user enters the EOF key sequence, EOFError is raised.
-
-        Optional inputs:
-
-          - prompt(''): a string to be printed to prompt the user.
-
-          - continue_prompt(False): whether this line is the first one or a
-          continuation in a sequence of inputs.
-        """
-
-        # Code run by the user may have modified the readline completer state.
-        # We must ensure that our completer is back in place.
-        if self.has_readline:
-            self.set_completer()
-        
-        try:
-            line = raw_input_original(prompt).decode(self.stdin_encoding)
-        except ValueError:
-            warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
-                 " or sys.stdout.close()!\nExiting IPython!")
-            self.exit_now = True
-            return ""
-
-        # Try to be reasonably smart about not re-indenting pasted input more
-        # than necessary.  We do this by trimming out the auto-indent initial
-        # spaces, if the user's actual input started itself with whitespace.
-        #debugx('self.buffer[-1]')
-
-        if self.autoindent:
-            if num_ini_spaces(line) > self.indent_current_nsp:
-                line = line[self.indent_current_nsp:]
-                self.indent_current_nsp = 0
-            
-        # store the unfiltered input before the user has any chance to modify
-        # it.
-        if line.strip():
-            if continue_prompt:
-                self.input_hist_raw[-1] += '%s\n' % line
-                if self.has_readline: # and some config option is set?
-                    try:
-                        histlen = self.readline.get_current_history_length()
-                        newhist = self.input_hist_raw[-1].rstrip()
-                        self.readline.remove_history_item(histlen-1)
-                        self.readline.replace_history_item(histlen-2,newhist)
-                    except AttributeError:
-                        pass # re{move,place}_history_item are new in 2.4.                
-            else:
-                self.input_hist_raw.append('%s\n' % line)                
-            # only entries starting at first column go to shadow history
-            if line.lstrip() == line:
-                self.shadowhist.add(line.strip())
-        elif not continue_prompt:
-            self.input_hist_raw.append('\n')
-        try:
-            lineout = self.prefilter(line,continue_prompt)
-        except:
-            # blanket except, in case a user-defined prefilter crashes, so it
-            # can't take all of ipython with it.
-            self.showtraceback()
-            return ''
-        else:
-            return lineout
-
-    def _prefilter(self, line, continue_prompt):
-        """Calls different preprocessors, depending on the form of line."""
-
-        # All handlers *must* return a value, even if it's blank ('').
-
-        # Lines are NOT logged here. Handlers should process the line as
-        # needed, update the cache AND log it (so that the input cache array
-        # stays synced).
-
-        #.....................................................................
-        # Code begins
-
-        #if line.startswith('%crash'): raise RuntimeError,'Crash now!'  # dbg
-
-        # save the line away in case we crash, so the post-mortem handler can
-        # record it
-        self._last_input_line = line
-
-        #print '***line: <%s>' % line # dbg
-
-        if not line:
-            # Return immediately on purely empty lines, so that if the user
-            # previously typed some whitespace that started a continuation
-            # prompt, he can break out of that loop with just an empty line.
-            # This is how the default python prompt works.
-
-            # Only return if the accumulated input buffer was just whitespace!
-            if ''.join(self.buffer).isspace():
-                self.buffer[:] = []
-            return ''
-        
-        line_info = prefilter.LineInfo(line, continue_prompt)
-        
-        # the input history needs to track even empty lines
-        stripped = line.strip()
-        
-        if not stripped:
-            if not continue_prompt:
-                self.outputcache.prompt_count -= 1
-            return self.handle_normal(line_info)
-
-        # print '***cont',continue_prompt  # dbg
-        # special handlers are only allowed for single line statements
-        if continue_prompt and not self.rc.multi_line_specials:
-            return self.handle_normal(line_info)
-
-
-        # See whether any pre-existing handler can take care of it  
-        rewritten = self.hooks.input_prefilter(stripped)
-        if rewritten != stripped: # ok, some prefilter did something
-            rewritten = line_info.pre + rewritten  # add indentation
-            return self.handle_normal(prefilter.LineInfo(rewritten,
-                                                         continue_prompt))
-            
-        #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest)  # dbg
-        
-        return prefilter.prefilter(line_info, self)
-
-
-    def _prefilter_dumb(self, line, continue_prompt):
-        """simple prefilter function, for debugging"""
-        return self.handle_normal(line,continue_prompt)
-
-    
-    def multiline_prefilter(self, line, continue_prompt):
-        """ Run _prefilter for each line of input
-        
-        Covers cases where there are multiple lines in the user entry,
-        which is the case when the user goes back to a multiline history
-        entry and presses enter.
-        
-        """
-        out = []
-        for l in line.rstrip('\n').split('\n'):
-            out.append(self._prefilter(l, continue_prompt))
-        return '\n'.join(out)
-    
-    # Set the default prefilter() function (this can be user-overridden)
-    prefilter = multiline_prefilter
-
-    def handle_normal(self,line_info):
-        """Handle normal input lines. Use as a template for handlers."""
-
-        # With autoindent on, we need some way to exit the input loop, and I
-        # don't want to force the user to have to backspace all the way to
-        # clear the line.  The rule will be in this case, that either two
-        # lines of pure whitespace in a row, or a line of pure whitespace but
-        # of a size different to the indent level, will exit the input loop.
-        line = line_info.line
-        continue_prompt = line_info.continue_prompt
-        
-        if (continue_prompt and self.autoindent and line.isspace() and
-            (0 < abs(len(line) - self.indent_current_nsp) <= 2 or
-             (self.buffer[-1]).isspace() )):
-            line = ''
-
-        self.log(line,line,continue_prompt)
-        return line
-
-    def handle_alias(self,line_info):
-        """Handle alias input lines. """
-        tgt = self.alias_table[line_info.iFun]
-        # print "=>",tgt #dbg
-        if callable(tgt):
-            if '$' in line_info.line:
-                call_meth = '(_ip, _ip.itpl(%s))'
-            else:
-                call_meth = '(_ip,%s)'
-            line_out = ("%s_sh.%s" + call_meth) % (line_info.preWhitespace,
-                                         line_info.iFun, 
-            make_quoted_expr(line_info.line))
-        else:
-            transformed = self.expand_aliases(line_info.iFun,line_info.theRest)
-
-            # pre is needed, because it carries the leading whitespace.  Otherwise
-            # aliases won't work in indented sections.
-            line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
-                                             make_quoted_expr( transformed ))
-        
-        self.log(line_info.line,line_out,line_info.continue_prompt)
-        #print 'line out:',line_out # dbg
-        return line_out
-
-    def handle_shell_escape(self, line_info):
-        """Execute the line in a shell, empty return value"""
-        #print 'line in :', `line` # dbg
-        line = line_info.line
-        if line.lstrip().startswith('!!'):
-            # rewrite LineInfo's line, iFun and theRest to properly hold the
-            # call to %sx and the actual command to be executed, so
-            # handle_magic can work correctly.  Note that this works even if
-            # the line is indented, so it handles multi_line_specials
-            # properly.
-            new_rest = line.lstrip()[2:]
-            line_info.line = '%ssx %s' % (self.ESC_MAGIC,new_rest)
-            line_info.iFun = 'sx'
-            line_info.theRest = new_rest
-            return self.handle_magic(line_info)
-        else:
-            cmd = line.lstrip().lstrip('!')
-            line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
-                                             make_quoted_expr(cmd))
-        # update cache/log and return
-        self.log(line,line_out,line_info.continue_prompt)
-        return line_out
-
-    def handle_magic(self, line_info):
-        """Execute magic functions."""
-        iFun    = line_info.iFun
-        theRest = line_info.theRest
-        cmd = '%s_ip.magic(%s)' % (line_info.preWhitespace,
-                                   make_quoted_expr(iFun + " " + theRest))
-        self.log(line_info.line,cmd,line_info.continue_prompt)
-        #print 'in handle_magic, cmd=<%s>' % cmd  # dbg
-        return cmd
-
-    def handle_auto(self, line_info):
-        """Hande lines which can be auto-executed, quoting if requested."""
-
-        #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest)  # dbg
-        line    = line_info.line
-        iFun    = line_info.iFun
-        theRest = line_info.theRest
-        pre     = line_info.pre
-        continue_prompt = line_info.continue_prompt
-        obj = line_info.ofind(self)['obj']
-        
-        # This should only be active for single-line input!
-        if continue_prompt:
-            self.log(line,line,continue_prompt)
-            return line
-
-        force_auto = isinstance(obj, IPython.ipapi.IPyAutocall)
-        auto_rewrite = True
-        
-        if pre == self.ESC_QUOTE:
-            # Auto-quote splitting on whitespace
-            newcmd = '%s("%s")' % (iFun,'", "'.join(theRest.split()) )
-        elif pre == self.ESC_QUOTE2:
-            # Auto-quote whole string
-            newcmd = '%s("%s")' % (iFun,theRest)
-        elif pre == self.ESC_PAREN:
-            newcmd = '%s(%s)' % (iFun,",".join(theRest.split()))
-        else:
-            # Auto-paren.
-            # We only apply it to argument-less calls if the autocall
-            # parameter is set to 2.  We only need to check that autocall is <
-            # 2, since this function isn't called unless it's at least 1.
-            if not theRest and (self.rc.autocall < 2) and not force_auto:
-                newcmd = '%s %s' % (iFun,theRest)
-                auto_rewrite = False
-            else:
-                if not force_auto and theRest.startswith('['):
-                    if hasattr(obj,'__getitem__'):
-                        # Don't autocall in this case: item access for an object
-                        # which is BOTH callable and implements __getitem__.
-                        newcmd = '%s %s' % (iFun,theRest)
-                        auto_rewrite = False
-                    else:
-                        # if the object doesn't support [] access, go ahead and
-                        # autocall
-                        newcmd = '%s(%s)' % (iFun.rstrip(),theRest)
-                elif theRest.endswith(';'):
-                    newcmd = '%s(%s);' % (iFun.rstrip(),theRest[:-1])
-                else:
-                    newcmd = '%s(%s)' % (iFun.rstrip(), theRest)
-
-        if auto_rewrite:
-            rw = self.outputcache.prompt1.auto_rewrite() + newcmd
-            
-            try:
-                # plain ascii works better w/ pyreadline, on some machines, so
-                # we use it and only print uncolored rewrite if we have unicode
-                rw = str(rw)
-                print >>Term.cout, rw
-            except UnicodeEncodeError:
-                print "-------------->" + newcmd
-            
-        # log what is now valid Python, not the actual user input (without the
-        # final newline)
-        self.log(line,newcmd,continue_prompt)
-        return newcmd
-
-    def handle_help(self, line_info):
-        """Try to get some help for the object.
-
-        obj? or ?obj   -> basic information.
-        obj?? or ??obj -> more details.
-        """
-        
-        line = line_info.line
-        # We need to make sure that we don't process lines which would be
-        # otherwise valid python, such as "x=1 # what?"
-        try:
-            codeop.compile_command(line)
-        except SyntaxError:
-            # We should only handle as help stuff which is NOT valid syntax
-            if line[0]==self.ESC_HELP:
-                line = line[1:]
-            elif line[-1]==self.ESC_HELP:
-                line = line[:-1]
-            self.log(line,'#?'+line,line_info.continue_prompt)
-            if line:
-                #print 'line:<%r>' % line  # dbg
-                self.magic_pinfo(line)
-            else:
-                page(self.usage,screen_lines=self.rc.screen_length)
-            return '' # Empty string is needed here!
-        except:
-            # Pass any other exceptions through to the normal handler
-            return self.handle_normal(line_info)
-        else:
-            # If the code compiles ok, we should handle it normally
-            return self.handle_normal(line_info)
-
-    def getapi(self):
-        """ Get an IPApi object for this shell instance
-        
-        Getting an IPApi object is always preferable to accessing the shell
-        directly, but this holds true especially for extensions.
-        
-        It should always be possible to implement an extension with IPApi
-        alone. If not, contact maintainer to request an addition.
-        
-        """
-        return self.api
-
-    def handle_emacs(self, line_info):
-        """Handle input lines marked by python-mode."""
-
-        # Currently, nothing is done.  Later more functionality can be added
-        # here if needed.
-
-        # The input cache shouldn't be updated
-        return line_info.line
-    
-
-    def mktempfile(self,data=None):
-        """Make a new tempfile and return its filename.
-
-        This makes a call to tempfile.mktemp, but it registers the created
-        filename internally so ipython cleans it up at exit time.
-
-        Optional inputs:
-
-          - data(None): if data is given, it gets written out to the temp file
-          immediately, and the file is closed again."""
-
-        filename = tempfile.mktemp('.py','ipython_edit_')
-        self.tempfiles.append(filename)
-        
-        if data:
-            tmp_file = open(filename,'w')
-            tmp_file.write(data)
-            tmp_file.close()
-        return filename
-
-    def write(self,data):
-        """Write a string to the default output"""
-        Term.cout.write(data)
-
-    def write_err(self,data):
-        """Write a string to the default error output"""
-        Term.cerr.write(data)
-
-    def exit(self):
-        """Handle interactive exit.
-
-        This method sets the exit_now attribute."""
-
-        if self.rc.confirm_exit:
-            if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
-                self.exit_now = True
-        else:
-            self.exit_now = True
-
-    def safe_execfile(self,fname,*where,**kw):
-        """A safe version of the builtin execfile().
-
-        This version will never throw an exception, and knows how to handle
-        ipython logs as well.
-
-        :Parameters:
-          fname : string
-            Name of the file to be executed.
-            
-          where : tuple
-            One or two namespaces, passed to execfile() as (globals,locals).
-            If only one is given, it is passed as both.
-
-        :Keywords:
-          islog : boolean (False)
-
-          quiet : boolean (True)
-
-          exit_ignore : boolean (False)
-          """
-
-        def syspath_cleanup():
-            """Internal cleanup routine for sys.path."""
-            if add_dname:
-                try:
-                    sys.path.remove(dname)
-                except ValueError:
-                    # For some reason the user has already removed it, ignore.
-                    pass
-        
-        fname = os.path.expanduser(fname)
-
-        # Find things also in current directory.  This is needed to mimic the
-        # behavior of running a script from the system command line, where
-        # Python inserts the script's directory into sys.path
-        dname = os.path.dirname(os.path.abspath(fname))
-        add_dname = False
-        if dname not in sys.path:
-            sys.path.insert(0,dname)
-            add_dname = True
-
-        try:
-            xfile = open(fname)
-        except:
-            print >> Term.cerr, \
-                  'Could not open file <%s> for safe execution.' % fname
-            syspath_cleanup()
-            return None
-
-        kw.setdefault('islog',0)
-        kw.setdefault('quiet',1)
-        kw.setdefault('exit_ignore',0)
-        
-        first = xfile.readline()
-        loghead = str(self.loghead_tpl).split('\n',1)[0].strip()
-        xfile.close()
-        # line by line execution
-        if first.startswith(loghead) or kw['islog']:
-            print 'Loading log file <%s> one line at a time...' % fname
-            if kw['quiet']:
-                stdout_save = sys.stdout
-                sys.stdout = StringIO.StringIO()
-            try:
-                globs,locs = where[0:2]
-            except:
-                try:
-                    globs = locs = where[0]
-                except:
-                    globs = locs = globals()
-            badblocks = []
-
-            # we also need to identify indented blocks of code when replaying
-            # logs and put them together before passing them to an exec
-            # statement. This takes a bit of regexp and look-ahead work in the
-            # file. It's easiest if we swallow the whole thing in memory
-            # first, and manually walk through the lines list moving the
-            # counter ourselves.
-            indent_re = re.compile('\s+\S')
-            xfile = open(fname)
-            filelines = xfile.readlines()
-            xfile.close()
-            nlines = len(filelines)
-            lnum = 0
-            while lnum < nlines:
-                line = filelines[lnum]
-                lnum += 1
-                # don't re-insert logger status info into cache
-                if line.startswith('#log#'):
-                    continue
-                else:
-                    # build a block of code (maybe a single line) for execution
-                    block = line
-                    try:
-                        next = filelines[lnum] # lnum has already incremented
-                    except:
-                        next = None
-                    while next and indent_re.match(next):
-                        block += next
-                        lnum += 1
-                        try:
-                            next = filelines[lnum]
-                        except:
-                            next = None
-                    # now execute the block of one or more lines
-                    try:
-                        exec block in globs,locs
-                    except SystemExit:
-                        pass
-                    except:
-                        badblocks.append(block.rstrip())
-            if kw['quiet']:  # restore stdout
-                sys.stdout.close()
-                sys.stdout = stdout_save
-            print 'Finished replaying log file <%s>' % fname
-            if badblocks:
-                print >> sys.stderr, ('\nThe following lines/blocks in file '
-                                      '<%s> reported errors:' % fname)
-                    
-                for badline in badblocks:
-                    print >> sys.stderr, badline
-        else:  # regular file execution
-            try:
-                if sys.platform == 'win32' and sys.version_info < (2,5,1):
-                    # Work around a bug in Python for Windows.  The bug was
-                    # fixed in in Python 2.5 r54159 and 54158, but that's still
-                    # SVN Python as of March/07.  For details, see:
-                    # http://projects.scipy.org/ipython/ipython/ticket/123
-                    try:
-                        globs,locs = where[0:2]
-                    except:
-                        try:
-                            globs = locs = where[0]
-                        except:
-                            globs = locs = globals()
-                    exec file(fname) in globs,locs
-                else:
-                    execfile(fname,*where)
-            except SyntaxError:
-                self.showsyntaxerror()
-                warn('Failure executing file: <%s>' % fname)
-            except SystemExit,status:
-                # Code that correctly sets the exit status flag to success (0)
-                # shouldn't be bothered with a traceback.  Note that a plain
-                # sys.exit() does NOT set the message to 0 (it's empty) so that
-                # will still get a traceback.  Note that the structure of the
-                # SystemExit exception changed between Python 2.4 and 2.5, so
-                # the checks must be done in a version-dependent way.
-                show = False
-
-                if sys.version_info[:2] > (2,5):
-                    if status.message!=0 and not kw['exit_ignore']:
-                        show = True
-                else:
-                    if status.code and not kw['exit_ignore']:
-                        show = True
-                if show:
-                    self.showtraceback()
-                    warn('Failure executing file: <%s>' % fname)
-            except:
-                self.showtraceback()
-                warn('Failure executing file: <%s>' % fname)
-
-        syspath_cleanup()
+		wait()
+		os.chdir(cwd)
+		# end user_setup()
+
+	def atexit_operations(self):
+		"""This will be executed at the time of exit.
+
+		Saving of persistent data should be performed here. """
+
+		#print '*** IPython exit cleanup ***' # dbg
+		# input history
+		self.savehist()
+
+		# Cleanup all tempfiles left around
+		for tfile in self.tempfiles:
+			try:
+				os.unlink(tfile)
+			except OSError:
+				pass
+
+		self.hooks.shutdown_hook()
+		
+	def savehist(self):
+		"""Save input history to a file (via readline library)."""
+		try:
+			self.readline.write_history_file(self.histfile)
+		except:
+			print 'Unable to save IPython command history to file: ' + \
+				  `self.histfile`
+
+	def reloadhist(self):
+		"""Reload the input history from disk file."""
+
+		if self.has_readline:
+			self.readline.clear_history()
+			self.readline.read_history_file(self.shell.histfile)
+
+	def history_saving_wrapper(self, func):
+		""" Wrap func for readline history saving
+		
+		Convert func into callable that saves & restores
+		history around the call """
+		
+		if not self.has_readline:
+			return func
+		
+		def wrapper():
+			self.savehist()
+			try:
+				func()
+			finally:
+				readline.read_history_file(self.histfile)
+		return wrapper
+				
+			
+	def pre_readline(self):
+		"""readline hook to be used at the start of each line.
+
+		Currently it handles auto-indent only."""
+
+		#debugx('self.indent_current_nsp','pre_readline:')
+
+		if self.rl_do_indent:
+			self.readline.insert_text(self.indent_current_str())
+		if self.rl_next_input is not None:
+			self.readline.insert_text(self.rl_next_input)
+			self.rl_next_input = None
+
+	def init_readline(self):
+		"""Command history completion/saving/reloading."""
+
+
+		import IPython.rlineimpl as readline
+				  
+		if not readline.have_readline:
+			self.has_readline = 0
+			self.readline = None
+			# no point in bugging windows users with this every time:
+			warn('Readline services not available on this platform.')
+		else:
+			sys.modules['readline'] = readline
+			import atexit
+			from IPython.completer import IPCompleter
+			self.Completer = IPCompleter(self,
+											self.user_ns,
+											self.user_global_ns,
+											self.rc.readline_omit__names,
+											self.alias_table)
+			sdisp = self.strdispatchers.get('complete_command', StrDispatch())
+			self.strdispatchers['complete_command'] = sdisp
+			self.Completer.custom_completers = sdisp
+			# Platform-specific configuration
+			if os.name == 'nt':
+				self.readline_startup_hook = readline.set_pre_input_hook
+			else:
+				self.readline_startup_hook = readline.set_startup_hook
+
+			# Load user's initrc file (readline config)
+			# Or if libedit is used, load editrc.
+			inputrc_name = os.environ.get('INPUTRC')
+			if inputrc_name is None:
+				home_dir = get_home_dir()
+				if home_dir is not None:
+					inputrc_name = '.inputrc'
+					if readline.uses_libedit:
+						inputrc_name = '.editrc'
+					inputrc_name = os.path.join(home_dir, inputrc_name)
+			if os.path.isfile(inputrc_name):
+				try:
+					readline.read_init_file(inputrc_name)
+				except:
+					warn('Problems reading readline initialization file <%s>'
+						 % inputrc_name)
+			
+			self.has_readline = 1
+			self.readline = readline
+			# save this in sys so embedded copies can restore it properly
+			sys.ipcompleter = self.Completer.complete
+			self.set_completer()
+
+			# Configure readline according to user's prefs
+			# This is only done if GNU readline is being used.	If libedit
+			# is being used (as on Leopard) the readline config is
+			# not run as the syntax for libedit is different.
+			if not readline.uses_libedit:
+				for rlcommand in self.rc.readline_parse_and_bind:
+					readline.parse_and_bind(rlcommand)
+
+			# remove some chars from the delimiters list
+			delims = readline.get_completer_delims()
+			delims = delims.translate(string._idmap,
+									  self.rc.readline_remove_delims)
+			readline.set_completer_delims(delims)
+			# otherwise we end up with a monster history after a while:
+			readline.set_history_length(1000)
+			try:
+				#print '*** Reading readline history'  # dbg
+				readline.read_history_file(self.histfile)
+			except IOError:
+				pass  # It doesn't exist yet.
+
+			atexit.register(self.atexit_operations)
+			del atexit
+
+		# Configure auto-indent for all platforms
+		self.set_autoindent(self.rc.autoindent)
+
+	def ask_yes_no(self,prompt,default=True):
+		if self.rc.quiet:
+			return True
+		return ask_yes_no(prompt,default)
+	
+	def _should_recompile(self,e):
+		"""Utility routine for edit_syntax_error"""
+
+		if e.filename in ('<ipython console>','<input>','<string>',
+						  '<console>','<BackgroundJob compilation>',
+						  None):
+							  
+			return False
+		try:
+			if (self.rc.autoedit_syntax and 
+				not self.ask_yes_no('Return to editor to correct syntax error? '
+							  '[Y/n] ','y')):
+				return False
+		except EOFError:
+			return False
+
+		def int0(x):
+			try:
+				return int(x)
+			except TypeError:
+				return 0
+		# always pass integer line and offset values to editor hook
+		self.hooks.fix_error_editor(e.filename,
+			int0(e.lineno),int0(e.offset),e.msg)
+		return True
+		
+	def edit_syntax_error(self):
+		"""The bottom half of the syntax error handler called in the main loop.
+
+		Loop until syntax error is fixed or user cancels.
+		"""
+
+		while self.SyntaxTB.last_syntax_error:
+			# copy and clear last_syntax_error
+			err = self.SyntaxTB.clear_err_state()
+			if not self._should_recompile(err):
+				return
+			try:
+				# may set last_syntax_error again if a SyntaxError is raised
+				self.safe_execfile(err.filename,self.user_ns)
+			except:
+				self.showtraceback()
+			else:
+				try:
+					f = file(err.filename)
+					try:
+						sys.displayhook(f.read())
+					finally:
+						f.close()
+				except:
+					self.showtraceback()
+
+	def showsyntaxerror(self, filename=None):
+		"""Display the syntax error that just occurred.
+
+		This doesn't display a stack trace because there isn't one.
+
+		If a filename is given, it is stuffed in the exception instead
+		of what was there before (because Python's parser always uses
+		"<string>" when reading from a string).
+		"""
+		etype, value, last_traceback = sys.exc_info()
+
+		# See note about these variables in showtraceback() below
+		sys.last_type = etype
+		sys.last_value = value
+		sys.last_traceback = last_traceback
+		
+		if filename and etype is SyntaxError:
+			# Work hard to stuff the correct filename in the exception
+			try:
+				msg, (dummy_filename, lineno, offset, line) = value
+			except:
+				# Not the format we expect; leave it alone
+				pass
+			else:
+				# Stuff in the right filename
+				try:
+					# Assume SyntaxError is a class exception
+					value = SyntaxError(msg, (filename, lineno, offset, line))
+				except:
+					# If that failed, assume SyntaxError is a string
+					value = msg, (filename, lineno, offset, line)
+		self.SyntaxTB(etype,value,[])
+
+	def debugger(self,force=False):
+		"""Call the pydb/pdb debugger.
+
+		Keywords:
+
+		  - force(False): by default, this routine checks the instance call_pdb
+		  flag and does not actually invoke the debugger if the flag is false.
+		  The 'force' option forces the debugger to activate even if the flag
+		  is false.
+		"""
+
+		if not (force or self.call_pdb):
+			return
+
+		if not hasattr(sys,'last_traceback'):
+			error('No traceback has been produced, nothing to debug.')
+			return
+
+		# use pydb if available
+		if Debugger.has_pydb:
+			from pydb import pm
+		else:
+			# fallback to our internal debugger
+			pm = lambda : self.InteractiveTB.debugger(force=True)
+		self.history_saving_wrapper(pm)()
+
+	def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None):
+		"""Display the exception that just occurred.
+
+		If nothing is known about the exception, this is the method which
+		should be used throughout the code for presenting user tracebacks,
+		rather than directly invoking the InteractiveTB object.
+
+		A specific showsyntaxerror() also exists, but this method can take
+		care of calling it if needed, so unless you are explicitly catching a
+		SyntaxError exception, don't try to analyze the stack manually and
+		simply call this method."""
+
+		
+		# Though this won't be called by syntax errors in the input line,
+		# there may be SyntaxError cases whith imported code.
+		
+		
+		if exc_tuple is None:
+			etype, value, tb = sys.exc_info()
+		else:
+			etype, value, tb = exc_tuple
+
+		if etype is SyntaxError:
+			self.showsyntaxerror(filename)
+		elif etype is IPython.ipapi.UsageError:
+			print "UsageError:", value
+		else:
+			# WARNING: these variables are somewhat deprecated and not
+			# necessarily safe to use in a threaded environment, but tools
+			# like pdb depend on their existence, so let's set them.  If we
+			# find problems in the field, we'll need to revisit their use.
+			sys.last_type = etype
+			sys.last_value = value
+			sys.last_traceback = tb
+
+			if etype in self.custom_exceptions:
+				self.CustomTB(etype,value,tb)
+			else:
+				self.InteractiveTB(etype,value,tb,tb_offset=tb_offset)
+				if self.InteractiveTB.call_pdb and self.has_readline:
+					# pdb mucks up readline, fix it back
+					self.set_completer()
+		
+
+	def mainloop(self,banner=None):
+		"""Creates the local namespace and starts the mainloop.
+
+		If an optional banner argument is given, it will override the
+		internally created default banner."""
+
+		if self.rc.c:  # Emulate Python's -c option
+			self.exec_init_cmd()
+		if banner is None:
+			if not self.rc.banner:
+				banner = ''
+			# banner is string? Use it directly!
+			elif isinstance(self.rc.banner,basestring):
+				banner = self.rc.banner
+			else:				 
+				banner = self.BANNER+self.banner2
+
+		self.interact(banner)
+
+	def exec_init_cmd(self):
+		"""Execute a command given at the command line.
+
+		This emulates Python's -c option."""
+
+		#sys.argv = ['-c']
+		self.push(self.prefilter(self.rc.c, False))
+		if not self.rc.interact:
+			self.exit_now = True
+
+	def embed_mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):
+		"""Embeds IPython into a running python program.
+
+		Input:
+
+		  - header: An optional header message can be specified.
+
+		  - local_ns, global_ns: working namespaces. If given as None, the
+		  IPython-initialized one is updated with __main__.__dict__, so that
+		  program variables become visible but user-specific configuration
+		  remains possible.
+
+		  - stack_depth: specifies how many levels in the stack to go to
+		  looking for namespaces (when local_ns and global_ns are None).  This
+		  allows an intermediate caller to make sure that this function gets
+		  the namespace from the intended level in the stack.  By default (0)
+		  it will get its locals and globals from the immediate caller.
+
+		Warning: it's possible to use this in a program which is being run by
+		IPython itself (via %run), but some funny things will happen (a few
+		globals get overwritten). In the future this will be cleaned up, as
+		there is no fundamental reason why it can't work perfectly."""
+
+		# Get locals and globals from caller
+		if local_ns is None or global_ns is None:
+			call_frame = sys._getframe(stack_depth).f_back
+
+			if local_ns is None:
+				local_ns = call_frame.f_locals
+			if global_ns is None:
+				global_ns = call_frame.f_globals
+
+		# Update namespaces and fire up interpreter
+
+		# The global one is easy, we can just throw it in
+		self.user_global_ns = global_ns
+
+		# but the user/local one is tricky: ipython needs it to store internal
+		# data, but we also need the locals.  We'll copy locals in the user
+		# one, but will track what got copied so we can delete them at exit.
+		# This is so that a later embedded call doesn't see locals from a
+		# previous call (which most likely existed in a separate scope).
+		local_varnames = local_ns.keys()
+		self.user_ns.update(local_ns)
+
+		# Patch for global embedding to make sure that things don't overwrite
+		# user globals accidentally. Thanks to Richard <[e-mail]>
+		# FIXME. Test this a bit more carefully (the if.. is new)
+		if local_ns is None and global_ns is None:
+			self.user_global_ns.update(__main__.__dict__)
+
+		# make sure the tab-completer has the correct frame information, so it
+		# actually completes using the frame's locals/globals
+		self.set_completer_frame()
+
+		# before activating the interactive mode, we need to make sure that
+		# all names in the builtin namespace needed by ipython point to
+		# ourselves, and not to other instances.
+		self.add_builtins()
+
+		self.interact(header)
+		
+		# now, purge out the user namespace from anything we might have added
+		# from the caller's local namespace
+		delvar = self.user_ns.pop
+		for var in local_varnames:
+			delvar(var,None)
+		# and clean builtins we may have overridden
+		self.clean_builtins()
+
+	def interact(self, banner=None):
+		"""Closely emulate the interactive Python console.
+
+		The optional banner argument specify the banner to print
+		before the first interaction; by default it prints a banner
+		similar to the one printed by the real Python interpreter,
+		followed by the current class name in parentheses (so as not
+		to confuse this with the real interpreter -- since it's so
+		close!).
+
+		"""
+		
+		if self.exit_now:
+			# batch run -> do not interact
+			return
+		cprt = 'Type "copyright", "credits" or "license" for more information.'
+		if banner is None:
+			self.write("Python %s on %s\n%s\n(%s)\n" %
+					   (sys.version, sys.platform, cprt,
+						self.__class__.__name__))
+		else:
+			self.write(banner)
+
+		more = 0
+		
+		# Mark activity in the builtins
+		__builtin__.__dict__['__IPYTHON__active'] += 1
+		
+		if self.has_readline:
+			self.readline_startup_hook(self.pre_readline)
+		# exit_now is set by a call to %Exit or %Quit
+		
+		while not self.exit_now:
+			if more:
+				prompt = self.hooks.generate_prompt(True)
+				if self.autoindent:
+					self.rl_do_indent = True
+					
+			else:
+				prompt = self.hooks.generate_prompt(False)
+			try:
+				line = self.raw_input(prompt,more)
+				if self.exit_now:
+					# quick exit on sys.std[in|out] close
+					break
+				if self.autoindent:
+					self.rl_do_indent = False
+					
+			except KeyboardInterrupt:
+				self.write('\nKeyboardInterrupt\n')
+				self.resetbuffer()
+				# keep cache in sync with the prompt counter:
+				self.outputcache.prompt_count -= 1
+
+				if self.autoindent:
+					self.indent_current_nsp = 0
+				more = 0
+			except EOFError:
+				if self.autoindent:
+					self.rl_do_indent = False
+					self.readline_startup_hook(None)
+				self.write('\n')
+				self.exit()
+			except bdb.BdbQuit:
+				warn('The Python debugger has exited with a BdbQuit exception.\n'
+					 'Because of how pdb handles the stack, it is impossible\n'
+					 'for IPython to properly format this particular exception.\n'
+					 'IPython will resume normal operation.')
+			except:
+				# exceptions here are VERY RARE, but they can be triggered
+				# asynchronously by signal handlers, for example.
+				self.showtraceback()
+			else:
+				more = self.push(line)
+				if (self.SyntaxTB.last_syntax_error and
+					self.rc.autoedit_syntax):
+					self.edit_syntax_error()
+			
+		# We are off again...
+		__builtin__.__dict__['__IPYTHON__active'] -= 1
+
+	def excepthook(self, etype, value, tb):
+	  """One more defense for GUI apps that call sys.excepthook.
+
+	  GUI frameworks like wxPython trap exceptions and call
+	  sys.excepthook themselves.  I guess this is a feature that
+	  enables them to keep running after exceptions that would
+	  otherwise kill their mainloop. This is a bother for IPython
+	  which excepts to catch all of the program exceptions with a try:
+	  except: statement.
+
+	  Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
+	  any app directly invokes sys.excepthook, it will look to the user like
+	  IPython crashed.	In order to work around this, we can disable the
+	  CrashHandler and replace it with this excepthook instead, which prints a
+	  regular traceback using our InteractiveTB.  In this fashion, apps which
+	  call sys.excepthook will generate a regular-looking exception from
+	  IPython, and the CrashHandler will only be triggered by real IPython
+	  crashes.
+
+	  This hook should be used sparingly, only in places which are not likely
+	  to be true IPython errors.
+	  """
+	  self.showtraceback((etype,value,tb),tb_offset=0)
+
+	def expand_aliases(self,fn,rest):
+		""" Expand multiple levels of aliases:
+		
+		if:
+		
+		alias foo bar /tmp
+		alias baz foo
+		
+		then:
+		
+		baz huhhahhei -> bar /tmp huhhahhei
+		
+		"""
+		line = fn + " " + rest
+		
+		done = Set()
+		while 1:
+			pre,fn,rest = prefilter.splitUserInput(line,
+												   prefilter.shell_line_split)
+			if fn in self.alias_table:
+				if fn in done:
+					warn("Cyclic alias definition, repeated '%s'" % fn)
+					return ""
+				done.add(fn)
+
+				l2 = self.transform_alias(fn,rest)
+				# dir -> dir 
+				# print "alias",line, "->",l2  #dbg
+				if l2 == line:
+					break
+				# ls -> ls -F should not recurse forever
+				if l2.split(None,1)[0] == line.split(None,1)[0]:
+					line = l2
+					break
+				
+				line=l2
+				
+				
+				# print "al expand to",line #dbg
+			else:
+				break
+				
+		return line
+
+	def transform_alias(self, alias,rest=''):
+		""" Transform alias to system command string.
+		"""
+		trg = self.alias_table[alias]
+
+		nargs,cmd = trg
+		# print trg #dbg
+		if ' ' in cmd and os.path.isfile(cmd):
+			cmd = '"%s"' % cmd
+
+		# Expand the %l special to be the user's input line
+		if cmd.find('%l') >= 0:
+			cmd = cmd.replace('%l',rest)
+			rest = ''
+		if nargs==0:
+			# Simple, argument-less aliases
+			cmd = '%s %s' % (cmd,rest)
+		else:
+			# Handle aliases with positional arguments
+			args = rest.split(None,nargs)
+			if len(args)< nargs:
+				error('Alias <%s> requires %s arguments, %s given.' %
+					  (alias,nargs,len(args)))
+				return None
+			cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))
+		# Now call the macro, evaluating in the user's namespace
+		#print 'new command: <%r>' % cmd  # dbg
+		return cmd
+		
+	def call_alias(self,alias,rest=''):
+		"""Call an alias given its name and the rest of the line.
+
+		This is only used to provide backwards compatibility for users of
+		ipalias(), use of which is not recommended for anymore."""
+
+		# Now call the macro, evaluating in the user's namespace
+		cmd = self.transform_alias(alias, rest)
+		try:
+			self.system(cmd)
+		except:
+			self.showtraceback()
+
+	def indent_current_str(self):
+		"""return the current level of indentation as a string"""
+		return self.indent_current_nsp * ' '
+
+	def autoindent_update(self,line):
+		"""Keep track of the indent level."""
+
+		#debugx('line')
+		#debugx('self.indent_current_nsp')
+		if self.autoindent:
+			if line:
+				inisp = num_ini_spaces(line)
+				if inisp < self.indent_current_nsp:
+					self.indent_current_nsp = inisp
+
+				if line[-1] == ':':
+					self.indent_current_nsp += 4
+				elif dedent_re.match(line):
+					self.indent_current_nsp -= 4
+			else:
+				self.indent_current_nsp = 0
+	def runlines(self,lines):
+		"""Run a string of one or more lines of source.
+
+		This method is capable of running a string containing multiple source
+		lines, as if they had been entered at the IPython prompt.  Since it
+		exposes IPython's processing machinery, the given strings can contain
+		magic calls (%magic), special shell access (!cmd), etc."""
+
+		# We must start with a clean buffer, in case this is run from an
+		# interactive IPython session (via a magic, for example).
+		self.resetbuffer()
+		lines = lines.split('\n')
+		more = 0
+	
+		for line in lines:
+			# skip blank lines so we don't mess up the prompt counter, but do
+			# NOT skip even a blank line if we are in a code block (more is
+			# true)
+			
+			
+			if line or more:
+				# push to raw history, so hist line numbers stay in sync
+				self.input_hist_raw.append("# " + line + "\n")
+				more = self.push(self.prefilter(line,more))
+				# IPython's runsource returns None if there was an error
+				# compiling the code.  This allows us to stop processing right
+				# away, so the user gets the error message at the right place.
+				if more is None:
+					break
+			else:
+				self.input_hist_raw.append("\n")
+		# final newline in case the input didn't have it, so that the code
+		# actually does get executed
+		if more:
+			self.push('\n')
+
+	def runsource(self, source, filename='<input>', symbol='single'):
+		"""Compile and run some source in the interpreter.
+
+		Arguments are as for compile_command().
+
+		One several things can happen:
+
+		1) The input is incorrect; compile_command() raised an
+		exception (SyntaxError or OverflowError).  A syntax traceback
+		will be printed by calling the showsyntaxerror() method.
+
+		2) The input is incomplete, and more input is required;
+		compile_command() returned None.  Nothing happens.
+
+		3) The input is complete; compile_command() returned a code
+		object.	 The code is executed by calling self.runcode() (which
+		also handles run-time exceptions, except for SystemExit).
+
+		The return value is:
+
+		  - True in case 2
+
+		  - False in the other cases, unless an exception is raised, where
+		  None is returned instead.	 This can be used by external callers to
+		  know whether to continue feeding input or not.
+
+		The return value can be used to decide whether to use sys.ps1 or
+		sys.ps2 to prompt the next line."""
+
+		# if the source code has leading blanks, add 'if 1:\n' to it
+		# this allows execution of indented pasted code. It is tempting
+		# to add '\n' at the end of source to run commands like ' a=1'
+		# directly, but this fails for more complicated scenarios
+		source=source.encode(self.stdin_encoding)
+		if source[:1] in [' ', '\t']:
+			source = 'if 1:\n%s' % source
+
+		try:
+			code = self.compile(source,filename,symbol)
+		except (OverflowError, SyntaxError, ValueError):
+			# Case 1
+			self.showsyntaxerror(filename)
+			return None
+
+		if code is None:
+			# Case 2
+			return True
+
+		# Case 3
+		# We store the code object so that threaded shells and
+		# custom exception handlers can access all this info if needed.
+		# The source corresponding to this can be obtained from the
+		# buffer attribute as '\n'.join(self.buffer).
+		self.code_to_run = code
+		# now actually execute the code object
+		if self.runcode(code) == 0:
+			return False
+		else:
+			return None
+
+	def runcode(self,code_obj):
+		"""Execute a code object.
+
+		When an exception occurs, self.showtraceback() is called to display a
+		traceback.
+
+		Return value: a flag indicating whether the code to be run completed
+		successfully:
+
+		  - 0: successful execution.
+		  - 1: an error occurred.
+		"""
+
+		# Set our own excepthook in case the user code tries to call it
+		# directly, so that the IPython crash handler doesn't get triggered
+		old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
+
+		# we save the original sys.excepthook in the instance, in case config
+		# code (such as magics) needs access to it.
+		self.sys_excepthook = old_excepthook
+		outflag = 1	 # happens in more places, so it's easier as default
+		try:
+			try:
+				# Embedded instances require separate global/local namespaces
+				# so they can see both the surrounding (local) namespace and
+				# the module-level globals when called inside another function.
+				if self.embedded:
+					exec code_obj in self.user_global_ns, self.user_ns
+				# Normal (non-embedded) instances should only have a single
+				# namespace for user code execution, otherwise functions won't
+				# see interactive top-level globals.
+				else:
+					exec code_obj in self.user_ns
+			finally:
+				# Reset our crash handler in place
+				sys.excepthook = old_excepthook
+		except SystemExit:
+			self.resetbuffer()
+			self.showtraceback()
+			warn("Type %exit or %quit to exit IPython "
+				 "(%Exit or %Quit do so unconditionally).",level=1)
+		except self.custom_exceptions:
+			etype,value,tb = sys.exc_info()
+			self.CustomTB(etype,value,tb)
+		except:
+			self.showtraceback()
+		else:
+			outflag = 0
+			if softspace(sys.stdout, 0):
+				print
+		# Flush out code object which has been run (and source)
+		self.code_to_run = None
+		return outflag
+		
+	def push(self, line):
+		"""Push a line to the interpreter.
+
+		The line should not have a trailing newline; it may have
+		internal newlines.	The line is appended to a buffer and the
+		interpreter's runsource() method is called with the
+		concatenated contents of the buffer as source.	If this
+		indicates that the command was executed or invalid, the buffer
+		is reset; otherwise, the command is incomplete, and the buffer
+		is left as it was after the line was appended.	The return
+		value is 1 if more input is required, 0 if the line was dealt
+		with in some way (this is the same as runsource()).
+		"""
+
+		# autoindent management should be done here, and not in the
+		# interactive loop, since that one is only seen by keyboard input.	We
+		# need this done correctly even for code run via runlines (which uses
+		# push).
+
+		#print 'push line: <%s>' % line	 # dbg
+		for subline in line.splitlines():
+			self.autoindent_update(subline)
+		self.buffer.append(line)
+		more = self.runsource('\n'.join(self.buffer), self.filename)
+		if not more:
+			self.resetbuffer()
+		return more
+
+	def split_user_input(self, line):
+		# This is really a hold-over to support ipapi and some extensions
+		return prefilter.splitUserInput(line)
+
+	def resetbuffer(self):
+		"""Reset the input buffer."""
+		self.buffer[:] = []
+		
+	def raw_input(self,prompt='',continue_prompt=False):
+		"""Write a prompt and read a line.
+
+		The returned line does not include the trailing newline.
+		When the user enters the EOF key sequence, EOFError is raised.
+
+		Optional inputs:
+
+		  - prompt(''): a string to be printed to prompt the user.
+
+		  - continue_prompt(False): whether this line is the first one or a
+		  continuation in a sequence of inputs.
+		"""
+
+		# Code run by the user may have modified the readline completer state.
+		# We must ensure that our completer is back in place.
+		if self.has_readline:
+			self.set_completer()
+		
+		try:
+			line = raw_input_original(prompt).decode(self.stdin_encoding)
+		except ValueError:
+			warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
+				 " or sys.stdout.close()!\nExiting IPython!")
+			self.exit_now = True
+			return ""
+
+		# Try to be reasonably smart about not re-indenting pasted input more
+		# than necessary.  We do this by trimming out the auto-indent initial
+		# spaces, if the user's actual input started itself with whitespace.
+		#debugx('self.buffer[-1]')
+
+		if self.autoindent:
+			if num_ini_spaces(line) > self.indent_current_nsp:
+				line = line[self.indent_current_nsp:]
+				self.indent_current_nsp = 0
+			
+		# store the unfiltered input before the user has any chance to modify
+		# it.
+		if line.strip():
+			if continue_prompt:
+				self.input_hist_raw[-1] += '%s\n' % line
+				if self.has_readline: # and some config option is set?
+					try:
+						histlen = self.readline.get_current_history_length()
+						newhist = self.input_hist_raw[-1].rstrip()
+						self.readline.remove_history_item(histlen-1)
+						self.readline.replace_history_item(histlen-2,newhist)
+					except AttributeError:
+						pass # re{move,place}_history_item are new in 2.4.				  
+			else:
+				self.input_hist_raw.append('%s\n' % line)				 
+			# only entries starting at first column go to shadow history
+			if line.lstrip() == line:
+				self.shadowhist.add(line.strip())
+		elif not continue_prompt:
+			self.input_hist_raw.append('\n')
+		try:
+			lineout = self.prefilter(line,continue_prompt)
+		except:
+			# blanket except, in case a user-defined prefilter crashes, so it
+			# can't take all of ipython with it.
+			self.showtraceback()
+			return ''
+		else:
+			return lineout
+
+	def _prefilter(self, line, continue_prompt):
+		"""Calls different preprocessors, depending on the form of line."""
+
+		# All handlers *must* return a value, even if it's blank ('').
+
+		# Lines are NOT logged here. Handlers should process the line as
+		# needed, update the cache AND log it (so that the input cache array
+		# stays synced).
+
+		#.....................................................................
+		# Code begins
+
+		#if line.startswith('%crash'): raise RuntimeError,'Crash now!'	# dbg
+
+		# save the line away in case we crash, so the post-mortem handler can
+		# record it
+		self._last_input_line = line
+
+		#print '***line: <%s>' % line # dbg
+
+		if not line:
+			# Return immediately on purely empty lines, so that if the user
+			# previously typed some whitespace that started a continuation
+			# prompt, he can break out of that loop with just an empty line.
+			# This is how the default python prompt works.
+
+			# Only return if the accumulated input buffer was just whitespace!
+			if ''.join(self.buffer).isspace():
+				self.buffer[:] = []
+			return ''
+		
+		line_info = prefilter.LineInfo(line, continue_prompt)
+		
+		# the input history needs to track even empty lines
+		stripped = line.strip()
+		
+		if not stripped:
+			if not continue_prompt:
+				self.outputcache.prompt_count -= 1
+			return self.handle_normal(line_info)
+
+		# print '***cont',continue_prompt  # dbg
+		# special handlers are only allowed for single line statements
+		if continue_prompt and not self.rc.multi_line_specials:
+			return self.handle_normal(line_info)
+
+
+		# See whether any pre-existing handler can take care of it	
+		rewritten = self.hooks.input_prefilter(stripped)
+		if rewritten != stripped: # ok, some prefilter did something
+			rewritten = line_info.pre + rewritten  # add indentation
+			return self.handle_normal(prefilter.LineInfo(rewritten,
+														 continue_prompt))
+			
+		#print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest)	# dbg
+		
+		return prefilter.prefilter(line_info, self)
+
+
+	def _prefilter_dumb(self, line, continue_prompt):
+		"""simple prefilter function, for debugging"""
+		return self.handle_normal(line,continue_prompt)
+
+	
+	def multiline_prefilter(self, line, continue_prompt):
+		""" Run _prefilter for each line of input
+		
+		Covers cases where there are multiple lines in the user entry,
+		which is the case when the user goes back to a multiline history
+		entry and presses enter.
+		
+		"""
+		out = []
+		for l in line.rstrip('\n').split('\n'):
+			out.append(self._prefilter(l, continue_prompt))
+		return '\n'.join(out)
+	
+	# Set the default prefilter() function (this can be user-overridden)
+	prefilter = multiline_prefilter
+
+	def handle_normal(self,line_info):
+		"""Handle normal input lines. Use as a template for handlers."""
+
+		# With autoindent on, we need some way to exit the input loop, and I
+		# don't want to force the user to have to backspace all the way to
+		# clear the line.  The rule will be in this case, that either two
+		# lines of pure whitespace in a row, or a line of pure whitespace but
+		# of a size different to the indent level, will exit the input loop.
+		line = line_info.line
+		continue_prompt = line_info.continue_prompt
+		
+		if (continue_prompt and self.autoindent and line.isspace() and
+			(0 < abs(len(line) - self.indent_current_nsp) <= 2 or
+			 (self.buffer[-1]).isspace() )):
+			line = ''
+
+		self.log(line,line,continue_prompt)
+		return line
+
+	def handle_alias(self,line_info):
+		"""Handle alias input lines. """
+		tgt = self.alias_table[line_info.iFun]
+		# print "=>",tgt #dbg
+		if callable(tgt):
+			if '$' in line_info.line:
+				call_meth = '(_ip, _ip.itpl(%s))'
+			else:
+				call_meth = '(_ip,%s)'
+			line_out = ("%s_sh.%s" + call_meth) % (line_info.preWhitespace,
+										 line_info.iFun, 
+			make_quoted_expr(line_info.line))
+		else:
+			transformed = self.expand_aliases(line_info.iFun,line_info.theRest)
+
+			# pre is needed, because it carries the leading whitespace.	 Otherwise
+			# aliases won't work in indented sections.
+			line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
+											 make_quoted_expr( transformed ))
+		
+		self.log(line_info.line,line_out,line_info.continue_prompt)
+		#print 'line out:',line_out # dbg
+		return line_out
+
+	def handle_shell_escape(self, line_info):
+		"""Execute the line in a shell, empty return value"""
+		#print 'line in :', `line` # dbg
+		line = line_info.line
+		if line.lstrip().startswith('!!'):
+			# rewrite LineInfo's line, iFun and theRest to properly hold the
+			# call to %sx and the actual command to be executed, so
+			# handle_magic can work correctly.	Note that this works even if
+			# the line is indented, so it handles multi_line_specials
+			# properly.
+			new_rest = line.lstrip()[2:]
+			line_info.line = '%ssx %s' % (self.ESC_MAGIC,new_rest)
+			line_info.iFun = 'sx'
+			line_info.theRest = new_rest
+			return self.handle_magic(line_info)
+		else:
+			cmd = line.lstrip().lstrip('!')
+			line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
+											 make_quoted_expr(cmd))
+		# update cache/log and return
+		self.log(line,line_out,line_info.continue_prompt)
+		return line_out
+
+	def handle_magic(self, line_info):
+		"""Execute magic functions."""
+		iFun	= line_info.iFun
+		theRest = line_info.theRest
+		cmd = '%s_ip.magic(%s)' % (line_info.preWhitespace,
+								   make_quoted_expr(iFun + " " + theRest))
+		self.log(line_info.line,cmd,line_info.continue_prompt)
+		#print 'in handle_magic, cmd=<%s>' % cmd  # dbg
+		return cmd
+
+	def handle_auto(self, line_info):
+		"""Hande lines which can be auto-executed, quoting if requested."""
+
+		#print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest)	# dbg
+		line	= line_info.line
+		iFun	= line_info.iFun
+		theRest = line_info.theRest
+		pre		= line_info.pre
+		continue_prompt = line_info.continue_prompt
+		obj = line_info.ofind(self)['obj']
+		
+		# This should only be active for single-line input!
+		if continue_prompt:
+			self.log(line,line,continue_prompt)
+			return line
+
+		force_auto = isinstance(obj, IPython.ipapi.IPyAutocall)
+		auto_rewrite = True
+		
+		if pre == self.ESC_QUOTE:
+			# Auto-quote splitting on whitespace
+			newcmd = '%s("%s")' % (iFun,'", "'.join(theRest.split()) )
+		elif pre == self.ESC_QUOTE2:
+			# Auto-quote whole string
+			newcmd = '%s("%s")' % (iFun,theRest)
+		elif pre == self.ESC_PAREN:
+			newcmd = '%s(%s)' % (iFun,",".join(theRest.split()))
+		else:
+			# Auto-paren.
+			# We only apply it to argument-less calls if the autocall
+			# parameter is set to 2.  We only need to check that autocall is <
+			# 2, since this function isn't called unless it's at least 1.
+			if not theRest and (self.rc.autocall < 2) and not force_auto:
+				newcmd = '%s %s' % (iFun,theRest)
+				auto_rewrite = False
+			else:
+				if not force_auto and theRest.startswith('['):
+					if hasattr(obj,'__getitem__'):
+						# Don't autocall in this case: item access for an object
+						# which is BOTH callable and implements __getitem__.
+						newcmd = '%s %s' % (iFun,theRest)
+						auto_rewrite = False
+					else:
+						# if the object doesn't support [] access, go ahead and
+						# autocall
+						newcmd = '%s(%s)' % (iFun.rstrip(),theRest)
+				elif theRest.endswith(';'):
+					newcmd = '%s(%s);' % (iFun.rstrip(),theRest[:-1])
+				else:
+					newcmd = '%s(%s)' % (iFun.rstrip(), theRest)
+
+		if auto_rewrite:
+			rw = self.outputcache.prompt1.auto_rewrite() + newcmd
+			
+			try:
+				# plain ascii works better w/ pyreadline, on some machines, so
+				# we use it and only print uncolored rewrite if we have unicode
+				rw = str(rw)
+				print >>Term.cout, rw
+			except UnicodeEncodeError:
+				print "-------------->" + newcmd
+			
+		# log what is now valid Python, not the actual user input (without the
+		# final newline)
+		self.log(line,newcmd,continue_prompt)
+		return newcmd
+
+	def handle_help(self, line_info):
+		"""Try to get some help for the object.
+
+		obj? or ?obj   -> basic information.
+		obj?? or ??obj -> more details.
+		"""
+		
+		line = line_info.line
+		# We need to make sure that we don't process lines which would be
+		# otherwise valid python, such as "x=1 # what?"
+		try:
+			codeop.compile_command(line)
+		except SyntaxError:
+			# We should only handle as help stuff which is NOT valid syntax
+			if line[0]==self.ESC_HELP:
+				line = line[1:]
+			elif line[-1]==self.ESC_HELP:
+				line = line[:-1]
+			self.log(line,'#?'+line,line_info.continue_prompt)
+			if line:
+				#print 'line:<%r>' % line  # dbg
+				self.magic_pinfo(line)
+			else:
+				page(self.usage,screen_lines=self.rc.screen_length)
+			return '' # Empty string is needed here!
+		except:
+			# Pass any other exceptions through to the normal handler
+			return self.handle_normal(line_info)
+		else:
+			# If the code compiles ok, we should handle it normally
+			return self.handle_normal(line_info)
+
+	def getapi(self):
+		""" Get an IPApi object for this shell instance
+		
+		Getting an IPApi object is always preferable to accessing the shell
+		directly, but this holds true especially for extensions.
+		
+		It should always be possible to implement an extension with IPApi
+		alone. If not, contact maintainer to request an addition.
+		
+		"""
+		return self.api
+
+	def handle_emacs(self, line_info):
+		"""Handle input lines marked by python-mode."""
+
+		# Currently, nothing is done.  Later more functionality can be added
+		# here if needed.
+
+		# The input cache shouldn't be updated
+		return line_info.line
+	
+
+	def mktempfile(self,data=None):
+		"""Make a new tempfile and return its filename.
+
+		This makes a call to tempfile.mktemp, but it registers the created
+		filename internally so ipython cleans it up at exit time.
+
+		Optional inputs:
+
+		  - data(None): if data is given, it gets written out to the temp file
+		  immediately, and the file is closed again."""
+
+		filename = tempfile.mktemp('.py','ipython_edit_')
+		self.tempfiles.append(filename)
+		
+		if data:
+			tmp_file = open(filename,'w')
+			tmp_file.write(data)
+			tmp_file.close()
+		return filename
+
+	def write(self,data):
+		"""Write a string to the default output"""
+		Term.cout.write(data)
+
+	def write_err(self,data):
+		"""Write a string to the default error output"""
+		Term.cerr.write(data)
+
+	def exit(self):
+		"""Handle interactive exit.
+
+		This method sets the exit_now attribute."""
+
+		if self.rc.confirm_exit:
+			if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
+				self.exit_now = True
+		else:
+			self.exit_now = True
+
+	def safe_execfile(self,fname,*where,**kw):
+		"""A safe version of the builtin execfile().
+
+		This version will never throw an exception, and knows how to handle
+		ipython logs as well.
+
+		:Parameters:
+		  fname : string
+			Name of the file to be executed.
+			
+		  where : tuple
+			One or two namespaces, passed to execfile() as (globals,locals).
+			If only one is given, it is passed as both.
+
+		:Keywords:
+		  islog : boolean (False)
+
+		  quiet : boolean (True)
+
+		  exit_ignore : boolean (False)
+		  """
+
+		def syspath_cleanup():
+			"""Internal cleanup routine for sys.path."""
+			if add_dname:
+				try:
+					sys.path.remove(dname)
+				except ValueError:
+					# For some reason the user has already removed it, ignore.
+					pass
+		
+		fname = os.path.expanduser(fname)
+
+		# Find things also in current directory.  This is needed to mimic the
+		# behavior of running a script from the system command line, where
+		# Python inserts the script's directory into sys.path
+		dname = os.path.dirname(os.path.abspath(fname))
+		add_dname = False
+		if dname not in sys.path:
+			sys.path.insert(0,dname)
+			add_dname = True
+
+		try:
+			xfile = open(fname)
+		except:
+			print >> Term.cerr, \
+				  'Could not open file <%s> for safe execution.' % fname
+			syspath_cleanup()
+			return None
+
+		kw.setdefault('islog',0)
+		kw.setdefault('quiet',1)
+		kw.setdefault('exit_ignore',0)
+		
+		first = xfile.readline()
+		loghead = str(self.loghead_tpl).split('\n',1)[0].strip()
+		xfile.close()
+		# line by line execution
+		if first.startswith(loghead) or kw['islog']:
+			print 'Loading log file <%s> one line at a time...' % fname
+			if kw['quiet']:
+				stdout_save = sys.stdout
+				sys.stdout = StringIO.StringIO()
+			try:
+				globs,locs = where[0:2]
+			except:
+				try:
+					globs = locs = where[0]
+				except:
+					globs = locs = globals()
+			badblocks = []
+
+			# we also need to identify indented blocks of code when replaying
+			# logs and put them together before passing them to an exec
+			# statement. This takes a bit of regexp and look-ahead work in the
+			# file. It's easiest if we swallow the whole thing in memory
+			# first, and manually walk through the lines list moving the
+			# counter ourselves.
+			indent_re = re.compile('\s+\S')
+			xfile = open(fname)
+			filelines = xfile.readlines()
+			xfile.close()
+			nlines = len(filelines)
+			lnum = 0
+			while lnum < nlines:
+				line = filelines[lnum]
+				lnum += 1
+				# don't re-insert logger status info into cache
+				if line.startswith('#log#'):
+					continue
+				else:
+					# build a block of code (maybe a single line) for execution
+					block = line
+					try:
+						next = filelines[lnum] # lnum has already incremented
+					except:
+						next = None
+					while next and indent_re.match(next):
+						block += next
+						lnum += 1
+						try:
+							next = filelines[lnum]
+						except:
+							next = None
+					# now execute the block of one or more lines
+					try:
+						exec block in globs,locs
+					except SystemExit:
+						pass
+					except:
+						badblocks.append(block.rstrip())
+			if kw['quiet']:	 # restore stdout
+				sys.stdout.close()
+				sys.stdout = stdout_save
+			print 'Finished replaying log file <%s>' % fname
+			if badblocks:
+				print >> sys.stderr, ('\nThe following lines/blocks in file '
+									  '<%s> reported errors:' % fname)
+					
+				for badline in badblocks:
+					print >> sys.stderr, badline
+		else:  # regular file execution
+			try:
+				if sys.platform == 'win32' and sys.version_info < (2,5,1):
+					# Work around a bug in Python for Windows.	The bug was
+					# fixed in in Python 2.5 r54159 and 54158, but that's still
+					# SVN Python as of March/07.  For details, see:
+					# http://projects.scipy.org/ipython/ipython/ticket/123
+					try:
+						globs,locs = where[0:2]
+					except:
+						try:
+							globs = locs = where[0]
+						except:
+							globs = locs = globals()
+					exec file(fname) in globs,locs
+				else:
+					execfile(fname,*where)
+			except SyntaxError:
+				self.showsyntaxerror()
+				warn('Failure executing file: <%s>' % fname)
+			except SystemExit,status:
+				# Code that correctly sets the exit status flag to success (0)
+				# shouldn't be bothered with a traceback.  Note that a plain
+				# sys.exit() does NOT set the message to 0 (it's empty) so that
+				# will still get a traceback.  Note that the structure of the
+				# SystemExit exception changed between Python 2.4 and 2.5, so
+				# the checks must be done in a version-dependent way.
+				show = False
+
+				if sys.version_info[:2] > (2,5):
+					if status.message!=0 and not kw['exit_ignore']:
+						show = True
+				else:
+					if status.code and not kw['exit_ignore']:
+						show = True
+				if show:
+					self.showtraceback()
+					warn('Failure executing file: <%s>' % fname)
+			except:
+				self.showtraceback()
+				warn('Failure executing file: <%s>' % fname)
+
+		syspath_cleanup()
 
 #************************* end of file <iplib.py> *****************************

IPython/rlineimpl.py

@@ -28,7 +28,20 b" if sys.platform == 'win32' and have_readline:"
     except AttributeError:
         print "Failed GetOutputFile"
         have_readline = False
-    
+
+# Test to see if libedit is being used instead of GNU readline.
+# Thanks to Boyd Waters for this patch.
+uses_libedit = False
+if sys.platform == 'darwin' and have_readline:
+	import commands
+	(status, result) = commands.getstatusoutput( "otool -L %s | grep libedit" % _rl.__file__ )
+	if status == 0 and len(result) > 0:
+		# we are bound to libedit - new in Leopard
+		_rl.parse_and_bind("bind ^I rl_complete")
+		print "Leopard libedit detected."
+		uses_libedit = True
+
+
 # the clear_history() function was only introduced in Python 2.4 and is
 # actually optional in the readline API, so we must explicitly check for its
 # existence.  Some known platforms actually don't have it.  This thread:

doc/ChangeLog

@@ -1,3 +1,8 b''
[phone]  Brian Granger <[e-mail]>
+
+	* iplib.py, rlineimpl.py: Applied Body Water's patches to get IPython
+	working with OS X 10.5 libedit implementation of readline.
+
 2007-10-24  Ville Vainio  <[e-mail]>
 
 	* iplib.py(user_setup): To route around buggy installations where