Provided by: vile-common_9.8t-1_all bug


       vile, xvile, uxvile, lxvile - VI Like Emacs


       vile   [@cmdfile]   [+command]   [-FhIiRVv]   [-gNNN]   [-kcryptkey]  [-spattern]  [-ttag]


       vile is a text editor.  This man page is fairly terse.  More information can  be  obtained
       from  the internal help, available with the -h option or by using the “:help” command from
       within vile.

       xvile is the same text editor, built as an X-windows application,  with  fully  integrated
       mouse support, scrollbars, etc.

       uxvile  is a wrapper around xvile which invokes the latter program with the correct locale
       environment required to use a unicode character set and the “UXVile” X resource class set.

       lxvile is a wrapper around xvile which invokes the latter program with a  font  chosen  to
       match the current locale environment.


       vile  retains  the  “finger-feel” if you will, of vi, while adding the multiple buffer and
       multiple window features of emacs and other editors.  It is definitely not a vi clone,  in
       that  some  substantial stuff is missing, and the screen doesn't look quite the same.  The
       things that you tend to type over and over probably work.  Things  done  less  frequently,
       like  configuring  a  startup  file, are somewhat (or very, depending on how ambitious you
       are) different.  But what matters most is that one's “muscle memory” does the right  thing
       to the text in front of you, and that is what vile tries to do for vi users.


       Vile  accumulates  most options into two temporary buffers [vileinit] and [vileopts].  The
       former is executed before reading the first file into a buffer.  The  latter  is  executed
       after  reading  the  first file into a buffer.  Each is removed after executing (unless an
       error is detected).

              vile will begin the session on the first file invoking the  given  command.   Legal
              commands  include  many  ex-style  commands,  vile-commands, etc., subject to shell
              quoting.  This option is used most often with a line number or search pattern.  For

                 vile -c123 filename
                 vile -c/pattern filename

              They correspond to ex-style commands on the given file:


              These are more verbose equivalents:

                 vile -c'123 goto-line' filename
                 vile -c'search-forward /pattern/' filename

              You can use more than one command, e.g.,

                 vile -c'123' -c'10*goto-col' filename

              to  put  the  cursor on column 10 of line 123.  The “*”(or “:” separates the repeat
              count (used by goto-col) from  the  line-  or  range-specification  used  by  line-
              oriented commands.

              vile  will  run  the specified file as its startup file, and will bypass any normal
              startup file (i.e.  .vilerc) or environment variable (i.e.   $VILEINIT).   This  is
              added to [vileinit].

       -D     tells  vile  to  trace  the  results  of  macro  execution  into  the hidden buffer

       -e | -E
              Invokes vile in “noview” mode - changes are permitted to any buffer while  in  this
              mode (see “-v”.

       -F     will  run  the syntax filter that applies to each filename on the command-line, and
              write the attributed text to the standard output.

       -h     Invokes vile on the helpfile.

       -i | -I
              Tells vile to use vileinit.rc (which is installed) as the initialization file.   If
              you do not have a .vilerc, vile will make a short one that sources vileinit.rc This
              is added to [vileinit].

       -k cryptkey | -K cryptkey
              Specifies an encryption/decryption key.  See below for  further  discussion.   This
              option  applies  only  locally to the buffers named on the command-line, and is not
              added to [vileopts], since that is executed too late.

       -R     Invokes vile in “readonly” mode - no writes  are  permitted  while  in  this  mode.
              (This will also be true if vile is invoked as view, or if “readonly” mode is set in
              the startup file.)

       -s pattern | -S pattern
              In the first file, vile will execute an initial search for the given pattern.  This
              is  not  the  same  as  “-c/pattern”  since  that  positions the cursor to the line
              matching the pattern.  This option positions the cursor within the line.

       -t tag
              vile will edit the correct file and move the cursor to the  location  of  the  tag.
              This  requires  a  tagsfile  created  with  the ctags(1) command.  The option -T is
              equivalent, and can be used when X11 option parsing eats the -t.

       -U     overrides the $system-crlf variable, making new buffers start in dos mode.

       -u     overrides the $system-crlf variable, making new buffers start in nodos mode.

       -v     Invokes vile in “view” mode - no changes are permitted to any buffer while in  this
              mode (see “-e”.

       -V     vile will report its version number.

       -25 -43 -50 -60
              On PC systems you may be able to set the initial screen resolution from the command

       -80 -132
              On VMS systems you may be able to  set  the  initial  screen  resolution  from  the
              command line.  See vile.hlp for details.

       xvile-specific command-line options are detailed in the help file (see “Standard X command
       line arguments”.  The standard ones (e.g., -display, -fn, -geometry, -name, etc.) are  all

       vile recognizes some options which duplicate the functionality of the POSIX “-c” option:

              This has the same effect as “-ccommand”

       -g NNN | -G NNN
              This  has  the same effect as “-cNNNvile will begin the session on the first file
              jumping to the given line number NNN.


       vile will edit the files specified on the command line.  If no files  are  specified,  and
       standard input is not connected to a terminal, then vile will bring up a buffer containing
       the output of the pipe it is connected to, and will re-open /dev/tty for commands.   Files
       (except  for the first) are not actually read into buffers until “visited” All buffers are
       kept in memory: machines with not much memory or swap space may have trouble with this.


       If the @cmdfile option is given, then the file given as “cmdfile” will be run  before  any
       files  are loaded.  If no @ option appears, startup commands will be taken from the user's
       VILEINIT variable, if it is set, from the file .vilerc in the  current  directory,  if  it
       exists,  or  from $HOME/.vilerc, as a last resort.  See the help file for examples of what
       sorts of things might go into these command files.


       Please refer to  the  help  available  within  vile  for  vile-specific  commands.   (That
       document,  however, assumes familiarity with vi.)  Short descriptions of each vile command
       may be obtained with the “:describe-function” and “:describe-key” commands.  All  commands
       may be listed with “:show-commands”

       Additional  documentation  on  writing macros using the internal scripting language can be
       found in the file macros.doc, distributed with the vile source.


       vile may also be built and installed as xvile, in which case it  behaves  as  a  native  X
       Windows application, with scrollbars, better mouse support, etc.

       The help file has more information on this in the section X Window System specifics.

       There  is  a  program  distributed  with  the  vile  source  which is usually installed as
       vile-manfilt.  It may be used in conjunction with vile or xvile  (with  the  help  of  the
       macros  in  the  file manpage.rc) to filter and view system manual pages.  xvile will even
       (with your font set properly) display certain portions of the manual page text in bold  or
       italics as appropriate.

       See the help file section on Filtering “man” pages for details.

   Syntax filters
       Likewise, there are several language filters, e.g., vile-c-filt for C, which can embolden,
       underline, or perform coloring on program source code.

       Again, see the help file section on Syntax Coloring for more information.


       Vile is not simply an interactive program.  Its macro  language  and  use  of  environment
       variables lets it be useful in scripting.

       The  syntax  filters and vile-manfilt may not be installed where you would execute them in
       your PATH.  The vile-libdir-path script looks in the usual places and  prints  an  updated
       PATH variable which other scripts can use when executing these programs.

       Vile  can  be  used as a pager (typical examples include more and less).  This script uses
       vile-manfilt to preprocess a file which  is  piped  to  vile,  adding  markup  which  vile
       displays properly.

       Unlike a typical pager, vile-pager handles multi-line color escape sequences, and multiple
       levels of overstrikes.  But unlike a typical pager, vile-pager  expects  the  pipe  to  be
       closed before it starts displaying.

       Vile's  “-F”  option  makes  it  act  like  a  smart interface to the collection of syntax
       filters.  But  its  output  uses  vile's  internal  markup  rather  than  standard  escape
       sequences.   Vile's  utilities include programs which translate that markup into different

              converts the markup to ANSI escape sequences.

              converts the markup to HTML (with color).

              converts the markup to plain text.

       The vile-to-html script uses atr2html to convert a text file into HTML using color.


       The program vile-crypt can be used to encrypt/decrypt files using the  same  algorithm  as
       microEmac's internal crypt algorithm.  This program, which uses public domain code written
       by Dana Hoggatt, is no longer used in vile, though it is provided for compatibility.

       vile currently uses the crypt(3) function for encryption/decryption, which is available on
       most Unix systems.  This ensures that vile is able to read and write files compatibly with
       vi (but not vim, which uses an different algorithm derived from info-zip).   The  editor's
       encryption/decryption  key  can  be specified on the command line with “-k key” Text to be
       encrypted can be specified as filenames on the command line, or provided as  the  standard

       On  systems with a getpass() library routine, the user will be prompted for the encryption
       key if it is not given on the command line.  To accommodate systems (such as linux)  where
       the getpass() library routine is not interruptible from the keyboard, entering a crypt-key
       password which ends in ^C will cause the program to quit.

       See the help  file  for  more  information  on  vile's  encryption  support,  including  a
       discussion of a collection of macros that interface with GNU's gpg package.


              Editor  initialization  commands  in lieu of a startup file.  These are copied into
              [vileinit], and executed.

              Override the name of the help file, normally “vile.hlp”.

              Augment $PATH when searching for a filter program.

              Override the name of the startup file, normally “.vilerc” (or  “vile.rc”  for  non-
              UNIX systems).

              Override the search path for the startup and help files.


       Your favorite vi document, the file macros.doc, and the vile help page, available with the
       -h option or as the text file vile.hlp.


       vile was originally built from a copy of microEmacs, so a large debt of gratitude  is  due
       to  the developers of that program.  A lot of people have helped with code and bug reports
       on vile.  Names are named at the bottom of the help file.


       vile was created by Paul Fox, Tom Dickey, and Kevin Buettner.


       The "VI Like Emacs” joke  isn't  really  funny.   It  only  sounds  that  way.  :-)  Other
       suspicious  behavior should be reported via the project mailing list, or via the web-based
       bug reporting system.  Both of these are available here: