Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
JOVE(1)			    General Commands Manual		       JOVE(1)

       jove - an interactive display-oriented text editor

       jove  [	-d directory ] [ -l libdir ] [ -s sharedir ] [ -ls bothdir ] [
       -J ] [ -j ] [ -wn ] [ -t	tag ] [	+n file	] [ +/pattern file ] [ -p file
       ] [ file...  ]
       jove -r

       JOVE  is	 Jonathan's Own	Version	of Emacs.  It is based on the original
       EMACS editor written at MIT by  Richard	Stallman.   Although  JOVE  is
       meant  to  be  compatible  with EMACS, there are	some major differences
       between the two editors	and  you  shouldn't  rely  on  their  behaving

       JOVE  works on any reasonable display terminal that is described	in the
       termcap file (see TERMCAP(5) for	more  details).	  When	you  start  up
       JOVE,  it checks	to see whether you have	your TERM environment variable
       set.  On	most systems that will automatically be	set up for you,	but if
       it's  not  JOVE	will  ask you what kind	of terminal you	are using.  To
       avoid having to type this every time you	run JOVE you can set your TERM
       environment  variable yourself.	How you	do this	depends	on which shell
       you are running.	 If you	are running the	C Shell, as most of  you  are,
       you type

	    % setenv TERM type

       and with	the Bourne Shell, you type

	    $ TERM= type ; export TERM

       where  type  is	the  name of the kind of terminal you are using	(e.g.,
       vt100).	If neither of these works get somebody to help you.

       If you run JOVE with no arguments  you  will  be	 placed	 in  an	 empty
       buffer,	 called	  Main.	  Otherwise,  any  arguments  you  supply  are
       considered file names and each is ``given'' its own buffer.   Only  the
       first file is actually read in -- reading other files is	deferred until
       you actually try	to use the buffers they	are attached to.  This is  for
       efficiency's sake: most of the time, when you run JOVE on a big list of
       files, you end up editing only a	few of them.

       The names of all	of the files specified on the command line  are	 saved
       in  a  buffer,  called  *minibuf*.   The	 mini-buffer is	a special JOVE
       buffer that is used when	JOVE is	 prompting  for	 some  input  to  many
       commands	 (for  example,	when JOVE is prompting for a file name).  When
       you are being prompted for  a  file  name,  you	can  type  ^N  (that's
       Control-N)  and	^P  to	cycle  through	the  list  of  files that were
       specified on the	command	line.  The file	name will  be  inserted	 where
       you are typing and then you can edit it as if you typed it in yourself.

       JOVE recognizes the following switches:

       -d dirname
	      dirname  is taken	to be the name of the current directory.  This
	      is for systems that  don't  have	a  version  of	C  shell  that
	      automatically  maintains the CWD environment variable.  If -d is
	      not specified on a system	without	a modified C shell, JOVE  will
	      have to figure out the current directory itself, and that	can be
	      slow.  You can simulate the modified  C  shell  by  putting  the
	      following	lines in your C	shell initialization file (.cshrc):

		   alias cd	   'cd \!*; setenv CWD $cwd'
		   alias popd	   'popd \!*; setenv CWD $cwd'
		   alias pushd	   'pushd \!*; setenv CWD $cwd'

       -l libdir
	      Allows  the  user	to specify the directory in which binary files
	      required	   by	  JOVE	   can	   be	   found      (default

       -s sharedir
	      Allows the user to specify the directory in which	initialization
	      files    required	   by	 JOVE	 can	be    found   (default

       -ls bothdir
	      Allows  the  user	to specify the directory in which binary files
	      and initialization files required	by JOVE	can be found.

       -J     Inhibits	reading	 of  the   system-wide	 initialization	  file

       -j     Inhibits reading of the user's initialization file (~/.joverc).

       +n     Reads  the  file	designated  by	the  following	argument,  and
	      positions	 point at the n'th line	instead	of the (default) first
	      line.  This can be specified more	than once but it doesn't  make
	      sense  to	use it twice on	the same file; in that case the	second
	      one wins.	 If no numeric argument	is  given  after  the  +,  the
	      point is positioned at the end of	the file.

	      Reads  the  file	designated  by	the  following	argument,  and
	      positions	point at the first match of the	pattern.

       -p file
	      Parses the error messages	 in  file.   The  error	 messages  are
	      assumed  to  be  in a format similar to the C compiler, LINT, or
	      GREP output.

       -t tag Runs the find-tag	command	on tag (see ctags(1)).

       -wn    Divides the window into n	windows	(if n is ommitted, it is taken
	      to  be  2).   Subsequent	files  in  the	list  are  read	in and
	      displayed	in succeeding windows.

       The -r option of	jove runs the JOVE recover program.  Use this when the
       system crashes, or JOVE crashes,	or you accidently get logged out while
       in JOVE.	 If there are any buffers to  be  recovered,  this  will  find

       Recover	looks  for  JOVE buffers that are left around and are owned by
       you.  (You cannot recover other peoples'	buffers, obviously.)  If there
       were  no	 buffers  that were modified at	the time of the	crash or there
       were but	recover	can't get its hands on them, you will be informed with
       the  message,  ``There  is  nothing  to	recover.''  Otherwise, recover
       prints the date and time	of the version of the buffers it has, and then
       waits for you type a command.

       To get a	list of	the buffers recover knows about, use the list command.
       This will list all the buffers and the files and	the  number  of	 lines
       associated  with	them.  Next to each buffer is a	number.	 When you want
       to recover a buffer, use	the get	command.  The  syntax  is  get	buffer
       filename	 where buffer is either	the buffer's name or the number	at the
       beginning of the	line.  If you  don't  type  the	 buffer	 name  or  the
       filename, recover will prompt you for them.

       If  there are a lot of buffers and you want to recover all of them, use
       the recover command.  This will recover each buffer to the name of  the
       buffer  with  ``.#''  prepended to the name (so that the	original isn't
       over-written).  It asks for each	file and if you	want to	 restore  that
       buffer  to that name you	type ``yes''.  If you want to recover the file
       but to a	different name,	just type the new name in.  If you type	``no''
       recover will skip that file and go on to	the next one.

       If  you want to look at a buffer	before deciding	to recover it, use the
       print command.  The syntax for this is print buffer where buffer	 again
       is either its name or the number.  You can type ^C if you want to abort
       printing	the file to the	terminal, and recover  will  respond  with  an
       appropriate message.

       When  you're  done  and	have  all  the buffers you want, type the quit
       command to leave.  You will then	be asked whether it's okay  to	delete
       the  tmp	 files.	  Most	of  the	 time  that's okay and you should type
       ``yes''.	 When you say that, JOVE removes all traces of	those  buffers
       and  you	 won't	be able	to look	at them	again.	(If you	recovered some
       buffers they will still be around, so don't worry.)  So,	if you're  not
       sure whether you've gotten all the buffers, you should answer ``no'' so
       that you'll be able to run recover again	at a  later  time  (presumably
       after  you've  figured out which	ones you want to save).	 If there were
       more than one crashed JOVE session, quit	will move you  on  to  dealing
       with the	next one instead of exiting.

       If  you	type  ^C at any	time other than	when you're printing a file to
       the terminal, recover will exit without a word.	If  you	 do  this  but
       wish you	hadn't,	just type ``jove -r'' to the shell again, and you will
       be put back with	no loss.

       Once in JOVE, there are several commands	available  to  get  help.   To
       execute any JOVE	command, you type ``<ESC> X command-name'' followed by
       <Return>.  To get a list	of all the JOVE	commands you type ``<ESC>  X''
       followed	 by ``?''.  The	describe-bindings command can be used to get a
       list containing each key, and its  associated  command  (that  is,  the
       command	that  gets  executed  when you type that key).	If you want to
       save the	list of	bindings, you can set the jove variable	 send-typeout-
       to-buffer to ON (using the set command),	and then execute the describe-
       bindings	command.  This will create a buffer and	put in it the bindings
       list  it	 normally would	have printed on	the screen.  Then you can save
       that buffer to a	file and print it to use as a  quick  reference	 card.
       (See VARIABLES below.)

       Once you	know the name of a command, you	can find out what it does with
       the describe-command command, which you can invoke  quickly  by	typing
       ``ESC ?''.  The apropos command will give you a list of all the command
       with a specific string in their names.  For example,  if	 you  want  to
       know the	names of all the commands that are concerned with windows, you
       can run ``apropos'' with	the keyword window.

       If the initialization file has provided specific	keybindings  for  your
       terminal,  it  should also be possible to view the keyboard layout with
       the keychart macro.

       If you're not familar with the EMACS command set,  it  would  be	 worth
       your  while  to use run TEACHJOVE.  Do do that, just type ``teachjove''
       to your shell and you will be placed in JOVE in a file  which  contains
       directions.   I	highly	recommend  this	 for  beginners;  you may save
       yourself	a lot of time and headaches.

       You can alter the key bindings in JOVE to  fit  your  personal  tastes.
       That  is, you can change	what a key does	every time you strike it.  For
       example,	by default the ^N key is bound to the command next-line	and so
       when you	type it	you move down a	line.  If you want to change a binding
       or add a	new one, you use  the  bind-to-key  command.   The  syntax  is
       ``bind-to-key <command> key''.

       You can also change the way JOVE	behaves	in little ways by changing the
       value of	some variables with the	set  command.	The  syntax  is	 ``set
       <variable>  value'',  where value is a number or	a string, or ``on'' or
       ``off'',	depending on the context.  For example,	if you	want  JOVE  to
       make  backup  files,  you  set  the  ``make-backup-files''  variable to
       ``on''.	To see the value of a variable,	use the	 ``print  <variable>''

       JOVE	first	 reads	  the	 system-wide	initialization	  file
       which  provides	reasonable  defaults  for  your	installation and loads
       standard	macros.	  It  will  normally  observe  your  TERM  environment
       variable	 in  order to provide terminal-specific	key bindings and a map
       of your keyboard	(see the standard ``keychart'' macro).

       JOVE then automatically reads further commands from the	initialization
       file   called  ``.joverc''  (``jove.rc''	 under	MSDOS)	in  your  HOME
       directory.  In this file	you can	place commands that you	would normally
       type  in	 JOVE.	If you like to rearrange the key bindings and set some
       variables every time you	get into JOVE, you should  put	them  in  your
       initialization file.  Here are a	few lines from mine:
	    set	match-regular-expressions on
	    1 auto-execute-command auto-fill /tmp/Re\|.*drft
	    bind-to-key	i-search-forward ^\
	    bind-to-key	i-search-reverse ^R
	    bind-to-key	find-tag-at-point ^[^T
	    bind-to-key	scroll-down ^C
	    bind-to-key	grow-window ^Xg
	    bind-to-key	shrink-window ^Xs
       (Note that the Control Characters can be	either two character sequences
       (e.g. ^ and C together as ^C) or	the actual control character.  If  you
       want  to	 use  an  ^ by itself you must BackSlash it (e.g., bind-to-key
       grow-window ^X\^	binds grow-window to ``^X^'').

       If  the	variable  LC_CTYPE  (see  environ(5))  is  not	set   in   the
       environment,  the  operational behavior of JOVE for the LC_CTYPE	locale
       category	is determined by the value of the LANG	environment  variable.
       If  LC_ALL  is set, its contents	are used to override both the LANG and
       the LC_CTYPE variable.  If none of the above variables is  set  in  the
       environment, the	"C" (U.S. style) locale	determines how JOVE behaves.

	      Determines  how JOVE handles characters. When LC_CTYPE is	set to
	      a	valid value, JOVE can display and handle  text	and  filenames
	      containing  valid	 characters  for  that	locale.	In particular,
	      characters will be correctly recognised as upper or  lower  case
	      and  displayed  if  printable.   However	JOVE cannot display or
	      handle Extended Unix Code	(EUC) characters which are more	than 1
	      byte  wide.  In the "C" locale, only characters from 7-bit ASCII
	      are  valid  (all	characters  with  the  eighth  bit  set	 being
	      displayed	in octal). In the "iso_8859_1" locale (if supported by
	      the OS), the  full  Latin-1  alphabet  is	 available.  The  JOVE
	      variable	``lc-ctype''  can  be  used to change the locale while
	      JOVE is running.

       You should type ^\ instead of ^S	in many	instances.  For	 example,  the
       way to search for a string is documented	as being ``^S''	but in reality
       you should type ``^\''.	This is	because	^S is the XOFF character (what
       gets  sent  when	 you  type  the	NO SCROLL key),	and clearly that won't
       work.  The XON character	is ``^Q'' (what	gets sent  when	 you  type  NO
       SCROLL  again)  which  is  documented as	the way	to do a	quoted-insert.
       The alternate key for this is ``^^'' (typed as ``^`''  on  vt100's  and
       its  look-alikes).   If	you want to enable ^S and ^Q and you know what
       you are doing, you can put the line:
	    set	allow-^S-and-^Q	on
       in your initialization file.

       If your terminal	has  a	metakey	 and  you  turn	 on  the  ``meta-key''
       variable,  JOVE	will use it to generate	commands which would otherwise
       start with an ESC.  JOVE	will automatically turn	on ``meta-key''	if the
       METAKEY	environment  variable  exists.	This is	useful for if you have
       different terminals (e.g., one at home and one at work) and one	has  a
       metakey	and  the other doesn't.	 However, if a locale which recognises
       8-bit characters	is in force, a metakey may be better used to  generate
       the extra characters (so	leave the ``meta-key'' variable	off).

       /wrkdirs/usr/ports/editors/jove/work/stage/usr/local/share/jove/jove.rc -- system-wide initialization file
       /wrkdirs/usr/ports/editors/jove/work/stage/usr/local/share/jove/jove.rc.$TERM --	terminal-specific initialization file
       /wrkdirs/usr/ports/editors/jove/work/stage/usr/local/share/jove/keychart.$TERM -- terminal-specific help	file
       /wrkdirs/usr/ports/editors/jove/work/stage/usr/local/share/jove/macros -- standard macros file
       ~/.joverc -- personal initialization file
       /var/tmp	-- where temporary files are stored
       /wrkdirs/usr/ports/editors/jove/work/stage/usr/local/share/jove/teach-jove -- the interactive tutorial
       /wrkdirs/usr/ports/editors/jove/work/stage/usr/local/libexec/jove/recover -- the	recovery program
       /wrkdirs/usr/ports/editors/jove/work/stage/usr/local/libexec/jove/portsrv -- for	running	shells in windows (pdp11 only)

       TERM -- your terminal type
       METAKEY -- if defined, sets the ``meta-key'' variable
       SHELL --	the shell to be	used by	the ``shell'' and other	commands
       COMSPEC -- (on MSDOS) used if SHELL is not defined
       MAIL -- to initialize the ``mailbox'' variable
       JOVELIB -- overrides /wrkdirs/usr/ports/editors/jove/work/stage/usr/local/libexec/jove unless overridden	by -l
       JOVESHARE -- overrides /wrkdirs/usr/ports/editors/jove/work/stage/usr/local/share/jove unless overridden	by -s
       TMPDIR -- overrides /var/tmp as directory for temporary files
       LC_ALL, LC_CTYPE, LANG -- to set	the locale

       ctags(1)	-- to generate tags for	the find-tag command and the -t	command-line
       ed(1) --	for a description of regular expressions
       teachjove(1) -- for an interactive JOVE tutorial.

       JOVE  diagnostics are meant to be self-explanatory, but you are advised
       to seek help whenever you are confused.	You can	easily lose a  lot  of
       work if you don't know EXACTLY what you are doing.

       Lines can't be more than	1024 characters	long.

       Searches	can't cross line boundaries.

       Jonathan	Payne

				 24 June 1993			       JOVE(1)


Want to link to this manual page? Use this URL:

home | help