Version 3 (modified by rme, 14 years ago) (diff)



Hemlock is a text editor which follows in the tradition of Emacs and the Lisp Machine editor ZWEI. In its basic form, Hemlock has almost the same command set as ITS/TOPS-20 Emacs FootNote(In this document, "Emacs" refers to this, the original version, rather than to any of the large numbers of text editors inspired by it which may go by the same name.)?, and similar features such as multiple windows and extended commands, as well as built in documentation features. The reader should bear in mind that whenever some powerful feature of Hemlock is described, it has probably been directly inspired by Emacs.

This manual describes Hemlock ’s commands and other user visible features and then goes on to tell how to make simple customizations. For complete documentation of the Hemlock primitives with which commands are written, the Hemlock Command Implementor’s Manual is also available.

1.1 The Point and the Cursor

The point is the current focus of editing activity. Text typed in by the user is inserted at the point. Nearly all commands use the point as a indication of what text to examine or modify. Textual positions in Hemlock are between characters. This may seem a bit curious at first, but it is necessary since text must be inserted between characters. Although the point points between characters, it is sometimes said to point at a character, in which case the character after the point is referred to.

The cursor is the visible indication of the current focus of attention: a rectangular blotch under X windows, or the hardware cursor on a terminal. The cursor is usually displayed on the character which is immediately after the point, but it may be displayed in other places. Wherever the cursor is displayed it indicates the current focus of attention. When input is being prompted for in the echo area, the cursor is displayed where the input is to go. Under X windows the cursor is only displayed when Hemlock is waiting for input.

1.2 Notation

There are a number of notational conventions used in this manual which need some explanation.

1.2.1 Key-events

The canonical representation of editor input is a key-event. When you type on the keyboard, Hemlock receives key-events. Key-events have names for their basic form, and we refer to this name as a keysym. This manual displays keysyms in a Bold font. For example, a and b are the keys that normally cause the editor to insert the characters a and b.

Key-events have modifiers or bits indicating a special interpretation of the root key-event. Although the keyboard places limitations on what key-events you can actually type, Hemlock understands arbitrary combinations of the following modifiers: Control, Meta, Super, Hyper, Shift, and Lock. This manual represents the bits in a key-event by prefixing the keysym with combinations of C-, M-, S-, H-, Shift-, and Lock. For example, awith both the control and meta bits set appears as C-M-a. In general, ignore the shift and lock modifiers since this manual never talks about keysyms that explicitly have these bits set; that is, it may talk about the key-event A, but it would never mention Shift-a. These are actually distinct key-events, but typical input coercion turns presents Hemlock with the former, not the latter.

Key-event modifiers are totally independent of the keysym. This may be new to you if you are used to thinking in terms of ASCII character codes. For example, with key-events you can distinctly identify both uppercase and lowercase keysyms with the control bit set; therefore, C-a and C-A may have different meanings to Hemlock.

Some keysyms’ names consist of more than a single character, and these usually correspond to the legend on the keyboard. For example, some keyboards let you enter Home, Return, F9, etc.

In addition to a keyboard, you may have a mouse or pointer device. Key-events also represent this kind of input. For example, the down and up transitions of the left button correspond to the Leftdown and Leftup keysyms.

See sections 1.3.1, 1.7, 1.8

1.2.2 Commands

Nearly everything that can be done inHemlockis done using a command. Since there are many things worth doing, Hemlockprovides many commands, currently nearly two hundred. Most of this manual is a description of what commands exist, how they are invoked, and what they do. This is the format of a command’s documentation:

Sample Command (bound to C-M-q, C-‘) [Command]

This command’s name is Sample Command, and it is bound to C-M-q and C-‘, meaning that typing either of these will invoke it. After this header comes a description of what the command does:

This command replaces all occurrences following the point of the string "Pascal" with the string "Lisp". If a prefix argument is supplied, then it is interpreted as the maximum number of occurrences to replace. If the prefix argument is negative then the replacements are done backwards from the point.

1.2.3 Hemlock Variables

Hemlock variables supply a simple customization mechanism by permitting commands to be parameterized. For

details see page 118. Sample Variable (initial value36) [Hemlock Variable]

The name of this variable is Sample Variable and its initial value is 36.

This variable sets a lower limit on the number of replacements that be done by Sample Command. If the prefix argument is supplied, and smaller in absolute value than Sample Variable, then the user is prompted as to whether that small a number of occurrences should be replaced, so as to avoid a possibly disastrous error.

Invoking Commands

In order to get a command to do its thing, it must be invoked. The user can do this two ways, by typing thekeyto which the command is bound or by using an extended command. Commonly used commands are invoked via their key bindings since they are faster to type, while less used commands are invoked as extended commands since they are easier to remember.

1.3.1 Key Bindings

A key is a sequence of key-events (see section 1.2.1) typed on the keyboard, usually only one or two in length. Sections 1.7 and 1.8 contain information on particular input devices.

When a command is bound to a key, typing the key causes Hemlock to invoke the command. When the command completes its job, Hemlock returns to reading another key, and this continually repeats.

Some commands read key-events interpreting them however each command desires. When commands do this, key bindings have no effect, but you can usually abort Hemlock whenever it is waiting for input by typing C-g (see section 1.12). You can usually find out what options are available by typing C-_ or Home (see section 1.10).

The user can easily rebind keys to different commands, bind new keys to commands, or establish bindings for commands never bound before (see section 13.2).

In addition to the key bindings explicitly listed with each command, there are some implicit bindings created by using key translations . These bindings are not displayed by documentation commands such as Where Is. By default, there are only a few key translations. The modifier-prefix characters C-, Escape, C-z, or C-c may be used when typing keys to convert the following key-event to a control, meta, control-meta, or hyper key-event. For example, C-x Escape b invokes the same commands as C-x M-b, and C-z u is the same as C-M-u. This allows user to type more interesting keys on limited keyboards that lack control, meta, and hyper keys.

Key Echo Delay (initial value1.0) [Hemlock Variable]

A key binding may be composed of several key-events, especially when you enter it using modifier-prefix key-events. Hemlock provides feedback for partially entered keys by displaying the typed key-events in the echo area. In order to avoid excessive output and clearing of the echo area, this display is delayed by Key Echo Delay seconds. If this variable is set to nil, then Hemlock foregoes displaying initial subsequences of keys.

1.3.2 Extended Commands

A command is invoked as an extended command by typing its name to the Extended Command command, which is invoked using its key binding, M-x.

Extended Command (bound to M-x) [Command]

This command prompts in the echo area for the name of a command, and then invokes that command. The prefix argument is passed through to the command invoked. The command name need not be typed out in full, as long as enough of its name is supplied to uniquely identify it. Completion is available using Escape and Space, and a list of possible completions is given by Home or C-_.

1.4 The Prefix Argument

The prefix argument is an integer argument which may be supplied to a command. It is known as the prefix argument because it is specified by invoking some prefix argument setting command immediately before the command to be given the argument. The following statements about the interpretation of the prefix argument are true:

  • When it is meaningful, most commands interpret the prefix argument as a repeat count, causing the same effect as invoking the command that many times.
  • When it is meaningful, most commands that use the prefix argument interpret a negative prefix argument as meaning the same thing as a positive argument, but the action is done in the opposite direction.
  • Most commands treat the absence of a prefix argument as meaning the same thing as a prefix argument of one.
  • Many commands ignore the prefix argument entirely.
  • Some commands do none of the above.

The following commands are used to set the prefix argument:

Argument Digit (bound to all control or meta digits) [Command]

Typing a number using this command sets the prefix argument to that number, for example, typing M-1 M-2 sets the prefix argument to twelve.

Negative Argument (bound to M--) [Command]

This command negates the prefix argument, or if there is none, sets it to negative one. For example, typing M-- M-7sets the prefix argument to negative seven.

Universal Argument (bound to C-u) [Command]

Universal Argument Default (initial value 4) [Hemlock Variable]

This command sets the prefix argument or multiplies it by four. If digits are typed immediately afterward, they are echoed in the echo area, and the prefix argument is set to the specified number. If no digits are typed then the prefix argument is multiplied by four. C-u - 7 sets the prefix argument to negative seven. C-u C-u sets the prefix argument to sixteen. M-4 M-2 C-u sets the prefix argument to one hundred and sixty-eight. C-u M-0 sets the prefix argument to forty.

Universal Argument Default determines the default value and multiplier for the Universal Argument command.

1.5 Modes

A mode provides a way to change Hemlock ’s behavior by specifying a modification to current key bindings, values of variables, and other things. Modes are typically used to adjust Hemlock to suit a particular editing task, e.g. Lispmode is used for editing LISP code. Modes in Hemlock are not like modes in most text editors; Hemlock is really a "modeless" editor. There are two ways that the Hemlock mode concept differs from the conventional one:

  1. Modes do not usually alter the environment in a very big way, i.e. replace the set of commands bound

with another totally disjoint one. When a mode redefines what a key does, it is usually redefined to have a slightly different meaning, rather than a totally different one. For this reason, typing a given key does pretty much the same thing no matter what modes are in effect. This property is the distinguishing characteristic of a modeless editor.

  1. Once the modes appropriate for editing a given file have been chosen, they are seldom, if ever,

changed. One of the advantages of modeless editors is that time is not wasted changing modes.

A major mode is used to make some big change in the editing environment. Language modes such as Pascal mode are major modes. A major mode is usually turned on by invoking the command mode-name Mode as an extended command. There is only one major mode present at a time. Turning on a major mode turns off the one that is currently in effect.

A minor mode is used to make a small change in the environment, such as automatically breaking lines if they get too long. Unlike major modes, any number of minor modes may be present at once. Ideally minor modes should do the "right thing" no matter what major and minor modes are in effect, but this is may not be the case when key bindings conflict.

Modes can be envisioned as switches, the major mode corresponding to one big switch which is thrown into the correct position for the type of editing being done, and each minor mode corresponding to an on-off switch which controls whether a certain characteristic is present.

Fundamental Mode [Command] This command puts the current buffer into Fundamental mode. Fundamental mode is the most basic major mode: it’s the next best thing to no mode at all.

1.6. Display Conventions

There are two ways that Hemlock displays information on the screen; one is normal buffer display, in which the text being edited is shown on the screen, and the other is a pop-up window.

1.6.1. Pop-Up Windows

Some commands print out information that is of little permanent value, and these commands use a pop-up window to display the information. It is known as a pop-up window because it temporarily appears on the screen overlaying text already displayed. Most commands of this nature can generate their output quickly, but in case there is a lot of output, or the user wants to repeatedly refer to the same output while editing, Hemlock saves the output in a buffer. Different commands may use different buffers to save their output, and we refer to these as random typeout buffers.

If the amount of output exceeds the size of the pop-up window, Hemlock displays the message "--More--" after each window full. The following are valid responses to this prompt:

Space,y Display the next window full of text. Delete,Backspace,n Abort any further output. Escape,! Remove the window and continue saving any further output in the buffer. k This is the same as ! or escape, but Hemlock makes a normal window over the pop-up window. This only works on bitmap devices.

Any other input causes the system to abort using the key-event to determine the next command to execute. When the output is complete, Hemlock displays the string "--Flush--" in the pop-up window’s modeline, indicating that the user may flush the temporary display. Typing any of the key-events described above removes the pop-up window, but typingkstill produces a window suitable for normal editing. Any other input also flushes the display, but Hemlock uses the key-event to determine the next command to invoke. Select Random Typeout Buffer (bound to H-t) [Command]

This command makes the most recently used random typeout buffer the current buffer in the current window. Random typeout buffers are always in Fundamental mode.

1.6.2. Buffer Display

If a line of text is too long to fit within the screen width it is wrapped, with Hemlock displaying consecutive pieces of the text line on as many screen lines as needed to hold the text. Hemlock indicates a wrapped line by placing a line-wrap character in the last column of each screen line. Currently, the line-wrap character is an exclamation point (!). It is possible for a line to wrap off the bottom of the screen or on to the top.

Hemlock wraps screen lines when the line is completely full regardless of the line-wrap character. Most editors insert the line-wrap character and wrap a single character when a screen line would be full if the editor had avoided wrapping the line. In this situation, Hemlock would leave the screen line full. This means there are always at least two characters on the next screen line if Hemlock wraps a line of display. When the cursor is at the end of a line which is the full width of the screen, it is displayed in the last column, since it cannot be displayed off the edge.

Hemlock displays most characters as themselves, but it treats some specially:

  • Tabs are treated as tabs, with eight character tab-stops.
  • Characters corresponding to ASCII control characters are printed as ^char; for example, a formfeed is ^L.
  • Characters with the most-significant bit on are displayed as <hex-code>; for example, <E2>. Since a character may be displayed using more than one printing character, there are some positions on the screen which are in the middle of a character. When the cursor is on a character with a multiple-character representation, Hemlock always displays the cursor on the first character.

1.6.3. Recentering Windows

When redisplaying the current window, Hemlock makes sure the current point is visible. This is the behavior you see when you are entering text near the bottom of the window, and suddenly redisplay shifts your position to the window’s center.

Some buffers receive input from streams and other processes, and you might have windows displaying these. However, if those windows are not the current window, the output will run off the bottom of the windows, and you won’t be able to see the output as it appears in the buffers. You can change to a window in which you want to track output and invoke the following command to remedy this situation.

Track Buffer Point [Command]

This command makes the current window track the buffer’s point. This means that each time Hemlock redisplays, it will make sure the buffer’s point is visible in the window. This is useful for windows that are not current and that display buffer’s that receive output from streams coming from other processes.

1.6.4. Modelines

A modeline is the line displayed at the bottom of each window where Hemlock shows information about the buffer displayed in that window. Here is a typical modeline:

 Hemlock  USER: (Fundamental Fill)  /usr/slisp/ Hemlock /user.mss 

This tells us that the file associated with this buffer is "/usr/slisp/Hemlock/user.mss", and the Current Package for Lisp interaction commands is the "USER" package. The modes currently present are Fundamental and Fill; the major mode is always displayed first, followed by any minor modes. If the buffer has no associated file, then the buffer name will be present instead:

 Hemlock  PLAY: (Lisp)  Silly: 

In this case, the buffer is named Silly and is in Lisp mode. The user has set Current Package for this buffer to "PLAY".

Maximum Modeline Pathname Length (initial value nil) [Hemlock Variable]

This variable controls how much of a pathname Hemlock displays in a modeline. Some distributed file systems can have very long pathnames which leads to the more particular information in a pathname running off the end of a modeline. When set, the system chops off leading directories until the name is less than the integer value of this variable. Three dots, ..., indicate a truncated name. The user can establish this variable buffer locally with the Defhvar command.

If the user has modified the buffer since the last time it was read from or save to a file, then the modeline contains an asterisk (*) between the modes list and the file or buffer name:

 Hemlock  USER: (Fundamental Fill)  * /usr/slisp/ Hemlock /user.mss 

This serves as a reminder that the buffer should be saved eventually.

There is a special modeline known as the status line which appears as the Echo Area’s modeline. Hemlock and user code use this area to display general information not particular to a buffer — recursive edits, whether you just received mail, etc.

1.7. Use with X Windows

Left out.

1.8. Use With Terminals

Left out.

1.9 The Echo Area

The echo area is the region which occupies the bottom few lines on the screen. It is used for two purposes: displaying brief messages to the user and prompting.

When a command needs some information from the user, it requests it by displaying aprompt in the echo area. The following is a typical prompt:

Select Buffer: [ Hemlock -init.lisp /usr/foo/] 

The general format of a prompt is a one or two word description of the input requested, possibly followed by a default in brackets. The default is a standard response to the prompt that Hemlock uses if you type Return without giving any other input.

There are four general kinds of prompts: key-event The response is a single key-event and no confirming Return is needed.

keyword The response is a selection from one of a limited number of choices. Completion is available using Space and Escape, and you only need to supply enough of the keyword to distinguish it from any other choice. In some cases a keyword prompt accepts unknown input, indicating the prompter should create a new entry. If this is the case, then you must enter the keyword fully specified or completed using Escape; this distinguishes entering an old keyword from making a new keyword which is a prefix of an old one since the system completes partial input automatically.

file The response is the name of a file, which may have to exist. Unlike other prompts, the default has some effect even after the user supplies some input: the system merges the default with the input filename. See page 33 for a description of filename merging. Escape and Space complete the input for a file parse.

string The response is a string which must satisfy some property, such as being the name of an existing file.

These key-events have special meanings when prompting:

Return Confirm the current parse. If no input has been entered, then use the default. If for some reason the input is unacceptable, Hemlock does two things:

  1. beeps, if the variableBeep on Ambiguityset, and
  2. moves the point to the end of the first word requiring disambiguation.

This allows you to add to the input before confirming the it again.

Home, C-_ Print some sort of help message. If the parse is a keyword parse, then print all the possible completions of the current input in a pop-up window.

Escape Attempt to complete the input to a keyword or file parse as far as possible, beeping if the result is ambiguous. When the result is ambiguous, Hemlock moves the point to the first ambiguous field, which may be the end of the completed input.

Space In a keyword parse, attempt to complete the input up to the next space. This is useful for completing the names of Hemlock commands and similar things without beeping a lot, and you can continue entering fields while leaving previous fields ambiguous. For example, you can invoke Forward Word as an extended command by typing M-X f Space w Return. Each time the user enters space, Hemlock attempts to complete the current field and all previous fields.

C-i, Tab In a string or keyword parse, insert the default so that it may be edited.

C-p Retrieve the text of the last string input from a history of echo area inputs. Repeating this

moves to successively earlier inputs.

C-n Go the other way in the echo area history.

C-q Quote the next key-event so that it is not interpreted as a command.

Ignore File Types [ Hemlock Variable]

This variable is a list of file types (or extensions), represented as a string without the dot, e.g. "fasl". Files having any of the specified types will be considered nonexistent for completion purposes, making an unambiguous completion more likely. The initial value contains most common binary and output file types.

1.10 Online Help

Hemlock has a fairly good online documentation facility. You can get brief documentation for every command, variable, character attribute, and key by typing a key.

Help(bound toHome, C-_) [Command]

This command prompt for a key-event indicating one of a number of other documentation commands. The following are valid responses: a List commands and other things whose names contain a specified keyword.

d Give the documentation and bindings for a specified command.

g Give the documentation for any Hemlock thing.

v Give the documentation for a Hemlock variable and its values.

c Give the documentation for a command bound to some key.

l List the last sixty key-events typed.

m Give the documentation for a mode followed by a short description of its mode-specific bindings.

p Give the documentation and bindings for commands that have at least one binding involving a mouse/pointer key-event.

w List all the key bindings for a specified command.

t Describe a LISPobject.

q Quit without doing anything.

Home, C-_, ?, h List all of the options and what they do.

Apropos (bound to Home a, C-_ a) [Command]

This command prints brief documentation for all commands, variables, and character attributes whose names match the input. This performs a prefix match on each supplied word separately, intersecting the names in each word’s result. For example, giving Apropos"f m" causes it to tersely describe following commands and variables:

  • Auto Fill Mode
  • Fundamental Mode
  • Mark Form *Default Modeline Fields
  • Fill Mode Hook
  • Fundamental Mode Hook

Notice Mark Form demonstrates that the "f" words may follow the "m" order of the fields does not matter for Apropos.

The bindings of commands and values of variables are printed with the documentation.

Describe Command (bound to Home d, C-_ d) [Command]

This command prompts for a command and prints its full documentation and all the keys bound to it.

Describe Key (bound to Home c, C-_ c, M-?) [Command]

This command prints full documentation for the command which is bound to the specified key in the current environment.

Describe Mode (bound to Home m, C-_ m) [Command]

This command prints the documentation for a mode followed by a short description of each of its mode-specific bindings.

Show Variable [Command]

Describe and Show Variable [Command]

Show Variabl eprompts for the name of a variable and displays the global value of the variable, the value local to the current buffer (if any), and the value of the variable in all defined modes that have it as a local variable. Describe and Show Variable displays the variable’s documentation in addition to the values.

What Lossage (bound to Home l, C-_ l) [Command]

This command displays the last sixty key-events typed. This can be useful if, for example, you are curious what the command was that you typed by accident.

Describe Pointer [Command]

This command displays the documentation and bindings for commands that have some binding involving a mouse/pointer key-event. It will not show the documentation for theIllegal command regardless of whether it has a pointer binding.

Where Is (bound toHome w, C-_ w) [Command] This command prompts for the name of a command and displays its key bindings in a pop-up window. If a key binding is not global, the environment in which it is available is displayed.

Generic Describe (bound toHome g, C-_ g) [Command]

This command prints full documentation for any thing that has documentation. It first prompts for the kind of thing to document, the following options being available:

attribute Describe a character attribute, given its name.

command Describe a command, given its name.

key Describe a command, given a key to which it is bound.

variable Describe a variable, given its name. This is the default.

1.11 Entering and Exiting

Hemlock is entered by using the COMMON LISP ed function. Simply typing (ed )will enter Hemlock , leaving

you in the state that you were in when you left it. If Hemlock has never been entered before then the current buffer will be Main. The -edit command-line switch may also be used to enter Hemlock: see page 82. ed may optionally be given a file name or a symbol argument. Typing (ed filename) will cause the specified file to be read into Hemlock , as though by Find File. Typing (ed symbol) will pretty-print the definition of the symbol into a buffer whose name is obtained by adding "Edit " to the beginning of the symbol’s name.

Exit Hemlock (bound to C-c, C-x C-z) [Command]

Pause Hemlock [Command]

Exit Hemlock exits Hemlock , returning t. Exit Hemlock does not by default save modified buffers, or do anything else that you might think it should do; it simply exits. At any time after exiting you may reenter by typing (ed) to LISP without losing anything. Before you quit from LISP using (quit), you should save any modified files that you want to be saved.

Pause Hemlock is similar, but it suspends the LISP process and returns control to the shell. When the process is resumed, it will still be running Hemlock.

1.12 Helpful Information

This section contains assorted helpful information which may be useful in staying out of trouble or getting out of trouble.

  • It is possible to get some sort of help nearly everywhere by typing Home or C-_.
  • Various commands take over the keyboard and insist that you type the key-events that they want as

input. If you get in such a situation and want to get out, you can usually do so by typing C-g some small number of times. If this fails you can try typing C-x C-z to exit Hemlock and then "(ed)" to re-enter it.

  • Before you quit, make sure you have saved all your changes. C-u C-x C-b will display a list of all

modified buffers. If you exit using C-x M-z, then Hemlock will save all modified buffers with associated files.

  • If you lose changes to a file due to a crash or accidental failure to save, look for backup ("file.BAK") or

checkpoint ("file.CKP") files in the same directory where the file was.

  • If the screen changes unexpectedly, you may have accidentally typed an incorrect command. Use

Home lto see what it was. If you are not familiar with the command, useHome cto see what it is so that you know what damage has been done. Many interesting commands can be found in this fashion. This is an example of the much-underrated learning technique known as "Learning by serendipitous malcoordination". Who would ever think of looking for a command that deletes all files in the current directory?

  • If you accidentally type a "killing" command such as C-w, you can get the lost text back using C-y.

The Undo command is also useful for recovering from this sort of problem.

Region Query Size(initial value 30) [ Hemlock Variable]

Various commands ask for confirmation before modifying a region containing more than this number of lines. If this is nil, then these commands refrain from asking, no matter how large the region is.

Undo [Command]

This command undoes the last major modification. Killing commands and some other commands save information about their modifications, so accidental uses may be retracted. This command displays the name of the operation to be undone and asks for confirmation. If the affected text has been modified between the invocations of Undoand the command to be undone, then the result may be somewhat incorrect but useful. Often Undo itself can be undone by invoking it again.

1.13 Recursive Edits

Some sophisticated commands, such as Query Replace, can place you in a recursive edit. A recursive edit is simply a recursive invocation of Hemlock done within a command. A recursive edit is useful because it allows arbitrary editing to be done during the execution of a command without losing any state that the command might have. When the user exits a recursive edit, the command that entered it proceeds as though nothing happened. Hemlock notes recursive edits in theEcho Areamodeline, or status line. A counter reflects the number of pending recursive edits.

Exit Recursive Edit (bound to C-M-z) [Command]

This command exits the current recursive edit, returningnil. If invoked when not in a recursive edit, then this signals an user error.

Abort Recursive Edit (bound to C-]) [Command]

This command causes the command which invoked the recursive edit to get an error. If not in a recursive edit, this signals an user error.

1.14 User Errors

When in the course of editing, Hemlock is unable to do what it thinks you want to do, then it brings this to your attention by a beep or a screen flash (possibly accompanied by an explanatory echo area message such as "No next line.".) Although the exact attention-getting mechanism may vary on the output device and variable settings, this is always called beeping.

Whatever the circumstances, you had best try something else since Hemlock , being far more stupid than you, is far more stubborn. Hemlock is an extensible editor, so it is always possible to change the command that complained to do what you wanted it to do.

1.15 Internal Errors

A message of this form may appear in the echo area, accompanied by a beep:

Internal error: 
Wrong type argument, NIL, should have been of type SIMPLE-VECTOR. 

If the error message is a file related error such as the following, then you have probably done something illegal which Hemlock did not catch, but was detected by the file system:

Internal error: 
No access to "/lisp2/Emacs/teco.mid" 

Otherwise, you have found a bug. Try to avoid the behavior that resulted in the error and report the problem to your system maintainer. Since LISP has fairly robust error recovery mechanisms, probably no damage has been done.

If a truly abominable error from which Hemlock cannot recover occurs, then you will be thrown into the LISP debugger. At this point it would be a good idea to save any changes with save-all-buffers and then start a new LISP.

The LISP function save-all-buffers may be used to save modified buffers in a seriously broken Hemlock. To use this, type "(save-all-buffers)" to the top-level ("* ") or debugger ("1] ") prompt and confirm saving of each buffer that should be saved. Since this function will prompt in the "Lisp" window, it isn’t very useful when called inside of Hemlock.