Provided by: vile-common_9.8v-1build1_all bug

NAME

       vile, xvile, uxvile, lxvile - VI Like Emacs

SYNOPSIS

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

DESCRIPTION

       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.

SPIRIT

       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.

OPTIONS

       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).

   COMMON OPTIONS
       -ccommand
              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 example

                 vile -c123 filename
                 vile -c/pattern filename

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

                 :123
                 :/pattern

              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.

       @cmdfile
              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 “[Trace]”.

       -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 line.

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

   X11 OPTIONS
       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 supported.

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

       +command
              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.

INVOCATION

       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.

STARTUP

       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.

COMMANDS

       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.

RELATED PROGRAMS

   xvile
       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.

   vile-manfilt
       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.

UTILITY SCRIPTS

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

   vile-libdir-path
       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-pager
       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-to-html
       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 formats:

       atr2ansi
              converts the markup to ANSI escape sequences.

       atr2html
              converts the markup to HTML (with color).

       atr2text
              converts the markup to plain text.

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

ENCRYPTION

       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 input.

       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.

ENVIRONMENT VARIABLES

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

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

       VILE_LIBDIR_PATH
              Augment $PATH when searching for a filter program.

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

       VILE_STARTUP_PATH
              Override the search path for the startup and help files.

SEE ALSO

       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.

DEBTS and CREDITS

       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.

AUTHORS

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

BUGS

       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:

       https://savannah.nongnu.org/projects/vile

                                                                                                         VILE(1)