JOVE(1)

📦
version 4.17.5.5.77.gfd92a30 · 5 versions
, in ubuntu stonking

💖 JOVE(1) 💖

general commands manual · bestie edition ✨

Okay so. jove is an interactive, display-oriented text editor, and this is literally its whole manual page. Grab a snack, we're doing this together. 🍓

🌸 NAME 🌸

jove — an interactive display-oriented text editor 💅

✨ SYNOPSIS ✨

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

Two moods: the normal one, and jove -r which is the whole crash-recovery era. 🫶

🦋 DESCRIPTION 🦋

JOVE stands for Jonathan's Own Version of Emacs, and she's based on the original EMACS editor that Richard Stallman wrote at MIT. But listen — even though JOVE is meant to be compatible with EMACS, there are some major differences between the two editors, and you should not rely on them behaving identically. They are sisters, not twins, okay? 😭

JOVE aims to be small and usable on a wide array of systems, so she works on many reasonable display terminals — like modern vt[12]-style terminals — and also by linking to a general terminal handling library such as ncurses (terminfo) or termcap (see TERMCAP(5)).

When you start up JOVE, she checks whether you have your TERM environment variable set. On most systems that'll get set up for you automatically, but if it's not, JOVE will ask you what kind of terminal you're using. To avoid having to type that every single time you run JOVE, you can just set your TERM environment variable yourself. How you do it depends on which shell you're running. If you're 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're using (e.g., vt100). If neither of these works, get somebody to help you. 🧚 (genuinely, no shame in that)

💜 INVOKING JOVE 💜

If you run JOVE with no arguments, you'll be placed in an empty buffer called Main. ✨ Otherwise, any arguments you supply are considered file names, and each one 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're attached to. It's 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 anyway. Not her wasting energy on your 47 tabs 💀

The names of all the files specified on the command line are saved in a buffer called *minibuf*. The mini-buffer is a special JOVE buffer that gets used when JOVE is prompting for some input to many commands (for example, when JOVE is prompting for a file name). When you're 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 gets inserted right where you're typing, and then you can edit it as if you typed it in yourself. Obsessed, honestly. 🎀

JOVE recognizes the following switches:

  • -d dirname — dirname is taken to be the name of the current directory. This one's for systems that don't have a version of C shell that automatically maintains the CWD environment variable. If -d isn't specified on a system without a modified C shell, JOVE will have to figure out the current directory herself, 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'
  • -D debugfile — debugfile is created if missing, and some internal debug output is written to it. Only for developers (or for filing bug reports on interactive-shell misbehaviour). You are not the target audience, bestie, unless you are 🙈
  • -l libdir — lets you specify the directory where the supporting programs (recover, portsrv) required by JOVE can be found (default /usr/lib/jove). Inside JOVE, this setting is visible as the lib-dir-pathname variable. Heads up: if JOVE was built to fit on machines with very little memory, without the features for post-crash recovery or interactive processes, then this option is not relevant. Also, if libdir is a relative path, then the directory from which the running JOVE binary was started gets prepended to it.
  • -s sharedir — lets you specify the directory where the default initialization files, command help and the primary JOVE tutorial can be found (default /usr/share/jove). Inside JOVE, this setting is visible as the share-dir-pathname variable. And same deal: if sharedir is a relative path, then the directory from which the running Jove binary was started gets prepended to it.
  • -ls bothdir — lets you specify the directory where the binary files and initialization files required by JOVE can be found. Pssst: -sl is an alias for this option. 👑
  • -J — inhibits reading of the system-wide initialization file (/usr/share/jove/jove.rc).
  • -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. You can specify this more than once, but it doesn't make sense to use it twice on the same file — in that case, the second one wins. And if no numeric argument is given after the +, point gets positioned at the end of the file.
  • +/pattern — 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. Those 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)).
  • -T — starts JOVE in teach-jove mode, loading the JOVE tutorial into a buffer (unsaved) with the filename ~/teach-jove. This replaces the old teachjove command. 📚
  • -wn — divides the window into n windows (if n is omitted, it's taken to be 2). Subsequent files in the list are read in and displayed in succeeding windows. Window girlies rise 🌈

🌟 RECOVERING BUFFERS AFTER A CRASH 🌟

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

recover looks for JOVE buffers that are left around and are owned by you. (You cannot recover other peoples' buffers, obviously. That would be so not it.) 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'll 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 to type a command.

To get a list of the buffers recover knows about, use the list command. This lists all the buffers, 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 recovers 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 whether 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'll 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'll 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). Lowkey the safe move, ngl.

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. Rude but iconic. 💅 And if you do this but wish you hadn't, just type jove -r to the shell again, and you'll be put back with no loss.

🎀 GETTING HELP 🎀

Once you're 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 creates a buffer and puts 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 gives you a list of all the commands 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 familiar with the EMACS command set, it would be worth your while to run TEACHJOVE. To do that, just type teachjove to your shell and you'll 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. 😭🫶 Trust. iykyk.

🔑 KEY BINDINGS and VARIABLES 💅

Bestie, you can totally remix the key bindings in JOVE so they match your personal taste. Like, you can change what a key does every single time you hit it. For example, by default the ^N key is bound to the command next-line, so when you type it you move down a line — no cap. If you wanna change a binding or add a whole new one, you use the bind-to-key command. The syntax is:

bind-to-key <command> key

You can also tweak how JOVE behaves in lil ways by changing the value of some variables with the set command. Syntax is:

set <variable> value

where value is a number or a string, or on or off, depending on the context. So for example, if you want JOVE to make backup files, you set the make-backup-files variable to on. And to peek at the value of a variable, you use the print <variable> command. Slay. ✨

🎀 INITIALIZATION ✨

JOVE first reads the system-wide initialization file (/usr/share/jove/jove.rc), which provides reasonable defaults for your installation and loads standard macros. It will normally observe your TERM environment variable so it can give you terminal-specific key bindings and a map of your keyboard (see the standard keychart macro). Iconic behavior, honestly. 🫶

Then JOVE automatically reads further commands from the initialization file called .joverc (jove.rc under MSDOS) in your HOME directory. In this file you can drop commands that you'd normally type inside JOVE. So if you like to rearrange key bindings and set some variables every time you get into JOVE, bestie, that's exactly where they go. 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^.)

🌍 ENVIRONMENT 🌈

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. And if none of the above variables is set in the environment, the "C" (U.S. style) locale determines how JOVE behaves. Periodt.

LC_CTYPE

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

🧚 SOME MINOR DETAILS 💖

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

📁 FILES 🍓

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

💜 ENVIRONMENT VARIABLES ⭐

  • 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 /usr/lib/jove unless overridden by -l or -ls
  • JOVESHARE — overrides /usr/share/jove unless overridden by -s or -ls
  • TMPDIR — overrides /var/tmp as directory for temporary files
  • LC_ALL, LC_CTYPE, LANG — to set the locale

👀 SEE ALSO 🔥

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

Project resources and releases: https://github.com/jonmacs/jove

🩺 DIAGNOSTICS 😭

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. Like, fr fr, be careful bestie. 💀

💀 BUGS / LIMITATIONS 🙈

Line lengths are limited to a fixed value set at compile time. The Default is 32768.

JOVE does not support multi-byte UTF-8 characters. In UTF-8 locales, non-ASCII characters may display incorrectly. Use ASCII or single-byte encodings with JOVE.

Searches can't cross line boundaries.

👑 AUTHOR 🌸

Jonathan Payne

That's the whole vibe check, babe — this page is from 24 June 1993, sourced from the JOVE(1) manual. Go forth and edit like the main character you are. 💅✨🎀

📦 where this page comes from