*pi_tar.txt*	For Vim version 7.2.  Last change: 2009 Dec 28

		       +====================+
		       | Tar File Interface |
		       +====================+

Author:  Charles E. Campbell, Jr.  <NdrOchip@ScampbellPfamily.AbizM>
	  (remove NOSPAM from Campbell's email first)
Copyright 2005-2008: The GPL (gnu public license) applies to	*tar-copyright*
	   tar.vim, tarPlugin.vim, and pi_tar.txt.
	   No warranty, express or implied.  Use At-Your-Own-Risk.

==============================================================================
1. Contents					*tar* *tar-contents*
   1. Contents..................................................|tar-contents|
   2. Usage.....................................................|tar-usage|
   3. Options...................................................|tar-options|
   4. History...................................................|tar-history|

==============================================================================
2. Usage					*tar-usage* *tar-manual*

   When one edits a *.tar file, this plugin will handle displaying a
   contents page.  Select a file to edit by moving the cursor atop
   the desired file, then hit the <return> key.  After editing, one may
   also write to the file.  Currently, one may not make a new file in
   tar archives via the plugin.

						*:Untarvim*
   UNTARVIM~

   :Untarvim [vimhome]

	This command copies, if necessary, the tarball to the .vim or vimfiles
	directory using the first writable directory in the |'runtimepath'|
	when no [vimhome] is specified.  Otherwise, the [vimhome] argument
	allows the user to specify that directory, instead.

	The copy is done using the command in *g:tar_copycmd* , which is >
		cp   for cygwin, unix, macunix
		copy for windows (32, 95, 64, 16)
<	The extraction is done with the command specified with
	*g:tar_extractcmd* , which by default is >
		"tar -xf"
<
   PREVENTING LOADING~

   If for some reason you do not wish to use vim to examine tar'd files,
   you may put the following two variables into your <.vimrc> to prevent
   the tar plugin from loading: >

	let g:loaded_tarPlugin= 1
	let g:loaded_tar      = 1
<

==============================================================================
3. Options						*tar-options*

   These options are variables that one may change, typically in one's
   <.vimrc> file.
                         Default
   Variable               Value   Explanation
   *g:tar_browseoptions*  "Ptf"   used to get a list of contents
   *g:tar_readoptions*    "OPxf"  used to extract a file from a tarball
   *g:tar_cmd*            "tar"   the name of the tar program
   *g:tar_nomax*            0     if true, file window will not be maximized
   *g:tar_secure*         undef   if exists:
					"--"s will be used to prevent unwanted
					option expansion in tar commands.
					Please be sure that your tar command
					accepts "--"; Posix compliant tar
					utilities do accept them.
				  if not exists:
				  	The tar plugin will reject any tar
					files or member files that begin with
					"-"
				  Not all tar's support the "--" which is why
				  it isn't default.
   *g:tar_writeoptions*   "uf"    used to update/replace a file


==============================================================================
4. History						*tar-history*


   v24 Apr 07, 2009 * :Untarvim command implemented
       Sep 28, 2009 * Added lzma support
   v22 Aug 08, 2008 * security fixes
   v16 Jun 06, 2008 * tarfile:: used instead of tarfile: when editing files
		      inside tarballs.  Fixes a problem with tarballs called
		      things like c:\abc.tar. (tnx to Bill McCarthy)
   v14 May 09, 2008 * arno caught a security bug
       May 28, 2008 * various security improvements.  Now requires patch 299
		      which provides the fnameescape() function
       May 30, 2008 * allows one to view *.gz and *.bz2 files that are in
		    *.tar files.
   v12 Sep 07, 2007 * &shq now used if not the empty string for g:tar_shq
   v10 May 02, 2006 * now using "redraw then echo" to show messages, instead
		      of "echo and prompt user"
   v9 May 02, 2006 * improved detection of masquerading as tar file
   v8 May 02, 2006 * allows editing of files that merely masquerade as tar
		     files
   v7 Mar 22, 2006 * work on making tar plugin work across network
      Mar 27, 2006 * g:tar_cmd now available for users to change the name
		     of the tar program to be used.  By default, of course,
		     it's "tar".
   v6 Dec 21, 2005 * writing to files not in directories caused problems -
		     fixed (pointed out by Christian Robinson)
   v5 Nov 22, 2005 * report option workaround installed
   v3 Sep 16, 2005 * handles writing files in an archive back to the
		     archive
      Oct 18, 2005 * <amatch> used instead of <afile> in autocmds
      Oct 18, 2005 * handles writing to compressed archives
      Nov 03, 2005 * handles writing tarfiles across a network using
		     netrw#NetWrite()
   v2              * converted to use Vim7's new autoload feature by
		     Bram Moolenaar
   v1 (original)   * Michael Toren (see http://michael.toren.net/code/)

==============================================================================
vim:tw=78:ts=8:ft=help
