ipython.rst: add magic command docs

doc/source/ipython.rst

@@ -2,8 +2,8 b''
    You can adapt this file completely to your liking, but it should at least
    contain the root 'toctree' directive.
 
-Welcome to IPython's documentation!
-===================================
+IPython documentation
+=====================
 
 Contents:
 
@@ -1389,15 +1389,19 b' typing %magic at the prompt, but that will also give you information'
 about magic commands you may have added as part of your personal
 customizations.
 
-::
+.. magic_start
 
-	%Exit: Exit IPython without confirmation.
+**%Exit**::
 
+	Exit IPython without confirmation.
 
-	%Pprint: Toggle pretty printing on/off.
+**%Pprint**::
 
+	Toggle pretty printing on/off.
 
-	%alias: Define an alias for a system command.
+**%alias**::
+
+	Define an alias for a system command.
 
         '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
 
@@ -1405,41 +1409,41 b' customizations.'
         params' (from your underlying operating system).
 
         Aliases have lower precedence than magic functions and Python normal
-	variables, so if 'foo' is both a Python variable and an alias, the alias
-	can not be executed until 'del foo' removes the Python variable.
+        variables, so if 'foo' is both a Python variable and an alias, the
+        alias can not be executed until 'del foo' removes the Python variable.
 
         You can use the %l specifier in an alias definition to represent the
         whole line when the alias is called.  For example:
 
-	In [2]: alias all echo "Input in brackets: <%l>"
-	In [3]: all hello world
+          In [2]: alias all echo "Input in brackets: <%l>"\
+          In [3]: all hello world\
           Input in brackets: <hello world>
 
-	You can also define aliases with parameters using %s specifiers (one per
-	parameter):
+        You can also define aliases with parameters using %s specifiers (one
+        per parameter):
         
-	In [1]: alias parts echo first %s second %s
-	In [2]: %parts A B
-	first A second B
-	In [3]: %parts A
-	Incorrect number of arguments: 2 expected.
+          In [1]: alias parts echo first %s second %s\
+          In [2]: %parts A B\
+          first A second B\
+          In [3]: %parts A\
+          Incorrect number of arguments: 2 expected.\
           parts is an alias to: 'echo first %s second %s'
 
-	Note that %l and %s are mutually exclusive. You can only use one or the
-	other in your aliases.
-	
-	Aliases expand Python variables just like system calls using ! or !! do:
-	all expressions prefixed with '$' get expanded. For details of the
-	semantic rules, see PEP-215: http://www.python.org/peps/pep-0215.html.
-	This is the library used by IPython for variable expansion. If you want
-	to access a true shell variable, an extra $ is necessary to prevent its
-	expansion by IPython:
-	
-	In [6]: alias show echo
-	In [7]: PATH='A Python string'
-	In [8]: show $PATH
-	A Python string
-	In [9]: show $$PATH
+        Note that %l and %s are mutually exclusive.  You can only use one or
+        the other in your aliases.
+
+        Aliases expand Python variables just like system calls using ! or !! 
+        do: all expressions prefixed with '$' get expanded.  For details of
+        the semantic rules, see PEP-215:
+        http://www.python.org/peps/pep-0215.html.  This is the library used by
+        IPython for variable expansion.  If you want to access a true shell
+        variable, an extra $ is necessary to prevent its expansion by IPython:
+
+        In [6]: alias show echo\
+        In [7]: PATH='A Python string'\
+        In [8]: show $PATH\
+        A Python string\
+        In [9]: show $$PATH\
         /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
 
         You can use the alias facility to acess all of $PATH.  See the %rehash
@@ -1448,8 +1452,9 b' customizations.'
 
         If called with no parameters, %alias prints the current alias table.
 
+**%autocall**::
 
-	%autocall: Make functions callable without having to type parentheses.
+	Make functions callable without having to type parentheses.
 
         Usage:
 
@@ -1466,27 +1471,34 b' customizations.'
 
         In this mode, you get:
 
-	In [1]: callable Out[1]: <built-in function callable>
+        In [1]: callable
+        Out[1]: <built-in function callable>
 
-	In [2]: callable 'hello' ---> callable('hello') Out[2]: False
+        In [2]: callable 'hello'
+        ------> callable('hello')
+        Out[2]: False
 
         2 -> Active always.  Even if no arguments are present, the callable
         object is called:
 
-	In [4]: callable ---> callable()
+        In [4]: callable
+        ------> callable()
 
         Note that even with autocall off, you can still use '/' at the start of
-	a line to treat the first argument on the command line as a function and
-	add parentheses to it:
+        a line to treat the first argument on the command line as a function
+        and add parentheses to it:
 
-	In [8]: /str 43 ---> str(43) Out[8]: '43'
+        In [8]: /str 43
+        ------> str(43)
+        Out[8]: '43'
 
+**%autoindent**::
 
-	%autoindent: Toggle autoindent on/off (if available).
+	Toggle autoindent on/off (if available).
 
+**%automagic**::
 
-	%automagic: Make magic functions callable without having to type the
-	initial %.
+	Make magic functions callable without having to type the initial %.
 
         Without argumentsl toggles on/off (when off, you must call it as
         %automagic, of course).  With arguments it sets the value, and you can
@@ -1496,22 +1508,23 b' customizations.'
 
          - off,0,False: to deactivate.
 
-	Note that magic functions have lowest priority, so if there's a variable
-	whose name collides with that of a magic fn, automagic won't work for
-	that function (you get the variable instead). However, if you delete the
-	variable (del var), the previously shadowed magic function becomes
-	visible to automagic again.
+        Note that magic functions have lowest priority, so if there's a
+        variable whose name collides with that of a magic fn, automagic won't
+        work for that function (you get the variable instead). However, if you
+        delete the variable (del var), the previously shadowed magic function
+        becomes visible to automagic again.
 
+**%bg**::
 
-	%bg: Run a job in the background, in a separate thread.
+	Run a job in the background, in a separate thread.
 
         For example,
 
           %bg myfunc(x,y,z=1)
 
         will execute 'myfunc(x,y,z=1)' in a background thread.  As soon as the
-	execution starts, a message will be printed indicating the job number.
-	If your job number is 5, you can use
+        execution starts, a message will be printed indicating the job
+        number.  If your job number is 5, you can use
 
           myvar = jobs.result(5)  or  myvar = jobs[5].result
 
@@ -1519,14 +1532,14 b' customizations.'
 
         IPython has a job manager, accessible via the 'jobs' object.  You can
         type jobs? to get more information about it, and use jobs.<TAB> to see
-	its attributes. All attributes not starting with an underscore are meant
-	for public use.
+        its attributes.  All attributes not starting with an underscore are
+        meant for public use.
 
         In particular, look at the jobs.new() method, which is used to create
-	new jobs. This magic %bg function is just a convenience wrapper around
-	jobs.new(), for expression-based jobs. If you want to create a new job
-	with an explicit function object and arguments, you must call jobs.new()
-	directly.
+        new jobs.  This magic %bg function is just a convenience wrapper
+        around jobs.new(), for expression-based jobs.  If you want to create a
+        new job with an explicit function object and arguments, you must call
+        jobs.new() directly.
 
         The jobs.new docstring also describes in detail several important
         caveats associated with a thread-based model for background job
@@ -1535,35 +1548,40 b' customizations.'
         You can check the status of all jobs with jobs.status().
 
         The jobs variable is set by IPython into the Python builtin namespace.
-	If you ever declare a variable named 'jobs', you will shadow this name.
-	You can either delete your global jobs variable to regain access to the
-	job manager, or make a new name and assign it manually to the manager
-	(stored in IPython's namespace). For example, to assign the job manager
-	to the Jobs name, use:
+        If you ever declare a variable named 'jobs', you will shadow this
+        name.  You can either delete your global jobs variable to regain
+        access to the job manager, or make a new name and assign it manually
+        to the manager (stored in IPython's namespace).  For example, to
+        assign the job manager to the Jobs name, use:
 
           Jobs = __builtins__.jobs
 
+**%bookmark**::
 
-	%bookmark: Manage IPython's bookmark system.
+	Manage IPython's bookmark system.
 
-	%bookmark <name> - set bookmark to current dir %bookmark <name> <dir> -
-	set bookmark to <dir> %bookmark -l - list all bookmarks %bookmark -d
-	<name> - remove bookmark %bookmark -r - remove all bookmarks
+        %bookmark <name>       - set bookmark to current dir
+        %bookmark <name> <dir> - set bookmark to <dir>
+        %bookmark -l           - list all bookmarks
+        %bookmark -d <name>    - remove bookmark
+        %bookmark -r           - remove all bookmarks
 
-	You can later on access a bookmarked folder with: %cd -b <name> or
-	simply '%cd <name>' if there is no directory called <name> AND there is
-	such a bookmark defined.
+        You can later on access a bookmarked folder with:
+          %cd -b <name>
+        or simply '%cd <name>' if there is no directory called <name> AND
+        there is such a bookmark defined.
 
-	Your bookmarks persist through IPython sessions, but they are associated
-	with each profile.
+        Your bookmarks persist through IPython sessions, but they are
+        associated with each profile.
 
+**%cd**::
 
-	%cd: Change the current working directory.
+	Change the current working directory.
 
-	This command automatically maintains an internal list of directories you
-	visit during your IPython session, in the variable _dh. The command
-	%dhist shows this history nicely formatted. You can also do 'cd -<tab>'
-	to see directory history conveniently.
+        This command automatically maintains an internal list of directories
+        you visit during your IPython session, in the variable _dh. The
+        command %dhist shows this history nicely formatted. You can also
+        do 'cd -<tab>' to see directory history conveniently.
 
         Usage:
 
@@ -1573,10 +1591,10 b' customizations.'
 
           cd -<n>: changes to the n-th directory in the directory history.
 
-	cd -b <bookmark_name>: jump to a bookmark set by %bookmark (note: cd
-	<bookmark_name> is enough if there is no directory <bookmark_name>, but
-	a bookmark with the name exists.) 'cd -b <tab>' allows you to
-	tab-complete bookmark names.
+          cd -b <bookmark_name>: jump to a bookmark set by %bookmark
+             (note: cd <bookmark_name> is enough if there is no
+              directory <bookmark_name>, but a bookmark with the name exists.)
+              'cd -b <tab>' allows you to tab-complete bookmark names. 
 
         Options:
 
@@ -1587,30 +1605,41 b' customizations.'
         Note that !cd doesn't work for this purpose because the shell where
         !command runs is immediately discarded after executing 'command'.
 
+**%clear**::
+
+	 Clear various data (e.g. stored history data)
     
-	%color_info: Toggle color_info.
+    %clear out - clear output history
+    %clear in  - clear input history
+    %clear shadow_compress - Compresses shadow history (to speed up ipython)
+    %clear shadow_nuke - permanently erase all entries in shadow history
+    %clear dhist - clear dir history
 
-	The color_info configuration parameter controls whether colors are used
-	for displaying object details (by things like %psource, %pfile or the
-	'?' system). This function toggles this value with each call.
+**%color_info**::
 
-	Note that unless you have a fairly recent pager (less works better than
-	more) in your system, using colored object information displays will not
-	work properly. Test it and see.
+	Toggle color_info.
 
+        The color_info configuration parameter controls whether colors are
+        used for displaying object details (by things like %psource, %pfile or
+        the '?' system). This function toggles this value with each call.
 
-	%colors: Switch color scheme for prompts, info system and exception
-	handlers.
+        Note that unless you have a fairly recent pager (less works better
+        than more) in your system, using colored object information displays
+        will not work properly. Test it and see.
+
+**%colors**::
+
+	Switch color scheme for prompts, info system and exception handlers.
 
         Currently implemented schemes: NoColor, Linux, LightBG.
 
         Color scheme names are not case-sensitive.
 
+**%cpaste**::
 
-	%cpaste: Allows you to paste & execute a pre-formatted code block from
-	clipboard
+	Allows you to paste & execute a pre-formatted code block from clipboard
         
-	You must terminate the block with '-' (two minus-signs) alone on the
+        You must terminate the block with '--' (two minus-signs) alone on the
         line. You can also provide your own sentinel with '%paste -s %%' ('%%' 
         is the new sentinel for this operation)
         
@@ -1625,13 +1654,14 b' customizations.'
         dedenting or executing it.
         
         Do not be alarmed by garbled output on Windows (it's a readline bug). 
-	Just press enter and type - (and press enter again) and the block will
-	be what was just pasted.
+        Just press enter and type -- (and press enter again) and the block 
+        will be what was just pasted.
         
         IPython statements (magics, shell escapes) are not supported (yet).
 
+**%debug**::
 
-	%debug: Activate the interactive debugger in post-mortem mode.
+	Activate the interactive debugger in post-mortem mode.
 
         If an exception has just occurred, this lets you inspect its stack
         frames interactively.  Note that this will always work only on the last
@@ -1639,57 +1669,63 b' customizations.'
         exception that you wish to inspect has fired, because if another one
         occurs, it clobbers the previous one.
 
-	If you want IPython to automatically do this on every exception, see the
-	%pdb magic for more details.
+        If you want IPython to automatically do this on every exception, see
+        the %pdb magic for more details.
 
+**%dhist**::
 
-	%dhist: Print your history of visited directories.
+	Print your history of visited directories.
 
-	%dhist -> print full history
-	%dhist n -> print last n entries only
-	%dhist n1 n2 -> print entries between n1 and n2 (n1 not included)
+        %dhist       -> print full history\
+        %dhist n     -> print last n entries only\
+        %dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\
 
-	This history is automatically maintained by the %cd command, and always
-	available as the global list variable _dh. You can use %cd -<n> to go to
-	directory number <n>.
+        This history is automatically maintained by the %cd command, and
+        always available as the global list variable _dh. You can use %cd -<n>
+        to go to directory number <n>.
         
-	Note that most of time, you should view directory history by entering cd
-	-<TAB>.
+        Note that most of time, you should view directory history by entering
+        cd -<TAB>.
 
+**%dirs**::
 
-	%dirs: Return the current directory stack.
+	Return the current directory stack.
 
+**%doctest_mode**::
 
-	%doctest_mode: Toggle doctest mode on and off.
+	Toggle doctest mode on and off.
 
         This mode allows you to toggle the prompt behavior between normal
         IPython prompts and ones that are as similar to the default IPython
         interpreter as possible.
 
-	It also supports the pasting of code snippets that have leading '»>' and
-	'...' prompts in them. This means that you can paste doctests from files
-	or docstrings (even if they have leading whitespace), and the code will
-	execute correctly. You can then use '%history -tn' to see the translated
-	history without line numbers; this will give you the input after removal
-	of all the leading prompts and whitespace, which can be pasted back into
-	an editor.
+        It also supports the pasting of code snippets that have leading '>>>'
+        and '...' prompts in them.  This means that you can paste doctests from
+        files or docstrings (even if they have leading whitespace), and the
+        code will execute correctly.  You can then use '%history -tn' to see
+        the translated history without line numbers; this will give you the
+        input after removal of all the leading prompts and whitespace, which
+        can be pasted back into an editor.
 
         With these features, you can switch into this mode easily whenever you
-	need to do testing and changes to doctests, without having to leave your
-	existing IPython session.
+        need to do testing and changes to doctests, without having to leave
+        your existing IPython session.
 
+**%ed**::
 
-	%ed: Alias to %edit.
+	Alias to %edit.
 
+**%edit**::
 
-	%edit: Bring up an editor and execute the resulting code.
+	Bring up an editor and execute the resulting code.
 
-	Usage: %edit [options] [args]
+        Usage:
+          %edit [options] [args]
 
         %edit runs IPython's editor hook.  The default version of this hook is
         set to call the __IPYTHON__.rc.editor command.  This is read from your
-	environment variable $EDITOR. If this isn't found, it will default to vi
-	under Linux/Unix and to notepad under Windows. See the end of this
+        environment variable $EDITOR.  If this isn't found, it will default to
+        vi under Linux/Unix and to notepad under Windows.  See the end of this
         docstring for how to change the editor hook.
 
         You can also set the value of this editor via the command line option
@@ -1701,251 +1737,309 b' customizations.'
         your IPython session.
         
         If called without arguments, %edit opens up an empty editor with a
-	temporary file and will execute the contents of this file when you close
-	it (don't forget to save it!).
+        temporary file and will execute the contents of this file when you
+        close it (don't forget to save it!).
+
 
         Options:
 
-	-n <number>: open the editor at a specified line number. By default, the
-	IPython editor hook uses the unix syntax 'editor +N filename', but you
-	can configure this by providing your own modified hook if your favorite
-	editor supports line-number specifications with a different syntax.
+        -n <number>: open the editor at a specified line number.  By default,
+        the IPython editor hook uses the unix syntax 'editor +N filename', but
+        you can configure this by providing your own modified hook if your
+        favorite editor supports line-number specifications with a different
+        syntax.
         
-	-p: this will call the editor with the same data as the previous time it
-	was used, regardless of how long ago (in your current session) it was.
+        -p: this will call the editor with the same data as the previous time
+        it was used, regardless of how long ago (in your current session) it
+        was.
 
         -r: use 'raw' input.  This option only applies to input taken from the
         user's history.  By default, the 'processed' history is used, so that
-	magics are loaded in their transformed version to valid Python. If this
-	option is given, the raw input as typed as the command line is used
-	instead. When you exit the editor, it will be executed by IPython's own
-	processor.
+        magics are loaded in their transformed version to valid Python.  If
+        this option is given, the raw input as typed as the command line is
+        used instead.  When you exit the editor, it will be executed by
+        IPython's own processor.
+        
+        -x: do not execute the edited code immediately upon exit. This is
+        mainly useful if you are editing programs which need to be called with
+        command line arguments, which you can then do using %run.
 
-	-x: do not execute the edited code immediately upon exit. This is mainly
-	useful if you are editing programs which need to be called with command
-	line arguments, which you can then do using %run.
 
         Arguments:
 
         If arguments are given, the following possibilites exist:
 
-	    - The arguments are numbers or pairs of dash-separated numbers (like 1
-	      4-8 9). These are interpreted as lines of previous input to be loaded
-	      into the editor. The syntax is the same of the %macro command.
+        - The arguments are numbers or pairs of colon-separated numbers (like
+        1 4:8 9). These are interpreted as lines of previous input to be
+        loaded into the editor. The syntax is the same of the %macro command.
 
         - If the argument doesn't start with a number, it is evaluated as a
-	      variable and its contents loaded into the editor. You can thus edit any
-	      string which contains python code (including the result of previous edits).
+        variable and its contents loaded into the editor. You can thus edit
+        any string which contains python code (including the result of
+        previous edits).
 
         - If the argument is the name of an object (other than a string),
         IPython will try to locate the file where it was defined and open the
-	      editor at the point where it is defined. You can use '%edit function' to
-	      load an editor exactly at the point where 'function' is defined, edit it
-	      and have the file be executed automatically.
+        editor at the point where it is defined. You can use `%edit function`
+        to load an editor exactly at the point where 'function' is defined,
+        edit it and have the file be executed automatically.
 
         If the object is a macro (see %macro for details), this opens up your
-	specified editor with a temporary file containing the macro's data. Upon
-	exit, the macro is reloaded with the contents of the file.
+        specified editor with a temporary file containing the macro's data.
+        Upon exit, the macro is reloaded with the contents of the file.
 
         Note: opening at an exact line is only supported under Unix, and some
         editors (like kedit and gedit up to Gnome 2.8) do not understand the
         '+NUMBER' parameter necessary for this feature. Good editors like
         (X)Emacs, vi, jed, pico and joe all do.
 
-	If the argument is not found as a variable, IPython will look for a
+        - If the argument is not found as a variable, IPython will look for a
         file with that name (adding .py if necessary) and load it into the
         editor. It will execute its contents with execfile() when you exit,
         loading any code in the file into your interactive namespace.
 
         After executing your code, %edit will return as output the code you
-	typed in the editor (except when it was an existing file). This way you
-	can reload the code in further invocations of %edit as a variable, via
-	_<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of the
-	output.
+        typed in the editor (except when it was an existing file). This way
+        you can reload the code in further invocations of %edit as a variable,
+        via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
+        the output.
 
         Note that %edit is also available through the alias %ed.
 
         This is an example of creating a simple function inside the editor and
-	then modifying it. First, start up the editor::
+        then modifying it. First, start up the editor:
 
-	    In [1]: ed
-	    Editing... done. Executing edited code...
+        In [1]: ed\
+        Editing... done. Executing edited code...\
         Out[1]: 'def foo():\n    print "foo() was defined in an editing session"\n'
 
         We can then call the function foo():
         
-	    In [2]: foo()
+        In [2]: foo()\
         foo() was defined in an editing session
 
         Now we edit foo.  IPython automatically loads the editor with the
         (temporary) file where foo() was previously defined:
         
-	    In [3]: ed foo
+        In [3]: ed foo\
         Editing... done. Executing edited code...
 
         And if we call foo() again we get the modified version:
         
-	    In [4]: foo()
+        In [4]: foo()\
         foo() has now been changed!
 
-	    Here is an example of how to edit a code snippet successive times. First
-	    we call the editor:
+        Here is an example of how to edit a code snippet successive
+        times. First we call the editor:
 
-	    In [8]: ed
-	    Editing... done. Executing edited code...
-	    hello
+        In [8]: ed\
+        Editing... done. Executing edited code...\
+        hello\
         Out[8]: "print 'hello'\n"
 
         Now we call it again with the previous output (stored in _):
 
-	    In [9]: ed _
-	    Editing... done. Executing edited code...
-	    hello world
+        In [9]: ed _\
+        Editing... done. Executing edited code...\
+        hello world\
         Out[9]: "print 'hello world'\n"
 
         Now we call it with the output #8 (stored in _8, also as Out[8]):
 
-	    In [10]: ed _8
-	    Editing... done. Executing edited code...
-	    hello again
+        In [10]: ed _8\
+        Editing... done. Executing edited code...\
+        hello again\
         Out[10]: "print 'hello again'\n"
 
+
         Changing the default editor hook:
 
         If you wish to write your own editor hook, you can put it in a
-	configuration file which you load at startup time. The default hook is
-	defined in the IPython.hooks module, and you can use that as a starting
-	example for further modifications. That file also has general
-	instructions on how to set a new hook for use once you've defined it.
+        configuration file which you load at startup time.  The default hook
+        is defined in the IPython.hooks module, and you can use that as a
+        starting example for further modifications.  That file also has
+        general instructions on how to set a new hook for use once you've
+        defined it.
 
+**%env**::
 
-	%env: List environment variables.
+	List environment variables.
 
+**%exit**::
 
-	%exit: Exit IPython, confirming if configured to do so.
+	Exit IPython, confirming if configured to do so.
 
         You can configure whether IPython asks for confirmation upon exit by
         setting the confirm_exit flag in the ipythonrc file.
 
+**%hist**::
+
+	Alternate name for %history.
+
+**%history**::
+
+	Print input history (_i<n> variables), with most recent last.
+    
+    %history       -> print at most 40 inputs (some may be multi-line)\
+    %history n     -> print at most n inputs\
+    %history n1 n2 -> print inputs between n1 and n2 (n2 not included)\
     
-	%logoff: Temporarily stop logging.
+    Each input's number <n> is shown, and is accessible as the
+    automatically generated variable _i<n>.  Multi-line statements are
+    printed starting at a new line for easy copy/paste.
+    
+
+    Options:
+
+      -n: do NOT print line numbers. This is useful if you want to get a
+      printout of many lines which can be directly pasted into a text
+      editor.
+
+      This feature is only available if numbered prompts are in use.
+
+      -t: (default) print the 'translated' history, as IPython understands it.
+      IPython filters your input and converts it all into valid Python source
+      before executing it (things like magics or aliases are turned into
+      function calls, for example). With this option, you'll see the native
+      history instead of the user-entered version: '%cd /' will be seen as
+      '_ip.magic("%cd /")' instead of '%cd /'.
+      
+      -r: print the 'raw' history, i.e. the actual commands you typed.
+      
+      -g: treat the arg as a pattern to grep for in (full) history.
+      This includes the "shadow history" (almost all commands ever written).
+      Use '%hist -g' to show full shadow history (may be very long).
+      In shadow history, every index nuwber starts with 0.
+
+      -f FILENAME: instead of printing the output to the screen, redirect it to
+       the given file.  The file is always overwritten, though IPython asks for
+       confirmation first if it already exists.
+
+**%logoff**::
+
+	Temporarily stop logging.
 
         You must have previously started logging.
 
+**%logon**::
 
-	%logon: Restart logging.
+	Restart logging.
 
-	This function is for restarting logging which you've temporarily stopped
-	with %logoff. For starting logging for the first time, you must use the
-	%logstart function, which allows you to specify an optional log filename.
+        This function is for restarting logging which you've temporarily
+        stopped with %logoff. For starting logging for the first time, you
+        must use the %logstart function, which allows you to specify an
+        optional log filename.
 
+**%logstart**::
 
-	%logstart: Start logging anywhere in a session.
+	Start logging anywhere in a session.
 
         %logstart [-o|-r|-t] [log_name [log_mode]]
 
-	If no name is given, it defaults to a file named 'ipython_log.py' in
-	your current directory, in 'rotate' mode (see below).
+        If no name is given, it defaults to a file named 'ipython_log.py' in your
+        current directory, in 'rotate' mode (see below).
 
         '%logstart name' saves to file 'name' in 'backup' mode.  It saves your
         history up to that point and then continues logging.
 
-	%logstart takes a second optional parameter: logging mode. This can be
-	one of (note that the modes are given unquoted):
-	append: well, that says it.
-	backup: rename (if exists) to name  and start name.
-	global: single logfile in your home dir, appended to.
-	over : overwrite existing log.
-	rotate: create rotating logs name.1 , name.2 , etc.
+        %logstart takes a second optional parameter: logging mode. This can be one
+        of (note that the modes are given unquoted):\
+          append: well, that says it.\
+          backup: rename (if exists) to name~ and start name.\
+          global: single logfile in your home dir, appended to.\
+          over  : overwrite existing log.\
+          rotate: create rotating logs name.1~, name.2~, etc.
 
         Options:
 
-	-o: log also IPython's output. In this mode, all commands which generate
-	an Out[NN] prompt are recorded to the logfile, right after their
-	corresponding input line. The output lines are always prepended with a
-	'#[Out]# ' marker, so that the log remains valid Python code.
+          -o: log also IPython's output.  In this mode, all commands which
+          generate an Out[NN] prompt are recorded to the logfile, right after
+          their corresponding input line.  The output lines are always
+          prepended with a '#[Out]# ' marker, so that the log remains valid
+          Python code.
 
-	Since this marker is always the same, filtering only the output from a
-	log is very easy, using for example a simple awk call:
+          Since this marker is always the same, filtering only the output from
+          a log is very easy, using for example a simple awk call:
 
-	awk -F'#
-	
-	\begin{displaymath}Out\end{displaymath}
-	
-	# ' 'if($2) print $2' ipython_log.py
+            awk -F'#\[Out\]# ' '{if($2) {print $2}}' ipython_log.py
 
           -r: log 'raw' input.  Normally, IPython's logs contain the processed
-	input, so that user lines are logged in their final form, converted into
-	valid Python. For example, %Exit is logged as '_ip.magic("Exit"). If the
-	-r flag is given, all input is logged exactly as typed, with no
-	transformations applied.
+          input, so that user lines are logged in their final form, converted
+          into valid Python.  For example, %Exit is logged as
+          '_ip.magic("Exit").  If the -r flag is given, all input is logged
+          exactly as typed, with no transformations applied.
 
           -t: put timestamps before each input line logged (these are put in
           comments).
 
+**%logstate**::
 
-	%logstate: Print the status of the logging system.
+	Print the status of the logging system.
 
+**%logstop**::
 
-	%logstop: Fully stop logging and close log file.
+	Fully stop logging and close log file.
 
         In order to start logging again, a new %logstart call needs to be made,
         possibly (though not necessarily) with a new filename, mode and other
         options.
 
+**%lsmagic**::
 
-	%lsmagic: List currently available magic functions.
+	List currently available magic functions.
 
+**%macro**::
 
-	%macro: Define a set of input lines as a macro for future re-execution.
+	Define a set of input lines as a macro for future re-execution.
 
-	Usage:
+        Usage:\
           %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
 
         Options:
         
-	-r: use 'raw' input. By default, the 'processed' history is used, so
-	that magics are loaded in their transformed version to valid Python. If
-	this option is given, the raw input as typed as the command line is used
-	instead.
+          -r: use 'raw' input.  By default, the 'processed' history is used,
+          so that magics are loaded in their transformed version to valid
+          Python.  If this option is given, the raw input as typed as the
+          command line is used instead.
 
-	This will define a global variable called 'name' which is a string made
-	of joining the slices and lines you specify (n1,n2,... numbers above)
-	from your input history into a single string. This variable acts like an
-	automatic function which re-executes those lines as if you had typed
-	them. You just type 'name' at the prompt and the code executes.
+        This will define a global variable called `name` which is a string
+        made of joining the slices and lines you specify (n1,n2,... numbers
+        above) from your input history into a single string. This variable
+        acts like an automatic function which re-executes those lines as if
+        you had typed them. You just type 'name' at the prompt and the code
+        executes.
 
         The notation for indicating number ranges is: n1-n2 means 'use line
-	numbers n1,...n2' (the endpoint is included). That is, '5-7' means using
-	the lines numbered 5,6 and 7.
+        numbers n1,...n2' (the endpoint is included).  That is, '5-7' means
+        using the lines numbered 5,6 and 7.
 
         Note: as a 'hidden' feature, you can also use traditional python slice
         notation, where N:M means numbers N through M-1.
 
         For example, if your history contains (%hist prints it):
         
-	44: x=1
-	45: y=3
-	46: z=x+y
-	47: print x
-	48: a=5
-	49: print 'x',x,'y',y
+          44: x=1\
+          45: y=3\
+          46: z=x+y\
+          47: print x\
+          48: a=5\
+          49: print 'x',x,'y',y\
 
         you can create a macro with lines 44 through 47 (included) and line 49
         called my_macro with:
 
           In [51]: %macro my_macro 44-47 49
 
-	Now, typing 'my_macro' (without quotes) will re-execute all this code in
-	one pass.
+        Now, typing `my_macro` (without quotes) will re-execute all this code
+        in one pass.
 
         You don't need to give the line-numbers in order, and any given line
-	number can appear multiple times. You can assemble macros with any lines
-	from your input history in any order.
+        number can appear multiple times. You can assemble macros with any
+        lines from your input history in any order.
 
-	The macro is a simple object which holds its value in an attribute, but
-	IPython's display system checks for macros and executes them as code
-	instead of printing them when you type their name.
+        The macro is a simple object which holds its value in an attribute,
+        but IPython's display system checks for macros and executes them as
+        code instead of printing them when you type their name.
 
         You can view a macro's contents by explicitly printing it with:
         
@@ -1957,11 +2051,45 b' customizations.'
 
           In [60]: exec In[44:48]+In[49]
 
-	
-	%magic: Print information about the magic function system.
-	
-	
-	%page: Pretty print the object and display it through a pager.
+**%magic**::
+
+	Print information about the magic function system.
+
+**%mglob**::
+
+	    This program allows specifying filenames with "mglob" mechanism.
+    Supported syntax in globs (wilcard matching patterns)::
+    
+     *.cpp ?ellowo*                
+         - obvious. Differs from normal glob in that dirs are not included.
+           Unix users might want to write this as: "*.cpp" "?ellowo*"
+     rec:/usr/share=*.txt,*.doc    
+         - get all *.txt and *.doc under /usr/share, 
+           recursively
+     rec:/usr/share
+         - All files under /usr/share, recursively
+     rec:*.py
+         - All .py files under current working dir, recursively
+     foo                           
+         - File or dir foo
+     !*.bak readme*                   
+         - readme*, exclude files ending with .bak
+     !.svn/ !.hg/ !*_Data/ rec:.
+         - Skip .svn, .hg, foo_Data dirs (and their subdirs) in recurse.
+           Trailing / is the key, \ does not work!
+     dir:foo                       
+         - the directory foo if it exists (not files in foo)
+     dir:*                         
+         - all directories in current folder
+     foo.py bar.* !h* rec:*.py
+         - Obvious. !h* exclusion only applies for rec:*.py.
+           foo.py is *not* included twice.
+     @filelist.txt
+         - All files listed in 'filelist.txt' file, on separate lines.
+
+**%page**::
+
+	Pretty print the object and display it through a pager.
         
         %page [options] OBJECT
 
@@ -1971,67 +2099,76 b' customizations.'
 
           -r: page str(object), don't pretty-print it.
 
+**%pdb**::
 
-	%pdb: Control the automatic calling of the pdb interactive debugger.
+	Control the automatic calling of the pdb interactive debugger.
 
         Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
         argument it works as a toggle.
 
         When an exception is triggered, IPython can optionally call the
-	interactive pdb debugger after the traceback printout. %pdb toggles this
-	feature on and off.
+        interactive pdb debugger after the traceback printout. %pdb toggles
+        this feature on and off.
 
-	The initial state of this feature is set in your ipythonrc configuration
-	file (the variable is called 'pdb').
+        The initial state of this feature is set in your ipythonrc
+        configuration file (the variable is called 'pdb').
 
         If you want to just activate the debugger AFTER an exception has fired,
         without having to type '%pdb on' and rerunning your code, you can use
         the %debug magic.
 
+**%pdef**::
 
-	%pdef: Print the definition header for any callable object.
+	Print the definition header for any callable object.
 
         If the object is a class, print the constructor information.
 
+**%pdoc**::
 
-	%pdoc: Print the docstring for an object.
+	Print the docstring for an object.
 
         If the given object is a class, it will print both the class and the
         constructor docstrings.
 
+**%pfile**::
 
-	%pfile: Print (or run through pager) the file where an object is defined.
+	Print (or run through pager) the file where an object is defined.
 
         The file opens at the line where the object definition begins. IPython
-	will honor the environment variable PAGER if set, and otherwise will do
-	its best to print the file in a convenient form.
+        will honor the environment variable PAGER if set, and otherwise will
+        do its best to print the file in a convenient form.
 
         If the given argument is not an object currently defined, IPython will
         try to interpret it as a filename (automatically adding a .py extension
-	if needed). You can thus use %pfile as a syntax highlighting code viewer.
+        if needed). You can thus use %pfile as a syntax highlighting code
+        viewer.
 
+**%pinfo**::
 
-	%pinfo: Provide detailed information about an object.
+	Provide detailed information about an object.
     
         '%pinfo object' is just a synonym for object? or ?object.
 
+**%popd**::
 
-	%popd: Change to directory popped off the top of the stack.
+	Change to directory popped off the top of the stack.
 
+**%profile**::
 
-	%profile: Print your currently active IPyhton profile.
+	Print your currently active IPyhton profile.
 
+**%prun**::
 
-	%prun: Run a statement through the python code profiler.
+	Run a statement through the python code profiler.
 
-	Usage:
+        Usage:\
           %prun [options] statement
 
         The given statement (which doesn't require quote marks) is run via the
         python profiler in a manner similar to the profile.run() function.
-	Namespaces are internally managed to work correctly; profile.run cannot
-	be used in IPython because it makes certain assumptions about namespaces
-	which do not hold under IPython.
+        Namespaces are internally managed to work correctly; profile.run
+        cannot be used in IPython because it makes certain assumptions about
+        namespaces which do not hold under IPython.
 
         Options:
 
@@ -2043,8 +2180,8 b' customizations.'
 
           * An integer: only these many lines are printed.
 
-	 * A float (between 0 and 1): this fraction of the report is printed (for
-	  example, use a limit of 0.4 to see the topmost 40% only).
+          * A float (between 0 and 1): this fraction of the report is printed
+          (for example, use a limit of 0.4 to see the topmost 40% only).
 
         You can combine several limits with repeated use of the option. For
         example, '-l __init__ -l 5' will print only the topmost 5 lines of
@@ -2065,108 +2202,118 b' customizations.'
         secondary criteria when the there is equality in all keys selected
         before them.
         
-	Abbreviations can be used for any key names, as long as the abbreviation
-	is unambiguous. The following are the keys currently defined:
-	
-	Valid Arg Meaning
-	"calls" call count
-	"cumulative" cumulative time
-	"file" file name
-	"module" file name
-	"pcalls" primitive call count
-	"line" line number
-	"name" function name
-	"nfl" name/file/line
-	"stdname" standard name
+        Abbreviations can be used for any key names, as long as the
+        abbreviation is unambiguous.  The following are the keys currently
+        defined:
+
+                Valid Arg       Meaning\
+                  "calls"      call count\
+                  "cumulative" cumulative time\
+                  "file"       file name\
+                  "module"     file name\
+                  "pcalls"     primitive call count\
+                  "line"       line number\
+                  "name"       function name\
+                  "nfl"        name/file/line\
+                  "stdname"    standard name\
                   "time"       internal time
 
-	Note that all sorts on statistics are in descending order (placing most
-	time consuming items first), where as name, file, and line number
+        Note that all sorts on statistics are in descending order (placing
+        most time consuming items first), where as name, file, and line number
         searches are in ascending order (i.e., alphabetical). The subtle
         distinction between "nfl" and "stdname" is that the standard name is a
-	sort of the name as printed, which means that the embedded line numbers
-	get compared in an odd way. For example, lines 3, 20, and 40 would (if
-	the file names were the same) appear in the string order "20" "3" and
-	"40". In contrast, "nfl" does a numeric compare of the line numbers. In
-	fact, sort_stats("nfl") is the same as sort_stats("name", "file", "line").
+        sort of the name as printed, which means that the embedded line
+        numbers get compared in an odd way.  For example, lines 3, 20, and 40
+        would (if the file names were the same) appear in the string order
+        "20" "3" and "40".  In contrast, "nfl" does a numeric compare of the
+        line numbers.  In fact, sort_stats("nfl") is the same as
+        sort_stats("name", "file", "line").
 
-	-T <filename>: save profile results as shown on screen to a text file.
-	The profile is still shown on screen.
+        -T <filename>: save profile results as shown on screen to a text
+        file. The profile is still shown on screen.
 
         -D <filename>: save (via dump_stats) profile statistics to given
         filename. This data is in a format understod by the pstats module, and
-	is generated by a call to the dump_stats() method of profile objects.
-	The profile is still shown on screen.
+        is generated by a call to the dump_stats() method of profile
+        objects. The profile is still shown on screen.
 
         If you want to run complete programs under the profiler's control, use
         '%run -p [prof_opts] filename.py [args to program]' where prof_opts
         contains profiler specific options as described here.
         
-	You can read the complete documentation for the profile module with:
+        You can read the complete documentation for the profile module with:\
           In [1]: import profile; profile.help()
 
+**%psearch**::
 
-	%psearch: Search for object in namespaces by wildcard.
+	Search for object in namespaces by wildcard.
 
         %psearch [options] PATTERN [OBJECT TYPE]
 
         Note: ? can be used as a synonym for %psearch, at the beginning or at
         the end: both a*? and ?a* are equivalent to '%psearch a*'.  Still, the
-	rest of the command line must be unchanged (options come first), so for
-	example the following forms are equivalent
+        rest of the command line must be unchanged (options come first), so
+        for example the following forms are equivalent
 
-	%psearch -i a* function -i a* function? ?-i a* function
+        %psearch -i a* function
+        -i a* function?
+        ?-i a* function
 
         Arguments:
         
           PATTERN
 
-	where PATTERN is a string containing * as a wildcard similar to its use
-	in a shell. The pattern is matched in all namespaces on the search path.
-	By default objects starting with a single _ are not matched, many
-	IPython generated objects have a single underscore. The default is case
-	insensitive matching. Matching is also done on the attributes of objects
-	and not only on the objects in a module.
+          where PATTERN is a string containing * as a wildcard similar to its
+          use in a shell.  The pattern is matched in all namespaces on the
+          search path. By default objects starting with a single _ are not
+          matched, many IPython generated objects have a single
+          underscore. The default is case insensitive matching. Matching is
+          also done on the attributes of objects and not only on the objects
+          in a module.
 
           [OBJECT TYPE]
 
-	Is the name of a python type from the types module. The name is given in
-	lowercase without the ending type, ex. StringType is written string. By
-	adding a type here only objects matching the given type are matched.
-	Using all here makes the pattern match all types (this is the default).
+          Is the name of a python type from the types module. The name is
+          given in lowercase without the ending type, ex. StringType is
+          written string. By adding a type here only objects matching the
+          given type are matched. Using all here makes the pattern match all
+          types (this is the default).
 
         Options:
 
-	-a: makes the pattern match even objects whose names start with a single
-	underscore. These names are normally ommitted from the search.
+          -a: makes the pattern match even objects whose names start with a
+          single underscore.  These names are normally ommitted from the
+          search.
 
-	-i/-c: make the pattern case insensitive/sensitive. If neither of these
-	options is given, the default is read from your ipythonrc file. The
-	option name which sets this value is 'wildcards_case_sensitive'. If this
-	option is not specified in your ipythonrc file, IPython's internal
-	default is to do a case sensitive search.
+          -i/-c: make the pattern case insensitive/sensitive.  If neither of
+          these options is given, the default is read from your ipythonrc
+          file.  The option name which sets this value is
+          'wildcards_case_sensitive'.  If this option is not specified in your
+          ipythonrc file, IPython's internal default is to do a case sensitive
+          search.
 
           -e/-s NAMESPACE: exclude/search a given namespace.  The pattern you
-	specifiy can be searched in any of the following namespaces: 'builtin',
-	'user', 'user_global','internal', 'alias', where 'builtin' and 'user'
-	are the search defaults. Note that you should not use quotes when
-	specifying namespaces.
-	
-	'Builtin' contains the python module builtin, 'user' contains all user
-	data, 'alias' only contain the shell aliases and no python objects,
-	'internal' contains objects used by IPython. The 'user_global' namespace
-	is only used by embedded IPython instances, and it contains module-level
-	globals. You can add namespaces to the search with -s or exclude them
-	with -e (these options can be given more than once).
+          specifiy can be searched in any of the following namespaces:
+          'builtin', 'user', 'user_global','internal', 'alias', where
+          'builtin' and 'user' are the search defaults.  Note that you should
+          not use quotes when specifying namespaces.
+
+          'Builtin' contains the python module builtin, 'user' contains all
+          user data, 'alias' only contain the shell aliases and no python
+          objects, 'internal' contains objects used by IPython.  The
+          'user_global' namespace is only used by embedded IPython instances,
+          and it contains module-level globals.  You can add namespaces to the
+          search with -s or exclude them with -e (these options can be given
+          more than once).
     
         Examples:
        
-	%psearch a* -> objects beginning with an a %psearch -e builtin a* ->
-	objects NOT in the builtin space starting in a %psearch a* function ->
-	all functions beginning with an a %psearch re.e* -> objects beginning
-	with an e in module re %psearch r*.e* -> objects that start with e in
-	modules starting in r %psearch r*.* string -> all strings in modules
-	beginning with r
+        %psearch a*            -> objects beginning with an a
+        %psearch -e builtin a* -> objects NOT in the builtin space starting in a
+        %psearch a* function   -> all functions beginning with an a
+        %psearch re.e*         -> objects beginning with an e in module re
+        %psearch r*.e*         -> objects that start with e in modules starting in r
+        %psearch r*.* string   -> all strings in modules beginning with r
 
         Case sensitve search:
        
@@ -2176,82 +2323,136 b' customizations.'
        
         %psearch -a _*         list objects beginning with a single underscore
 
+**%psource**::
 
-	%psource: Print (or run through pager) the source code for an object.
+	Print (or run through pager) the source code for an object.
 
+**%pushd**::
 
-	%pushd: Place the current dir on stack and change directory.
+	Place the current dir on stack and change directory.
         
-	Usage:
+        Usage:\
           %pushd ['dirname']
 
+**%pwd**::
 
-	%pwd: Return the current working directory path.
+	Return the current working directory path.
 
+**%pycat**::
 
-	%pycat: Show a syntax-highlighted file through a pager.
+	Show a syntax-highlighted file through a pager.
 
-	This magic is similar to the cat utility, but it will assume the file to
-	be Python source and will show it with syntax highlighting.
+        This magic is similar to the cat utility, but it will assume the file
+        to be Python source and will show it with syntax highlighting.
 
+**%quickref**::
 
-	%quickref: Show a quick reference sheet
+	 Show a quick reference sheet
 
+**%quit**::
 
-	%quit: Exit IPython, confirming if configured to do so (like %exit)
+	Exit IPython, confirming if configured to do so (like %exit)
 
+**%r**::
 
-	%r: Repeat previous input.
+	Repeat previous input.
 
         Note: Consider using the more powerfull %rep instead!
         
-	If given an argument, repeats the previous command which starts with the
-	same string, otherwise it just repeats the previous input.
+        If given an argument, repeats the previous command which starts with
+        the same string, otherwise it just repeats the previous input.
+
+        Shell escaped commands (with ! as first character) are not recognized
+        by this system, only pure python code and magic commands.
 
-	Shell escaped commands (with ! as first character) are not recognized by
-	this system, only pure python code and magic commands.
+**%rehashdir**::
 
+	 Add executables in all specified dirs to alias table
      
-	%rehashx: Update the alias table with all executable files in $PATH.
+    Usage:
 
-	This version explicitly checks that every entry in $PATH is a file with
-	execute access (os.X_OK), so it is much slower than %rehash.
+    %rehashdir c:/bin;c:/tools
+      - Add all executables under c:/bin and c:/tools to alias table, in 
+      order to make them directly executable from any directory.
         
-	Under Windows, it checks executability as a match agains a ``|``-separated
-	string of extensions, stored in the IPython config variable
-	win_exec_ext. This defaults to ``exe|com|bat``.
+      Without arguments, add all executables in current directory.
+
+**%rehashx**::
+
+	Update the alias table with all executable files in $PATH.
+
+        This version explicitly checks that every entry in $PATH is a file
+        with execute access (os.X_OK), so it is much slower than %rehash.
+
+        Under Windows, it checks executability as a match agains a
+        '|'-separated string of extensions, stored in the IPython config
+        variable win_exec_ext.  This defaults to 'exe|com|bat'.
         
         This function also resets the root module cache of module completer,
         used on slow filesystems.
 
+**%rep**::
+
+	 Repeat a command, or get command to input line for editing
+
+    - %rep (no arguments):
+    
+    Place a string version of last computation result (stored in the special '_'
+    variable) to the next input prompt. Allows you to create elaborate command
+    lines without using copy-paste::
+    
+        $ l = ["hei", "vaan"]       
+        $ "".join(l)        
+        ==> heivaan        
+        $ %rep        
+        $ heivaan_ <== cursor blinking    
+    
+    %rep 45
+    
+    Place history line 45 to next input prompt. Use %hist to find out the
+    number.
+    
+    %rep 1-4 6-7 3
+    
+    Repeat the specified lines immediately. Input slice syntax is the same as
+    in %macro and %save.
+    
+    %rep foo
     
-	%reset: Resets the namespace by removing all names defined by the user.
+    Place the most recent line that has the substring "foo" to next input.
+    (e.g. 'svn ci -m foobar').
+
+**%reset**::
+
+	Resets the namespace by removing all names defined by the user.
 
         Input/Output history are left around in case you need them.
 
+**%run**::
 
-	%run: Run the named file inside IPython as a program.
+	Run the named file inside IPython as a program.
 
-	Usage:
+        Usage:\
           %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
         
         Parameters after the filename are passed as command-line arguments to
-	the program (put in sys.argv). Then, control returns to IPython's prompt.
+        the program (put in sys.argv). Then, control returns to IPython's
+        prompt.
 
-	This is similar to running at a system prompt:
-	$ python file args
+        This is similar to running at a system prompt:\
+          $ python file args\
         but with the advantage of giving you IPython's tracebacks, and of
         loading all variables into your interactive namespace for further use
         (unless -p is used, see below).
 
         The file is executed in a namespace initially consisting only of
-	__name__=='__main__' and sys.argv constructed as indicated. It thus sees
-	its environment as if it were being run as a stand-alone program (except
-	for sharing global objects such as previously imported modules). But
-	after execution, the IPython interactive namespace gets updated with all
-	variables defined in the program (except for __name__ and sys.argv).
-	This allows for very convenient loading of code for interactive work,
-	while giving each program a 'clean sheet' to run in.
+        __name__=='__main__' and sys.argv constructed as indicated. It thus
+        sees its environment as if it were being run as a stand-alone program
+        (except for sharing global objects such as previously imported
+        modules). But after execution, the IPython interactive namespace gets
+        updated with all variables defined in the program (except for __name__
+        and sys.argv). This allows for very convenient loading of code for
+        interactive work, while giving each program a 'clean sheet' to run in.
 
         Options:
         
@@ -2260,45 +2461,45 b' customizations.'
         scripts and reloading the definitions in them without calling code
         protected by an ' if __name__ == "__main__" ' clause.
 
-	-i: run the file in IPython's namespace instead of an empty one. This is
-	useful if you are experimenting with code written in a text editor which
-	depends on variables defined interactively.
+        -i: run the file in IPython's namespace instead of an empty one. This
+        is useful if you are experimenting with code written in a text editor
+        which depends on variables defined interactively.
 
-	-e: ignore sys.exit() calls or SystemExit exceptions in the script being
-	run. This is particularly useful if IPython is being used to run
-	unittests, which always exit with a sys.exit() call. In such cases you
-	are interested in the output of the test results, not in seeing a
-	traceback of the unittest module.
+        -e: ignore sys.exit() calls or SystemExit exceptions in the script
+        being run.  This is particularly useful if IPython is being used to
+        run unittests, which always exit with a sys.exit() call.  In such
+        cases you are interested in the output of the test results, not in
+        seeing a traceback of the unittest module.
 
         -t: print timing information at the end of the run.  IPython will give
-	you an estimated CPU time consumption for your script, which under Unix
-	uses the resource module to avoid the wraparound problems of
-	time.clock(). Under Unix, an estimate of time spent on system tasks is
-	also given (for Windows platforms this is reported as 0.0).
+        you an estimated CPU time consumption for your script, which under
+        Unix uses the resource module to avoid the wraparound problems of
+        time.clock().  Under Unix, an estimate of time spent on system tasks
+        is also given (for Windows platforms this is reported as 0.0).
 
-	If -t is given, an additional -N<N> option can be given, where <N> must
-	be an integer indicating how many times you want the script to run. The
-	final timing report will include total and per run results.
+        If -t is given, an additional -N<N> option can be given, where <N>
+        must be an integer indicating how many times you want the script to
+        run.  The final timing report will include total and per run results.
 
         For example (testing the script uniq_stable.py):
 
             In [1]: run -t uniq_stable
 
-	IPython CPU timings (estimated):
-	User : 0.19597 s.
-	System: 0.0 s.
+            IPython CPU timings (estimated):\
+              User  :    0.19597 s.\
+              System:        0.0 s.\
 
             In [2]: run -t -N5 uniq_stable
 
-	IPython CPU timings (estimated):
-	Total runs performed: 5
-	Times : Total Per run
-	User : 0.910862 s, 0.1821724 s.
+            IPython CPU timings (estimated):\
+            Total runs performed: 5\
+              Times :      Total       Per run\
+              User  :   0.910862 s,  0.1821724 s.\
               System:        0.0 s,        0.0 s.
 
-	-d: run your program under the control of pdb, the Python debugger. This
-	allows you to execute your program step by step, watch variables, etc.
-	Internally, what IPython does is similar to calling:
+        -d: run your program under the control of pdb, the Python debugger.
+        This allows you to execute your program step by step, watch variables,
+        etc.  Internally, what IPython does is similar to calling:
         
           pdb.run('execfile("YOURFILENAME")')
 
@@ -2308,17 +2509,17 b' customizations.'
 
           %run -d -b40 myscript
 
-	will set the first breakpoint at line 40 in myscript.py. Note that the
-	first breakpoint must be set on a line which actually does something
-	(not a comment or docstring) for it to stop execution.
+        will set the first breakpoint at line 40 in myscript.py.  Note that
+        the first breakpoint must be set on a line which actually does
+        something (not a comment or docstring) for it to stop execution.
 
         When the pdb debugger starts, you will see a (Pdb) prompt.  You must
         first enter 'c' (without qoutes) to start execution up to the first
         breakpoint.
 
-	Entering 'help' gives information about the use of the debugger. You can
-	easily see pdb's full documentation with "import pdb;pdb.help()" at a
-	prompt.
+        Entering 'help' gives information about the use of the debugger.  You
+        can easily see pdb's full documentation with "import pdb;pdb.help()"
+        at a prompt.
 
         -p: run program under the control of the Python profiler module (which
         prints a detailed report of execution times, function calls, etc).
@@ -2333,37 +2534,39 b' customizations.'
         Internally this triggers a call to %prun, see its documentation for
         details on the options available specifically for profiling.
 
-	There is one special usage for which the text above doesn't apply: if
-	the filename ends with .ipy, the file is run as ipython script, just as
-	if the commands were written on IPython prompt.
+        There is one special usage for which the text above doesn't apply:
+        if the filename ends with .ipy, the file is run as ipython script,
+        just as if the commands were written on IPython prompt.
 
+**%runlog**::
 
-	%runlog: Run files as logs.
+	Run files as logs.
 
-	Usage:
+        Usage:\
           %runlog file1 file2 ...
 
-	Run the named files (treating them as log files) in sequence inside the
-	interpreter, and return to the prompt. This is much slower than %run
-	because each line is executed in a try/except block, but it allows
-	running files with syntax errors in them.
+        Run the named files (treating them as log files) in sequence inside
+        the interpreter, and return to the prompt.  This is much slower than
+        %run because each line is executed in a try/except block, but it
+        allows running files with syntax errors in them.
 
         Normally IPython will guess when a file is one of its own logfiles, so
         you can typically use %run even for logs. This shorthand allows you to
         force any file to be treated as a log file.
 
+**%save**::
 
-	%save: Save a set of lines to a given filename.
+	Save a set of lines to a given filename.
 
-	Usage:
+        Usage:\
           %save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...
 
         Options:
         
-	-r: use 'raw' input. By default, the 'processed' history is used, so
-	that magics are loaded in their transformed version to valid Python. If
-	this option is given, the raw input as typed as the command line is used
-	instead.
+          -r: use 'raw' input.  By default, the 'processed' history is used,
+          so that magics are loaded in their transformed version to valid
+          Python.  If this option is given, the raw input as typed as the
+          command line is used instead.
 
         This function uses the same syntax as %macro for line extraction, but
         instead of creating a macro it saves the resulting string to the
@@ -2372,25 +2575,28 b' customizations.'
         It adds a '.py' extension to the file if you don't do so yourself, and
         it asks for confirmation before overwriting existing files.
 
+**%sc**::
 
-	%sc: Shell capture - execute a shell command and capture its output.
+	Shell capture - execute a shell command and capture its output.
 
         DEPRECATED. Suboptimal, retained for backwards compatibility.
         
         You should use the form 'var = !command' instead. Example:
          
-	"%sc -l myfiles = ls " should now be written as
+         "%sc -l myfiles = ls ~" should now be written as
             
-	"myfiles = !ls "
+         "myfiles = !ls ~"
          
-	myfiles.s, myfiles.l and myfiles.n still apply as documented below.
+        myfiles.s, myfiles.l and myfiles.n still apply as documented
+        below.
 
-	- %sc [options] varname=command
+        --
+        %sc [options] varname=command
 
-	IPython will run the given command using commands.getoutput(), and will
-	then update the user's interactive namespace with a variable called
-	varname, containing the value of the call. Your command can contain
-	shell wildcards, pipes, etc.
+        IPython will run the given command using commands.getoutput(), and
+        will then update the user's interactive namespace with a variable
+        called varname, containing the value of the call.  Your command can
+        contain shell wildcards, pipes, etc.
 
         The '=' sign in the syntax is mandatory, and the variable name you
         supply must follow Python's standard conventions for valid names.
@@ -2400,133 +2606,202 b' customizations.'
         Options:
 
           -l: list output.  Split the output on newlines into a list before
-	assigning it to the given variable. By default the output is stored as a
-	single string.
+          assigning it to the given variable.  By default the output is stored
+          as a single string.
 
           -v: verbose.  Print the contents of the variable.
 
         In most cases you should not need to split as a list, because the
         returned value is a special type of string which can automatically
         provide its contents either as a list (split on newlines) or as a
-	space-separated string. These are convenient, respectively, either for
-	sequential processing or to be passed to a shell command.
+        space-separated string.  These are convenient, respectively, either
+        for sequential processing or to be passed to a shell command.
 
         For example:
 
-	# Capture into variable a In [9]: sc a=ls *py
+            # Capture into variable a
+            In [9]: sc a=ls *py
 
-	# a is a string with embedded newlines In [10]: a Out[10]: 'setup.py
-	win32_manual_post_install.py'
+            # a is a string with embedded newlines
+            In [10]: a
+            Out[10]: 'setup.py win32_manual_post_install.py'
 
-	# which can be seen as a list: In [11]: a.l Out[11]: ['setup.py',
-	'win32_manual_post_install.py']
+            # which can be seen as a list:
+            In [11]: a.l
+            Out[11]: ['setup.py', 'win32_manual_post_install.py']
 
-	# or as a whitespace-separated string: In [12]: a.s Out[12]: 'setup.py
-	win32_manual_post_install.py'
+            # or as a whitespace-separated string:
+            In [12]: a.s
+            Out[12]: 'setup.py win32_manual_post_install.py'
 
-	# a.s is useful to pass as a single command line: In [13]: !wc -l $a.s
-	146 setup.py 130 win32_manual_post_install.py 276 total
+            # a.s is useful to pass as a single command line:
+            In [13]: !wc -l $a.s
+              146 setup.py
+              130 win32_manual_post_install.py
+              276 total
 
-	# while the list form is useful to loop over: In [14]: for f in a.l:
-	....: !wc -l $f ....: 146 setup.py 130 win32_manual_post_install.py
+            # while the list form is useful to loop over:
+            In [14]: for f in a.l:
+               ....:      !wc -l $f
+               ....:
+            146 setup.py
+            130 win32_manual_post_install.py
 
-	Similiarly, the lists returned by the -l option are also special, in the
-	sense that you can equally invoke the .s attribute on them to
+        Similiarly, the lists returned by the -l option are also special, in
+        the sense that you can equally invoke the .s attribute on them to
         automatically get a whitespace-separated string from their contents:
 
             In [1]: sc -l b=ls *py
 
-	In [2]: b Out[2]: ['setup.py', 'win32_manual_post_install.py']
+            In [2]: b
+            Out[2]: ['setup.py', 'win32_manual_post_install.py']
+
+            In [3]: b.s
+            Out[3]: 'setup.py win32_manual_post_install.py'
+
+        In summary, both the lists and strings used for ouptut capture have
+        the following special attributes:
+
+            .l (or .list) : value as list.
+            .n (or .nlstr): value as newline-separated string.
+            .s (or .spstr): value as space-separated string.
 
-	In [3]: b.s Out[3]: 'setup.py win32_manual_post_install.py'
+**%store**::
 
-	In summary, both the lists and strings used for ouptut capture have the
-	following special attributes:
+	Lightweight persistence for python variables.
 
-	.l (or .list) : value as list. .n (or .nlstr): value as
-	newline-separated string. .s (or .spstr): value as space-separated string.
+    Example:
     
+    ville@badger[~]|1> A = ['hello',10,'world']\
+    ville@badger[~]|2> %store A\
+    ville@badger[~]|3> Exit
     
-	%sx: Shell execute - run a shell command and capture its output.
+    (IPython session is closed and started again...)
+    
+    ville@badger:~$ ipython -p pysh\
+    ville@badger[~]|1> print A
+    
+    ['hello', 10, 'world']
+    
+    Usage:
+    
+    %store          - Show list of all variables and their current values\
+    %store <var>    - Store the *current* value of the variable to disk\
+    %store -d <var> - Remove the variable and its value from storage\
+    %store -z       - Remove all variables from storage\
+    %store -r       - Refresh all variables from store (delete current vals)\
+    %store foo >a.txt  - Store value of foo to new file a.txt\
+    %store foo >>a.txt - Append value of foo to file a.txt\   
+    
+    It should be noted that if you change the value of a variable, you
+    need to %store it again if you want to persist the new value.
+    
+    Note also that the variables will need to be pickleable; most basic
+    python types can be safely %stored.
+    
+    Also aliases can be %store'd across sessions.
+
+**%sx**::
+
+	Shell execute - run a shell command and capture its output.
 
         %sx command
 
         IPython will run the given command using commands.getoutput(), and
-	return the result formatted as a list (split on '\n'). Since the output
-	is _returned_, it will be stored in ipython's regular output cache
-	Out[N] and in the '_N' automatic variables.
+        return the result formatted as a list (split on '\n').  Since the
+        output is _returned_, it will be stored in ipython's regular output
+        cache Out[N] and in the '_N' automatic variables.
 
         Notes:
 
-	1) If an input line begins with '!!', then %sx is automatically invoked.
-	That is, while: !ls causes ipython to simply issue system('ls'), typing
-	!!ls is a shorthand equivalent to: %sx ls
+        1) If an input line begins with '!!', then %sx is automatically
+        invoked.  That is, while:
+          !ls
+        causes ipython to simply issue system('ls'), typing
+          !!ls
+        is a shorthand equivalent to:
+          %sx ls
         
         2) %sx differs from %sc in that %sx automatically splits into a list,
-	like '%sc -l'. The reason for this is to make it as easy as possible to
-	process line-oriented shell output via further python commands. %sc is
-	meant to provide much finer control, but requires more typing.
+        like '%sc -l'.  The reason for this is to make it as easy as possible
+        to process line-oriented shell output via further python commands.
+        %sc is meant to provide much finer control, but requires more
+        typing.
 
         3) Just like %sc -l, this is a list with special attributes:
 
-	.l (or .list) : value as list. .n (or .nlstr): value as
-	newline-separated string. .s (or .spstr): value as whitespace-separated
-	string.
+          .l (or .list) : value as list.
+          .n (or .nlstr): value as newline-separated string.
+          .s (or .spstr): value as whitespace-separated string.
 
-	This is very useful when trying to use such lists as arguments to system
-	commands.
+        This is very useful when trying to use such lists as arguments to
+        system commands.
 
+**%system_verbose**::
 
-	%system_verbose: Set verbose printing of system calls.
+	Set verbose printing of system calls.
 
         If called without an argument, act as a toggle
 
+**%time**::
 
-	%time: Time execution of a Python statement or expression.
+	Time execution of a Python statement or expression.
 
         The CPU and wall clock times are printed, and the value of the
-	expression (if any) is returned. Note that under Win32, system time is
-	always reported as 0, since it can not be measured.
+        expression (if any) is returned.  Note that under Win32, system time
+        is always reported as 0, since it can not be measured.
 
-	This function provides very basic timing functionality. In Python 2.3,
-	the timeit module offers more control and sophistication, so this could
-	be rewritten to use it (patches welcome).
+        This function provides very basic timing functionality.  In Python
+        2.3, the timeit module offers more control and sophistication, so this
+        could be rewritten to use it (patches welcome).
         
         Some examples:
 
-	In [1]: time 2**128 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
-	Wall time: 0.00 Out[1]: 340282366920938463463374607431768211456L
+          In [1]: time 2**128
+          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+          Wall time: 0.00
+          Out[1]: 340282366920938463463374607431768211456L
 
           In [2]: n = 1000000
 
-	In [3]: time sum(range(n)) CPU times: user 1.20 s, sys: 0.05 s, total:
-	1.25 s Wall time: 1.37 Out[3]: 499999500000L
+          In [3]: time sum(range(n))
+          CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
+          Wall time: 1.37
+          Out[3]: 499999500000L
 
-	In [4]: time print 'hello world' hello world CPU times: user 0.00 s,
-	sys: 0.00 s, total: 0.00 s Wall time: 0.00
+          In [4]: time print 'hello world'
+          hello world
+          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+          Wall time: 0.00
 
-	Note that the time needed by Python to compile the given expression will
-	be reported if it is more than 0.1s. In this example, the actual
-	exponentiation is done by Python at compilation time, so while the
-	expression can take a noticeable amount of time to compute, that time is
-	purely due to the compilation:
+          Note that the time needed by Python to compile the given expression
+          will be reported if it is more than 0.1s.  In this example, the
+          actual exponentiation is done by Python at compilation time, so while
+          the expression can take a noticeable amount of time to compute, that
+          time is purely due to the compilation:
 
-	In [5]: time 3**9999; CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+          In [5]: time 3**9999;
+          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
           Wall time: 0.00 s
 
-	In [6]: time 3**999999; CPU times: user 0.00 s, sys: 0.00 s, total: 0.00
-	s Wall time: 0.00 s Compiler : 0.78 s
+          In [6]: time 3**999999;
+          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+          Wall time: 0.00 s
+          Compiler : 0.78 s
 
+**%timeit**::
 
-	%timeit: Time execution of a Python statement or expression
+	Time execution of a Python statement or expression
 
-	Usage:
+        Usage:\
           %timeit [-n<N> -r<R> [-t|-c]] statement
 
-	Time execution of a Python statement or expression using the timeit module.
+        Time execution of a Python statement or expression using the timeit
+        module.
 
-	Options: -n<N>: execute the given statement <N> times in a loop. If this
-	value is not given, a fitting value is chosen.
+        Options:
+        -n<N>: execute the given statement <N> times in a loop. If this value
+        is not given, a fitting value is chosen. 
         
         -r<R>: repeat the loop iteration <R> times and take the best result.
         Default: 3
@@ -2534,49 +2809,84 b' customizations.'
         -t: use time.time to measure the time, which is the default on Unix.
         This function measures wall time.
         
-	-c: use time.clock to measure the time, which is the default on Windows
-	and measures wall time. On Unix, resource.getrusage is used instead and
-	returns the CPU user time.
+        -c: use time.clock to measure the time, which is the default on
+        Windows and measures wall time. On Unix, resource.getrusage is used
+        instead and returns the CPU user time.
 
         -p<P>: use a precision of <P> digits to display the timing result.
         Default: 3
 
-	Examples:
-	In [1]: %timeit pass 10000000 loops, best of 3: 53.3 ns per loop
+        
+        Examples:\
+          In [1]: %timeit pass
+          10000000 loops, best of 3: 53.3 ns per loop
 
           In [2]: u = None
 
-	In [3]: %timeit u is None 10000000 loops, best of 3: 184 ns per loop
+          In [3]: %timeit u is None
+          10000000 loops, best of 3: 184 ns per loop
 
-	In [4]: %timeit -r 4 u == None 1000000 loops, best of 4: 242 ns per loop
+          In [4]: %timeit -r 4 u == None
+          1000000 loops, best of 4: 242 ns per loop
 
           In [5]: import time
 
-	In [6]: %timeit -n1 time.sleep(2) 1 loops, best of 3: 2 s per loop
+          In [6]: %timeit -n1 time.sleep(2)
+          1 loops, best of 3: 2 s per loop
+          
 
         The times reported by %timeit will be slightly higher than those
         reported by the timeit.py script when variables are accessed. This is
-	due to the fact that %timeit executes the statement in the namespace of
-	the shell, compared with timeit.py, which uses a single setup statement
-	to import function or create variables. Generally, the bias does not
-	matter as long as results from timeit.py are not mixed with those from
-	%timeit.
+        due to the fact that %timeit executes the statement in the namespace
+        of the shell, compared with timeit.py, which uses a single setup
+        statement to import function or create variables. Generally, the bias
+        does not matter as long as results from timeit.py are not mixed with
+        those from %timeit.
+
+**%unalias**::
+
+	Remove an alias
+
+**%upgrade**::
+
+	 Upgrade your IPython installation
+        
+        This will copy the config files that don't yet exist in your 
+        ipython dir from the system config dir. Use this after upgrading 
+        IPython if you don't wish to delete your .ipython dir.
+
+        Call with -nolegacy to get rid of ipythonrc* files (recommended for
+        new users)
+
+**%which**::
 
+	 %which <cmd> => search PATH for files matching cmd. Also scans aliases.
 
-	%unalias: Remove an alias
+    Traverses PATH and prints all files (not just executables!) that match the
+    pattern on command line. Probably more useful in finding stuff
+    interactively than 'which', which only prints the first matching item.
     
+    Also discovers and expands aliases, so you'll see what will be executed
+    when you call an alias.
     
-	%upgrade: Upgrade your IPython installation
+    Example:
     
-	This will copy the config files that don't yet exist in your ipython dir
-	from the system config dir. Use this after upgrading IPython if you
-	don't wish to delete your .ipython dir.
+    [~]|62> %which d
+    d -> ls -F --color=auto
+      == c:\cygwin\bin\ls.exe
+    c:\cygwin\bin\d.exe
     
-	Call with -nolegacy to get rid of ipythonrc* files (recommended for new
-	users)
+    [~]|64> %which diff*
+    diff3 -> diff3
+      == c:\cygwin\bin\diff3.exe
+    diff -> diff
+      == c:\cygwin\bin\diff.exe
+    c:\cygwin\bin\diff.exe
+    c:\cygwin\bin\diff3.exe
 
+**%who**::
 
-	%who: Print all interactive variables, with some minimal formatting.
+	Print all interactive variables, with some minimal formatting.
 
         If any arguments are given, only variables whose type matches one of
         these are printed.  For example:
@@ -2587,7 +2897,7 b' customizations.'
         variables.  To find the proper type names, simply use type(var) at a
         command line to see how python prints type names.  For example:
 
-	In [1]: type('hello')
+          In [1]: type('hello')\
           Out[1]: <type 'str'>
 
         indicates that the type name for strings is 'str'.
@@ -2598,34 +2908,38 b' customizations.'
         This is deliberate, as typically you may load many modules and the
         purpose of %who is to show you only what you've manually defined.
 
+**%who_ls**::
 
-	%who_ls: Return a sorted list of all interactive variables.
+	Return a sorted list of all interactive variables.
 
-	If arguments are given, only variables of types matching these arguments
-	are returned.
+        If arguments are given, only variables of types matching these
+        arguments are returned.
 
+**%whos**::
 
-	%whos: Like %who, but gives some extra information about each variable.
+	Like %who, but gives some extra information about each variable.
 
         The same type filtering of %who can be applied here.
 
         For all variables, the type is printed. Additionally it prints:
         
-	- For ,[],(): their length.
+          - For {},[],(): their length.
 
           - For numpy and Numeric arrays, a summary with shape, number of
           elements, typecode and size in memory.
 
-	- Everything else: a string representation, snipping their middle if too
-	long.
+          - Everything else: a string representation, snipping their middle if
+          too long.
 
+**%xmode**::
 
-	%xmode: Switch modes for the exception handlers.
+	Switch modes for the exception handlers.
 
         Valid modes: Plain, Context and Verbose.
 
         If called without arguments, acts as a toggle.
 
+.. magic_end
 
 Access to the standard Python help
 ----------------------------------