(make-buffer-name NAME)
Construct a unique buffer-name from NAME.(make-buffer NAME)
Return a new buffer, it's name is the result of (make-buffer-name NAME).(destory-buffer BUFFER)
Throw away everything associated with buffer. All resident marks are made
non-resident.(get-file-buffer NAME)
Scan all buffers for one containing the file NAME.(get-buffer NAME)
Scan all buffers for one whose name is NAME.(current-buffer [WINDOW])
Return the buffer that WINDOW (or the current window) is displaying.(set-current-buffer BUFFER [WINDOW])
Set the buffer that WINDOW (or the current window) is displaying. Returns
the buffer which was being displayed before.(file-name [BUFFER])
Return the name of the file being edited in BUFFER.(set-file-name BUFFER NAME)
Set the name of the file being edited in BUFFER to NAME.(buffer-name [BUFFER])
Return the name of BUFFER.(set-buffer-name BUFFER NAME)
Set the name of BUFFER to NAME.(buffer-changes [BUFFER])
Return the number of modifications to BUFFER.(buffer-modified-p [BUFFER])
Returns t if the buffer has changed since it was last saved.(set-buffer-modified BUFFER STATUS)
If STATUS is nil make it look as though buffer hasn't changed, else make
it look as though it has.(set-buffer-special BUFFER SPECIALP)
When a buffer is `special' it means that it is controlled by some Lisp code,
not by the user typing into it (although this can still happen as well). This
is used for things like the `*jade*' or `*Info*' buffers (in fact most of
the buffers whose names are surrounded by asterisks are special).

What the `special' attribute actually does is make sure that the buffer is
never truely killed (`kill-buffer' removes it from each window's `buffer-list'
but doesn't detroy the actual contents) and modifications don't cause the
`+' marker to appear in the status line.(buffer-special-p [BUFFER])
Returns t if BUFFER is ``special''. See `set-buffer-special' for the meaning of
the ``special'' attribute.(set-buffer-read-only BUFFER READ-ONLY-P)
If a buffer is read-only no modification of its contents is allowed.(buffer-read-only-p [BUFFER])
Returns t if BUFFER is read-only. See `set-buffer-read-only'.(file-length [BUFFER])
Returns the number of lines in BUFFER.(line-length [LINE-POS] [BUFFER])
Returns the length (not including newline) of the specified line, or
using current cursor position if specifiers are not provided.(with-buffer BUFFER FORMS...) <SPECIAL-FORM>
Temporarily switches to buffer, then executes the FORMS in it before 
returning to the original buffer.(bufferp ARG)
Returns t if ARG is a buffer.The number of modifications which must be made to a buffer before it
is considered for auto-saving. A value of zero means that this buffer
is not to be auto-saved.Number of changes the last time this buffer was saved (could be auto-save).Number of changes the last time this buffer was saved (not from auto-save).System time at last save of this buffer (could be from an auto-save).Sets the size of tab-stops for the `left-tab' and `right-tab' commands.Sets the size of the tab-stops used when loading and saving files in this
buffer.Defines whether or not tab characters (ASCII 9) are used when saving files,
STATUS can be one of,
     nil     NO tabs are used, all spaces are left intact.
     leading All *leading* spaces in each line will be optimised into
	     tabs.
     all     All groups of spaces (except after any quotes) are changed
	     to tabs wherever possible.This is used to display the name of the edit-mode being used in the status
line.(make-mark [POS] [BUFFER | FILE-NAME])
Creates a new mark pointing to position POS either in the current file
or in FILE-NAME, or BUFFER.

Note that FILE-NAME doesn't have to be a file that has been loaded, it's
stored as a string, the file it points to is only opened when needed.

Unlike position objects, the position in a file that a mark points to is
updated as the file changes -- it will always point to the same character
(for as long as that character exists, anyway).(set-mark MARK [POS] [FILE-NAME | BUFFER])
Sets the position which MARK points to POS in FILE-NAME or BUFFER.(mark-pos MARK)
Returns the position that MARK points to. (note that this is the *same*
object that the mark stores internally -- so don't modify it unless you're
really sure you know what you're doing)(mark-file MARK)
Returns the file-name or buffer that MARK points to.(mark-resident-p MARK)
Returns t if the file that MARK points to is in a buffer.(markp ARG)
Return t if ARG is a mark.(prompt PROMPT [STRING])
Displays PROMPT and waits for the user to enter a string, which is
then returned. If STRING is provided it is used as the starting value
of the string.(split-line)
Splits the line into two at the cursor position, if the auto-indent option
is enabled the cursor will be placed at the same level of indentation as
the previous line.(insert STRING [POS] [BUFFER])
Inserts STRING into BUFFER at POS.(insert-rect STRING [POS] [BUFFER])
Inserts STRING into BUFFER at POS treating it as a ``rectangle'' of
text -- that is, each separate line in STRING (separated by newlines) is
inserted at the *same* column in successive lines.(delete-area START-POS END-POS [BUFFER])
Deletes from START-POS up to (but not including) END-POS.(delete-rect START-POS END-POS [BUFFER])
Deletes the rectangle of text from one corner, START-POS, to the opposite
corner, END-POS.(copy-area START-POS END-POS [BUFFER])
Returns the string from START-POS up to END-POS.(copy-rect START-POS END-POS [BUFFER])
Returns the rectangle of text marked out by START-POS and END-POS.(cut-area START-POS END-POS [BUFFER])
The same as `copy-area' except that the section of text copied (START-POS to
END-POS) is deleted from the file after being duplicated.(cut-rect START-POS END-POS [BUFFER])
The same as `copy-rect' except that the section of text copied (START-POS
to END-POS) is deleted from the file after being duplicated.(block-toggle)(block-start [POS])
Always returns the position of the block-start as it is, if POS is given
it is used as the new position of the start of the block.(block-end [POS])
Always returns the position of the block-end as it is, if POS is given
it is used as the new position of the end of the block.(block-kill)
Unmarks the block.(blockp)
Returns true if a block is currently marked.(translate-area START-POS END-POS TRANSLATION-TABLE [BUFFER])
Applies the TRANSLATION-TABLE to the text between START-POS and END-POS.
TRANSLATION-TABLE is a string, each character represents the translation
for an ascii character of that characters position in the string. If the
string is less than 256 chars long any undefined characters will remain
unchanged.(alpha-char-p CHAR)
Returns t if CHAR is an alphabetic character.(upper-case-p CHAR)
Returns t if CHAR is upper case.(lower-case-p CHAR)
Returns t if CHAR is lower case.(digit-char-p CHAR)
Returns t if CHAR is a digit.(alphanumericp CHAR)
Returns t if CHAR is alpha-numeric.(space-char-p CHAR)
Returns t if CHAR is whitespace.(char-upcase CHAR)
Returns the upper-case equivalent of CHAR.(char-downcase CHAR)
Returns the lower-case equivalent of CHAR.(pos-line POS)
Returns the line number which POS points to.(pos-col POS)
Return the column number which POS points to.(set-pos-line POS LINE)
Sets the line number of POS to LINE.(set-pos-col POS COL)
Sets the column number of POS to COL.(posp ARG)
Returns t if ARG is a position object.(cursor-pos)
Returns the position of the cursor in the current window.(empty-line-p [POS] [BUFFER])
Returns t if the line pointer to by POS (or the cursor) in BUFFER is
empty, ie, blank or only containing spaces.(indent-pos [POS] [BUFFER])
Returns the position of the first non-space character in the line pointer
to by POS (or the cursor), in BUFFER.(set-indent-pos POS [BUFFER])
Sets the indentation of the line pointed to by POS to the column pointed
to by POS by either deleting characters from the start of the line, or
inserting spaces.(clear-buffer [BUFFER])
Remove all text from BUFFER, leaving just one empty line.(find-next-regexp REGEXP [POS] [BUFFER] [IGNORE-CASE-P])
Scans forwards from POS (or the cursor), in BUFFER, looking for a match
with REGEXP. Returns the position of the next match or nil.

When IGNORE-CASE-P is non-nil the case of matched strings are ignored. Note
that character classes are still case-significant.(find-prev-regexp REGEXP [POS] [BUFFER] [IGNORE-CASE-P])
Scans backwards from POS (or the cursor), in BUFFER, looking for a match
with REGEXP. Returns the position of the next match or nil.

When IGNORE-CASE-P is non-nil the case of matched strings are ignored. Note
that character classes are still case-significant.(find-next-string STRING [POS] [BUFFER])
Scans forwards from POS (or the cursor), in BUFFER, looking for a match
with STRING. Returns the position of the next match or nil.(find-prev-string STRING [POS] [BUFFER])
Scans backwards from POS (or the cursor), in BUFFER, looking for a match
with STRING. Returns the position of the next match or nil.(find-next-char CHAR [POS] [BUFFER])
Scans forwards from POS (or the cursor), in BUFFER, looking for a match
with CHAR. Returns the position of the next match or nil.(find-prev-char CHAR [POS] [BUFFER])
Scans backwards from POS (or the cursor), in BUFFER, looking for a match
with CHAR. Returns the position of the next match or nil.(replace-regexp REGEXP TEMPLATE [POS] [BUFFER] [IGNORE-CASE-P])
If the text at POS or the cursor, matches REGEXP replace it with TEMPLATE,
this is a string that can have the following escape characters,
  \0, \&   whole string matched by REGEXP
  \N	   N'th parenthensized expression (1 <= N <= 9)

When IGNORE-CASE-P is non-nil the case of matched strings are ignored. Note
that character classes are still case-significant.(replace-string ORIGINAL NEW [POS] [BUFFER])
If the text at POS, or the cursor, matches ORIGINAL, replace it with the
string NEW.(regexp-expand REGEXP MATCHSTR TEMPLATE [IGNORE-CASE-P])
If REGEXP matches MATCHSTR then return the string made by expanding the
string TEMPLATE in a similar way to in the function `replace-regexp'.

When IGNORE-CASE-P is non-nil the case of matched strings are ignored. Note
that character classes are still case-significant.(regexp-match REGEXP STRING [IGNORE-CASE-P])
Return t if REGEXP matches STRING.

When IGNORE-CASE-P is non-nil the case of matched strings are ignored. Note
that character classes are still case-significant.(regexp-expand REGEXP TEMPLATE [POS] [BUFFER] [IGNORE-CASE-P])
If REGEXP matches the line at POS in BUFFER then return the string made
by expanding the string TEMPLATE in a similar way to in the function
`replace-regexp' and the variables `find-last-start-pos' and
`find-last-end-pos' are set to the start and end of the match.

When IGNORE-CASE-P is non-nil the case of matched strings are ignored. Note
that character classes are still case-significant.(regexp-match-line REGEXP [LINE-POS] [BUFFER] [IGNORE-CASE-P])
Attempts to match the regular-expression REGEXP to the line pointed to by
LINE-POS and BUFFER. If the match succeeds t is returned and the variables
`find-last-start-pos' and `find-last-end-pos' are set to the start and end
of the match.

When IGNORE-CASE-P is non-nil the case of matched strings are ignored. Note
that character classes are still case-significant.(looking-at REGEXP [POS] [BUFFER] [IGNORE-CASE-P])
Returns t if REGEXP matches the text at POS. Sets the `find-last-start-pos'
and `find-last-end-pos' appropriately. Only the text from POS to the end of
the line is matched against.The position of the start of the last match found by any of the find-*-*
functions.The position of the end of the last match found by any of the find-*-*
functions.(read-buffer FILE [BUFFER])
Overwrites the text in BUFFER with that from the file FILE.
FILE is either a string naming the file to be opened or a Lisp file object
(from `open') to be used.(write-buffer [FILE-NAME] [BUFFER])
Saves the contents of BUFFER to file FILE-NAME.(write-buffer-area START-POS END-POS [FILE-NAME] [BUFFER])
Writes the text between START-POS and END-POS in BUFFER to file
FILE-NAME.(cd [DIRECTORY])
If DIRECTORY is given set the editor's current directory to it, else
return the name of the current directory.(write-file FILE-NAME STRING)
Writes STRING to file FILE-NAME.(read-file FILE-NAME)
Return the contents of file FILE-NAME.(read-file-from-to FILENAME OFFSET CHAR)(write-clip UNIT STRING)
Writes STRING to unit UNIT of the standard clipboard.(read-clip UNIT)
Returns the string which unit UNIT of the clipboard holds.A list of keymaps (ie, keylists and/or keytables). When an event occurs
each keymap in the list is searched for an event binding which matches
it. These bindings are installed in a keymap by the function `bind-keys'.
See also `next-keymap-path'.When no event binding can be found for an event this hook is evaluated in
the standard manner (see the function `eval-hook' for details).(make-keytab)
Return a new key-table suitable for storing bindings in.(make-keylist)
Return a new key-list suitable for storing bindings in.(bind-keys KEY-MAP { KEY-DESCRIPTION FUNCTION }...)(unbind-keys KEY-MAP KEY-DESCRIPTION...)The value of `keymap-path' to be used for the *next* keypress. This is
usually used to chain together multi-key bindings.(eval FORM)
Evaluates FORM and returns its value.(funcall FUNCTION ARGS...)
Calls FUNCTION with arguments ARGS... and returns its result.(progn FORMS... ) <SPECIAL-FORM>
Eval's each of the FORMS in order returning the value of the last
one.(break)
The next form to be evaluated will be done so through the Lisp debugger.(step FORM)
Use the Lisp debugger to evaluate FORM.(macroexpand FORM [ENVIRONMENT])
If FORM is a macro call, expand it until it isn't. If ENVIRONMENT is
specified it is an alist of `(MACRO-NAME . DEFINITION)'.(get-doc-string INDEX)
Returns the document-string number INDEX.(add-doc-string STRING)
Appends STRING to the end of the doc-file and returns the index position of
it's first character (a number).When an error is signalled this variable controls whether or not to enter the
Lisp debugger immediately. If the variable's value is t or a list of symbols
- one of which is the signalled error symbol - the debugger is entered.
See `signal'.(signal ERROR-SYMBOL DATA)
Signal that an error has happened. ERROR-SYMBOL is the name of a symbol
classifying the type of error, it should have a property `error-message' (a
string) with a short description of the error message.
DATA is a list of objects which are relevant to the error -- they will
be made available to any error-handler or printed by the default error
-handler.(error-protect FORM HANDLERS...) <SPECIAL-FORM>
Evaluates FORM with error-handlers in place, if no errors occur return the
value returned by FORM, else the value of whichever handler's body was
evaluated.
Each HANDLER is a list looking like `(ERROR-SYMBOL BODY...)'. If an error
of type ERROR-SYMBOL occurs BODY is evaluated with the symbol `error-info'
temporarily set to `(ERROR-SYMBOL . DATA)' (these were the arguments given to
the `signal' which caused the error).(backtrace [STREAM])
Prints a backtrace of the current Lisp call stack to STREAM (or to
`standard-output').
The format is something like:
  FUNCTION (ARGLIST) ARGS-EVALLED-P
where ARGS-EVALLED-P is either `t' or `nil', depending on whether or not
ARGLIST had been evaluated or not before being put into the stack.The maximum number of times that eval and funcall can be called recursively.
This is intended to stop infinite recursion, if the default value of 250 is
too small (you get errors in normal use) set it to something larger.A list of directory names. When `load' opens a lisp-file it searches each
directory named in this list in turn until the file is found or the list
is exhausted.The name of the directory in which the standard lisp files live.(quote ARG) <SPECIAL-FORM>
'ARG
Returns ARG.(function ARG) <SPECIAL-FORM>
#'ARG
Normally the same as `quote'. When being compiled, if ARG is not a symbol
it causes ARG to be compiled as a lambda expression.(defmacro NAME LAMBDA-LIST [DOC-STRING] BODY...)
Defines a macro called NAME with argument spec. LAMBDA-LIST, documentation
DOC-STRING (optional) and body BODY. The actual function value is 
    `(macro lambda LAMBDA-LIST [DOC-STRING] BODY...)'
Macros are called with their arguments un-evaluated, they are expected to
return a form which will be executed to provide the result of the expression.

A pathetic example could be,
  (defmacro foo (x) (list 'cons nil x))
   => foo
  (foo 'bar)
   => (nil . bar)
This makes `(foo X)' a pseudonym for `(cons nil X)'.

Note that macros are expanded at *compile-time* (unless, of course, the Lisp
code has not been compiled).(defun NAME LAMBDA-LIST [DOC-STRING] BODY...)
Defines a function called NAME with argument specification LAMBDA-LIST,
documentation DOC-STRING (optional) and body BODY. The actual function
value is,
    `(lambda LAMBDA-LIST [DOC-STRING] BODY...)'(car CONS-CELL)
Returns the value stored in the car slot of CONS-CELL, or nil if CONS-CELL
is nil.(cdr CONS-CELL)
Returns the value stored in the cdr slot of CONS-CELL, or nil if CONS-CELL
is nil.(list ARGS...)
Returns a new list with members ARGS...(copy-list LIST)
Returns a new list which is identical to LIST except that the cons cells
which it is made from are different, all elements are shared however.(make-list LENGTH [INITIAL-VALUE])
Returns a new list with LENGTH members, each of which is initialised to
INITIAL-VALUE, or nil.(append LISTS...)
Non-destructively concatenates each of it's argument LISTS... into one
new list which is returned.(nconc LISTS... )
Destructively concatenates each of it's argument LISTS... into one new
list. Every LIST but the last is modified so that it's last cdr points
to the beginning of the next list. Returns the new list.(rplaca CONS-CELL NEW-CAR)
Sets the value of the car slot in CONS-CELL to NEW-CAR. Returns the new
value.(rplacd CONS-CELL NEW-CDR)
Sets the value of the cdr slot in CONS-CELL to NEW-CAR. Returns the new
value.(reverse LIST)
Returns a new list which is a copy of LIST except that the members are in
reverse order.(nreverse LIST)
Returns LIST altered so that it's members are in reverse order to what they
were. This function is destructive towards it's argument.(assoc ELT ASSOC-LIST)
Searches ASSOC-LIST for a list whose first element is ELT. `assoc' uses
`equal' to compare elements. Returns the sub-list starting from the first 
matching association.(assq ELT ASSOC-LIST)
Searches ASSOC-LIST for a list whose first element is ELT. `assq' uses `eq'
to compare elements. Returns the sub-list starting from the first matching
association.(nth INDEX LIST)
Returns the INDEXth element of LIST. The first element has an INDEX of zero.(nthcdr INDEX LIST)
Returns the INDEXth cdr of LIST. The first is INDEX zero.(last LIST)
Returns the last element of LIST.(mapcar FUNCTION LIST)
Calls FUNCTION-NAME with each element of LIST as an argument in turn and
returns a new list constructed from the results, ie,
  (mapcar (function (lambda (x) (1+ x))) '(1 2 3))
   => (2 3 4)(mapc FUNCTION LIST)
Applies FUNCTION to each element in LIST, discards the results.(member ELT LIST)
If ELT is a member of list LIST then return the tail of the list starting
from the matched ELT, ie,
  (member 1 '(2 1 3))
   => (1 3)
`member' uses `equal' to compare atoms.(memq ELT LIST)
If ELT is a member of list LIST then return the tail of the list starting
from the matched ELT, ie,
  (memq 1 '(2 1 3))
   => (1 3)
`memq' uses `eq' to compare atoms.(delete ELT LIST)
Returns LIST with any members `equal' to ELT destructively removed.(delq ELT LIST)
Returns LIST with any members `eq' to ELT destructively removed.(delete-if FUNCTION LIST)
Similar to `delete' except that a predicate function, FUNCTION-NAME, is
used to decide which elements to delete (remove destructively).
`delete-if' deletes an element if FUNCTION-NAME returns non-nil when 
applied to that element, ie,
  (delete-if '(lambda (x) (= x 1)) '(1 2 3 4 1 2))
   => (2 3 4 2)(delete-if-not FUNCTION LIST)
Similar to `delete' except that a predicate function, FUNCTION-NAME, is
used to decide which elements to delete (remove destructively).
`delete-if-not' deletes an element if FUNCTION-NAME returns nil when 
applied to that element, ie,
  (delete-if-not '(lambda (x) (= x 1)) '(1 2 3 4 1 2))
   => (1 1)(vector ARGS...)
Returns a new vector with ARGS... as its elements.(make-vector SIZE [INITIAL-VALUE])
Creates a new vector of size SIZE. If INITIAL-VALUE is provided each element
will be set to that value, else they will all be nil.(aset SEQUENCE INDEX NEW-VALUE)
Sets element number INDEX (a positive integer) of SEQUENCE (can be a list,
vector or string) to NEW-VALUE, returning NEW-VALUE. Note that strings
can only contain characters (ie, integers).(aref SEQUENCE INDEX)
Returns the INDEXth (a non-negative integer) element of SEQUENCE, which
can be a list, vector or string. INDEX starts at zero.(make-string LENGTH [INITIAL-VALUE])
Returns a new string of length LENGTH, each character is initialised to
INITIAL-VALUE, or to space if INITIAL-VALUE is not given.(concat ARGS...)
Concatenates all ARGS... into a single string, each argument can be a string,
a character or a list or vector of characters.(length SEQUENCE)
Returns the number of elements in SEQUENCE (a string, list or vector).(prog1 FORM1 FORMS... ) <SPECIAL-FORM>
First evals FORM1 then FORMS, returns the value that FORM1 gave.(prog2 FORM1 FORM2 FORMS...) <SPECIAL-FORM>
Evals FORM1 then FORM2 then the rest. Returns whatever FORM2 gave.(while CONDITION FORMS... ) <SPECIAL-FORM>
Eval CONDITION, if it is non-nil then execute FORMS and repeat the
procedure, else return nil.(if CONDITION THEN-FORM [ELSE-FORMS...] ) <SPECIAL-FORM>
Eval CONDITION, if it is non-nil then eval THEN-FORM and return it's 
result, else do an implicit progn with the ELSE-FORMS returning its value.(when CONDITION FORMS... ) <SPECIAL-FORM>
Evaluates CONDITION, if it is non-nil evaluates FORMS.(unless CONDITION FORMS... ) <SPECIAL-FORM>
Evaluates CONDITION, if it is nil evaluates FORMS.(cond (CONDITION FORMS... ) ... ) <SPECIAL-FORM>
Find the first CONDITION which has a value of t when eval'ed, then perform
a progn on its associated FORMS. If there are no FORMS with the CONDITION
then the value of the CONDITION is returned. If no CONDITION is t then
return nil.
An example,
  (cond
    ((stringp foo)
      (title "foo is a string"))
    ((numberp foo)
      (setq bar foo)
      (title "foo is a number"))
    (t
      (title "foo is something else...")))
Note the use of plain `t' on it's own for the last CONDITION, this is
like the last else in an else-if statement in C.(apply FUNCTION ARGS... ARG-LIST)
Calls FUNCTION passing all of ARGS to it as well as all elements in ARG-LIST.
ie,
  (apply '+ 1 2 3 '(4 5 6))
   => 21(load FILE [NO-ERROR-P] [NO-PATH-P] [NO-SUFFIX-P])
Attempt to open and then read-and-eval the file of Lisp code FILE.

For each directory named in the variable `load-path' tries the value of
FILE with `.jlc' (compiled-lisp) appended to it, then with `.jl' appended
to it, finally tries FILE without modification.

If NO-ERROR-P is non-nil no error is signalled if FILE can't be found.
If NO-PATH-P is non-nil the `load-path' variable is not used, just the value
of FILE.
If NO-SUFFIX-P is non-nil no suffixes are appended to FILE.

If the compiled version is older than it's source code, the source code is
loaded and a warning is displayed.(+ NUMBERS...)
Adds all NUMBERS together.(- NUMBER [NUMBERS...])
Either returns the negation of NUMBER or the value of NUMBER minus
NUMBERS(* NUMBERS...)
Multiplies all NUMBERS together(/ NUMBERS...)
Divides NUMBERS (in left-to-right order), ie,
  (/ 100 2
   => 10(mod NUMBERS...)
Applies the modulus operator between each of NUMBERS.(bit-not NUMBER)
Returns the bitwise not of NUMBER.(not ARG)
If ARG is nil returns t, else returns nil.(bit-or NUMBERS...)
Bitwise ORs all NUMBERS together.(or FORMS...) <SPECIAL-FORM>
Evals each FORM while they return nil, returns the first non-nil result or
nil if all FORMS return nil.(bit-and NUMBERS...)
Bitwise AND all NUMBERS together.(and FORMS... ) <SPECIAL-FORM>
Evals each FORM until one returns nil, it returns that value, or t if all
FORMS return t.(equal VALUE1 VALUE2)
Compares VALUE1 and VALUE2, compares the actual structure of the objects not
just whether the objects are one and the same. ie, will return t for two
strings built from the same characters in the same order even if the strings'
location in memory is different.(eq VALUE1 VALUE2)
Returns t if VALUE1 and VALUE2 are one and the same object. Note that
  (eq 1 1)
   => nil(string-head-eq STRING1 STRING2)
Returns t if STRING2 matches the beginning of STRING1, ie,
  (string-head-eq "foobar" "foo")
   => t
  (string-head-eq "foo" "foobar")
   => nil(= NUMBER1 NUMBER2)
Returns t if NUMBER1 and NUMBER2 are equal.(/= NUMBER1 NUMBER2)
Returns t if NUMBER1 and NUMBER2 are unequal.(> ARG1 ARG2)
Returns t if ARG1 is greater than ARG2. Note that this command isn't
limited to numbers, it can do strings, positions, marks, etc as well.(>= ARG1 ARG2)
Returns t if ARG1 is greater-or-equal than ARG2. Note that this command
isn't limited to numbers, it can do strings, positions, marks, etc as well.(< ARG1 ARG2)
Returns t if ARG1 is less than ARG2. Note that this command isn't limited to
numbers, it can do strings, positions, marks, etc as well.(<= ARG1 ARG2)
Returns t if ARG1 is less-or-equal than ARG2. Note that this command isn't
limited to numbers, it can do strings, positions, marks, etc as well.(1+ NUMBER)
Return NUMBER plus 1.(1- NUMBER)
Return NUMBER minus 1.(lsh NUMBER COUNT)
Shift the bits in NUMBER by COUNT bits to the left, a negative COUNT means
shift right.(zerop NUMBER)
t if NUMBER is zero.(null ARG)
Returns t if ARG is nil.(atom ARG)
Returns t if ARG is not a cons-cell.(consp ARG)
Returns t if ARG is a cons-cell.(listp ARG)
Returns t if ARG is a list, (either a cons-cell or nil).(numberp ARG)
Return t if ARG is a number.(stringp ARG)
Returns t is ARG is a string.(vectorp ARG)
Returns t if ARG is a vector.(functionp ARG)
Returns t if ARG is a function (ie, a symbol or a list whose car is the
symbol `lambda'(special-form-p ARG)
Returns t if ARG is a special-form.(keymapp ARG)
Returns t if ARG is a keytab or a keylist.(subr-p ARG)
Returns t if arg is a primitive function.(subr-documentation SUBR [USE-VAR])
Returns the doc-string associated with SUBR.(subr-name SUBR [USE-VAR])
Returns the name (a string) associated with SUBR.(eval-hook HOOK ARGS...)
Evaluate the hook, HOOK (a symbol), with arguments ARGS

The way hooks work is that the hook-symbol's value is a list of functions
to call. Each function in turn is called with ARGS until one returns non-nil,
this non-nil value is then the result of `eval-hook'. If all functions return
nil then `eval-hook' returns nil.(eval-hook2 HOOK ARG)
Similar to `eval-hook', the only reason this function exists is because it
is easier to call a 2-argument function from C than an N-argument function.(catch TAG FORMS...) <SPECIAL-FORM>
Evaluates FORMS, non-local exits are allowed with `(throw TAG)'.
The value of `catch' is either the value of the last FORM or the
value given to the throw command.

There are several pre-defined `catch'es which are,
  'defun
     Around all defuns, the `return' command uses this, it basically does
     (throw 'defun X).
  'exit
     Exits one level of recursive-editing (but doesn't work in the top
     level.
  'top-level
     At the top-level recursive-edit (ie, the one which you're in when
     the editor is started).
  'quit
     Kills the editor.(throw TAG VALUE)
Performs a non-local exit to the `catch' waiting for TAG and return
VALUE from it. TAG and VALUE are both evaluated fully.(return VALUE)
Arranges it so that the innermost defun returns VALUE as its result, this
is achieved by doing what amounts to `(throw 'defun VALUE)'.(unwind-protect BODY CLEANUP-FORMS...) <SPECIAL-FORM>
Eval and return the value of BODY guaranteeing that the CLEANUP-FORMS will
be evalled no matter what happens (ie, error, non-local exit, etc) while
BODY is being evaluated.(lisp-code CODE-STRING CONST-VEC MAX-STACK)
Evaluates the string of byte codes CODE-STRING, the constants that it
references are contained in the vector CONST-VEC. MAX-STACK is a number
defining how much stack space is required to evaluate the code.

Do *not* attempt to call this function manually, the lisp file `compiler.jl'
contains a simple compiler which translates files of lisp forms into files
of byte code. See the functions `compile-file', `compile-directory' and
`compile-lisp-lib' for more details.(recursive-edit)
Enter a new recursive-edit.(recursion-depth)
Returns the number of recursive-edit's deep we are, zero signifies the
original level.(input-lock [STATUS])
Sets or returns the status of the input lock. When this value is non-zero
no user input is accepted, only messages from ARexx can get through.(file-concat PARTS...)
Returns a string made from all the PARTS, each of which is one component of
a filename. Add's `/' characters between each PART if necessary.(system SHELL-COMMAND)
Tells the operating-system to execute SHELL-COMMAND, returns the exit code
of that command.(substr STRING START LENGTH)
Returns the portion of STRING starting at character number START for
LENGTH characters, a LENGTH of zero means all characters after START.(beep)
Rings a bell.(base-name FILE-NAME)
Returns the file part of FILE-NAME.(path-name FILE-NAME)
Returns the directory part of FILE-NAME.(balance-brackets OPEN-STRING CLOSE-STRING STRING)(strtoc STRING)
Returns the first character of STRING.(ctostr CHAR)
Returns a one-character string containing CHAR.(amiga-p)
t if running on an Amiga.(x11-p)
t if running on the X Window System V11.(unix-p)
t if running under some flavour of unix.(tmp-file-name)
Returns the name of a unique file.(make-completion-string EXISTING [POSSIBLE | POSIIBLE...])(current-time)
Return some number denoting the current system time.(current-time-string)
Returns a human-readable string defining the current date and time.(major-version-number)(minor-version-number)(getenv NAME)
Returns the value of environment variable NAME as a string, or nil if it is
undefined.(screen-top-line)
Returns the line number of the first line being shown in the current window.(screen-bottom-line)
Returns the line number of the last line being shown in the current window.(screen-first-column)
Returns the line number of the first column being shown in the current window.(screen-last-column)
Returns the line number of the last column being shown in the current window.(goto POS)
Set the cursor position in the current window to POS.(next-screen [NUMBER])
Move NUMBER (default: 1) screens forwards in the current window.(prev-screen [NUMBER])
Move NUMBER (default: 1) screens backwards in the current window.(file-end [BUFFER])
Return the position of the last character in BUFFER.(goto-file-end)
Move to the last character in the current window.(file-start)
Return the position of the start of the file.(goto-file-start)
Move to the first character in the buffer displayed in the current window.(line-end [POS] [BUFFER])
Return the position of the last character in the line pointed to by POS (or
the cursor).(goto-line-end)
Move to the last character in the line.(line-start [POS])
Return the position of the first character in the line pointed to by POS
(or the cursor).(goto-line-start)
Move to the start of the current line.(next-line [NUMBER] [POS])
Return the position of the NUMBERth (def: 1) line down from that pointed to
by POS (or the cursor). POS is altered.(goto-next-line [NUMBER])
Move NUMBER lines (def: 1) downwards.(prev-line [NUMBER] [POS])
Return the position of the NUMBERth (def: 1) line up from that pointed to
by POS (or the cursor). POS is altered.(goto-next-line [NUMBER])
Move NUMBER lines (def: 1) upwards.(left-char [NUMBER] [POS])
Return the position of the NUMBERth character (def: 1) to the left of the
one pointed to by POS (or the cursor). If that position is before the
beginning of the line, returns nil. POS is altered.(goto-left-char [NUMBER])
Move NUMBER chars (def: 1) to the left.(right-char [NUMBER] [POS])
Return the position of the NUMBERth character (def: 1) to the right of the
one pointed to by POS (or the cursor). Doesn't pay any attention to newlines.
POS is altered.(goto-right-char [NUMBER])
Move NUMBER chars (def: 1) to the right(prev-tab [NUMBER] [POS])
Return the position of the NUMBERth (def: 1) tab stop to the left of POS (or
the cursor). Returns nil if that position is past the beginning of the line.
POS is altered.(goto-prev-tab [NUMBER])
Move NUMBER (def: 1) tab stops to the left.(next-tab [NUMBER] [POS])
Return the position of the NUMBERth (def: 1) tab stop to the right of POS (or
the cursor). POS is altered.(goto-next-tab [NUMBER])
Move NUMBER (def: 1) tab stops to the right(next-char [POS])
Returns the position of the next character after POS (or the cursor).
Will move to the start of the next line after the end of the current line.
POS is altered.(goto-next-char)
Moves to the next character. Will move to the start of the next line after
the end of the current line.(prev-char [POS])
Returns the position of the character before POS (or the cursor). Will move
to the start of the next line after the end of the current line.
POS is altered.(goto-prev-char)
Moves to the previous character. Will move to the start of the next line
after the end of the current line.(match-brackets [POS] [BUFFER])
Find a bracket matching the one at POS (or the cursor). The things that match
each other are,  { }, ( ), [ ], ` ', < >. POS is altered.(mouse-pos)
Return the position of the mouse pointer, relative to the display origin of
the buffer in the current window.(cursor STATUS)
Turns cursor on or off, normally cursor is always off when an event is being
evaluated.(refresh-all)
Redraw anything that has been changed since the last refresh.(write STREAM DATA)
Writes DATA, which can either be a string or a character, to the stream
STREAM, returning the number of characters actually written.(read-char STREAM)
Reads the next character from the input-stream STREAM, if no more characters
are available returns nil.(read-line STREAM)
Read one line of text from STREAM.(copy-stream SOURCE-STREAM DEST-STREAM)
Copy all characters from SOURCE-STREAM to DEST-STREAM until an EOF is read.(read [STREAM])
Reads one lisp-object from the input-stream STREAM (or the value of the
variable `standard-input' if STREAM is unspecified) and return it.(print OBJECT [STREAM])
First outputs a newline, then prints a text representation of OBJECT to
STREAM (or the contents of the variable `standard-output') in a form suitable
for `read'.(prin1 OBJECT [STREAM])
Prints a text representation of OBJECT to STREAM (or the contents of the
variable `standard-output') in a form suitable for `read'.(princ OBJECT [STREAM])
Prints a text representation of OBJECT to STREAM (or the contents of the
variable standard-output), no strange characters are quoted and no quotes
are printed around strings.(format STREAM FORMAT-STRING ARGS... )
Writes a string created from the format specification FORMAT-STRING and
the argument-values ARGS to the stream, STREAM.
FORMAT-STRING is a template for the result, any `%' characters introduce
a substitution, using the next unused ARG. These format specifiers are
implemented:
   d	  print next ARG as decimal integer
   x	  print next ARG as hexadecimal integer
   c	  print next ARG as ASCII character
   s	  unquoted representation (as from `princ') of next ARG
   S	  normal print'ed representation of next ARG
   %	  literal percentage character

Returns STREAM.(open [FILE-NAME MODE-STRING] [FILE])
Opens a file called FILE-NAME with modes MODE-STRING (standard c-library
modes, ie `r' == read, `w' == write, etc). If FILE is given it is an
existing file object which is to be closed before opening the new file on it.(close FILE)
Kills any association between object FILE and the file in the filesystem that
it has open.(flush-file FILE)
Flushes any buffered output on FILE.(file-p ARG)
Returns t if ARG is a file object.(file-bound-p FILE)
Returns t if FILE is currently bound to a physical file.(file-binding FILE)
Returns the name of the physical file FILE is bound to, or nil.(file-eof-p FILE
Returns t when end of FILE is reached.(read-file-until FILE REGEXP [IGNORE-CASE-P])
Read lines from the Lisp file object FILE until one matching the regular
expression REGEXP is found. The matching line is returned, or nil if no
lines match.
If IGNORE-CASE-P is non-nil the regexp matching is not case-sensitive.(stdin-file)
Returns the file object representing the editor's standard input.(stdout-file)
Returns the file object representing the editor's standard output.(make-symbol NAME)
Returns a new, uninterned, symbol with print-name NAME. It's value and
function definition are both void and it has a nil property-list.(make-obarray SIZE)
Creates a new structure for storing symbols in. This is basically a vector
with a few slight differences (all pointers initialised to NULL).(find-symbol NAME [OBARRAY])
Returns the symbol with print-name NAME, found by searching OBARRAY (or
the default `obarray' if nil), or nil if no such symbol exists.(intern-symbol SYMBOL [OBARRAY])
Stores SYMBOL in OBARRAY (or the default). If SYMBOL has already been interned
somewhere an error is signalled.(intern NAME [OBARRAY])
If a symbol with print-name exists in OBARRAY (or the default) return it.
Else use `(make-symbol NAME)' to create a new symbol, intern that into the
OBARRAY, then return it.(unintern SYMBOL [OBARRAY])
Removes SYMBOL from OBARRAY (or the default). Use this with caution.(symbol-value SYMBOL)
Returns the value of SYMBOL, if SYMBOL is flagged as having buffer-local
values look for one of those first.(set SYMBOL VALUE)
Sets the value of SYMBOL to VALUE, if SYMBOL is flagged as having buffer-
local values then set that value. Returns VALUE.(setplist SYMBOL PROP-LIST)
Sets the property list of SYMBOL to PROP-LIST, returns PROP-LIST.(symbol-name SYMBOL)
Returns the print-name of SYMBOL.(symbol-function SYMBOL)
Returns the function value of SYMBOL.(fboundp SYMBOL)
Returns t if the function-slot of SYMBOL has a value.(boundp SYMBOL)
Returns t if SYMBOL has a value as a variable.(symbol-plist SYMBOL)
Returns the property-list of SYMBOL.(gensym)
Returns a new (non-interned) symbol with a unique print name.(symbolp ARG)
Returns t if ARG is a symbol.(setq { SYMBOL FORM }...) <SPECIAL-FORM>
Sets the value of each SYMBOL to the value of its corresponding FORM
evaluated, returns the value of the last evaluation. ie,
  (setq x 1 y (symbol-name 'nil))
   => "nil"
  x
   => 1
  y
   => "nil"(fset SYMBOL VALUE)
Sets the function value of SYMBOL to VALUE, returns VALUE.(makunbound SYMBOL)
Make SYMBOL have no value as a variable.(fmakunbound SYMBOL)
Make the function slot of SYMBOL have no value.(let (SYMBOL-BINDINGS...) BODY...) <SPECIAL-FORM>
Binds temporary values to symbols while BODY is being evaluated.
Each SYMBOL-BINDING is either a symbol, in which case that symbol is bound to
nil, or a list. The symbol at the head of this list is bound to the progn'ed
value of the forms making up the tail. ie,
  (let
      ((foo 1 2 3)
       bar)
    (cons foo bar))
   => (3 . nil)

All values of the new bindings are evaluated before any symbols are bound.(let* (SYMBOL-BINDINGS...) BODY...) <SPECIAL-FORM>
Binds temporary values to symbols while BODY is being evaluated.
Each SYMBOL-BINDING is either a symbol, in which case that symbol is bound to
nil, or a list. The symbol at the head of this list is bound to the progn'ed
value of the forms making up the tail. ie,
  (let*
      ((foo 1 2 3)
       bar)
    (cons foo bar))
   => (3 . nil)

The value of each binding is evaluated just before that symbol is bound,
this means that,
  (setq x 'foo)
  (let*
      ((x 10)
       (y x))
    (cons x y))
   => (10 . 10)(get SYMBOL PROPERTY)
Returns the value of SYMBOL's property PROPERTY. See `put'.(put SYMBOL PROPERTY VALUE)
Sets the value of SYMBOL's property PROPERTY to VALUE, this value can be
retrieved with the `get' function.(buffer-variables [BUFFER])
Returns a list of (SYMBOL . VALUE) bindings which take effect when the
current buffer is BUFFER.(window-variables [WINDOW])
Returns a list of (SYMBOL . VALUE) bindings which take effect when the
current window is WINDOW.(apropos REGEXP [PREDICATE] [OBARRAY])
Returns a list of symbols from OBARRAY (or the default) whose print-name
matches the regular-expression REGEXP. If PREDICATE is given and non-nil,
each symbol which matches is applied to the function PREDICATE, if the value
is non-nil it is considered a match.(set-buffer-variable SYMBOL)
Flags that SYMBOL might have a value local to each buffer.(buffer-variable-p SYMBOL)
Returns t if `set-buffer-variable' has been called on this symbol.(set-window-variable SYMBOL)
Flags that SYMBOL might have a value local to each window.(window-variable-p SYMBOL)
Returns t if `set-window-variable' has been called on this symbol.(set-const-variable SYMBOL)
Flags that the value of SYMBOL may not be changed.(const-variable-p SYMBOL)
Return t is `set-const-variable' has been called on SYMBOL.(trace SYMBOL)
Flag that whenever SYMBOL is evaluated (as a variable or a function) the
debugger is entered.(untrace SYMBOL)
Cancel the effect of (trace SYMBOL).(cons CAR-VALUE CDR-VALUE)
Returns a new cons-cell with car CAR-VALUE and cdr CDR-VALUE.(pos X Y)
Returns a new position object with coordinates (X , Y).(dup-pos POS)
Returns a new copy of POS.The number of bytes of storage which must be used before a garbage-
collection is triggered.The number of bytes of storage which must be used before a garbage-
collection is triggered when the editor is idle.(garbage-collect)
Scans all allocated storage for unusable data, and puts it onto the free-
list. This is done automatically when the amount of storage used since the
last garbage-collection is greater than `garbage-threshold'.(make-window [X] [Y] [WIDTH] [HEIGHT])
Return a new window, it will be displaying the same buffer as the currently
active window.(destroy-window [WINDOW])
Close WINDOW (or the current window), if this was the last one all files in
memory are flushed and jade will exit.(sleep-window [WINDOW])
Iconifies the current window.(unsleep-window [WINDOW])
Uniconifies the current window.(next-window [WINDOW] [ACTIVATE])
Cycles through the open windows forwards.(title STRING)
Temporarily sets the status display to STRING, this won't happen until the
window is next refreshed.(title STRING)
Immediately sets the status display to STRING.(font-name [WINDOW])
Returns the name of the font being used in this window.Maximum scroll distance (number of lines). If a set of lines has to be
scrolled further than this the whole window is redrawn.Controls the actual number of lines scrolled when the cursor moves out of
view. The number of lines to move the display origin is calcualted with the
formula:
  LINES_TO_SCROLL = TOTAL_LINES_IN_WINDOW / y-scroll-step-ratio
If the value is 0 then the window will be scrolled by one line.Controls the actual number of columns scrolled when the cursor moves out of
view. The number of lines to move the display origin is calcualted with the
formula:
  COLUMNS_TO_SCROLL = TOTAL_COLUMNS_IN_WINDOW / x-scroll-step-ratio
If the value is 0 then the window will be scrolled by one column.(rect-blocks-p [WINDOW])
Returns t if blocks marked in WINDOW (or the current one) are treated as
rectangles.(set-rect-blocks WINDOW STATUS)
Controls whether or not blocks are taken as contiguous regions of text or as
rectangles in WINDOW. When STATUS is t rectangles are used.(window-asleep-p)
Returns t if window is currently iconified.(window-count)
Number of opened windows.(position-window LEFT TOP WIDTH HEIGHT)
Sets the position and dimensions of the current window. These are all
*pixel* measurememnts.(current-window)
Returns the currently active window. Note that this is the editor's notion
of `current' -- it doesn't necessarily mean that this is the window to which
your window system will send input events to.(with-window WINDOW FORMS...) <SPECIAL-FORM>
Set the editor's current window to WINDOW and evaluate FORMS, then
reinstall the original window as the current one.(set-current-window WINDOW [ACTIVATE-P])
Sets the window which jade reguards as current.
If ACTIVATE-P is non-nil the window will be activated with respect to the
window-system (under X11 this means warping the pointer to the top left corner
of the window as well).(window-id [WINDOW])
Returns the identifier of the physical window that the Lisp window WINDOW
points to. This is window-system dependant, under X11 it will be some integer,
under Intuition a pointer (integer) to the window structure.(font-x-size [WINDOW])
Returns the width of the window's font (in pixels).(font-y-size [WINDOW])
Returns the height of the window's font (in pixels).(set-font FONT-NAME [WINDOW])
FONT-NAME specifies the font to use in WINDOW (or the active one).
Under X11 FONT-NAME is a standard font description, under AmigaDOS it is the
name of the font followed by a dash and then the point size to use (for
example "topaz.font-8" to get an 8-point topaz font).(screen-width)
Returns the width of the root window or screen in pixels.(screen-height)
Returns the height of the root window or screen in pixels.(window-left-edge)
Returns the x position of the current window relative to the origin of the
root window or screen.(window-top-edge)
Returns the y position of the current window relative to the origin of the
root window or screen.(window-width)
Returns the width, in pixels, of the current window.(window-height)
Returns the height, in pixels, of the current window.(window-bar-height)
On an Amiga returns the number of pixels high the title bar of the window
is. This is 0 in X11.(flush-output)
Forces any cached window output to be drawn. This is usually unnecessary.(delete-file FILE-NAME)
Attempts to delete the file called FILE-NAME.(rename-file SRC DEST)
Tries to rename the file SRC as DEST, this doesn't work across filesystems, or
if a file DEST already exists.(copy-file SRC DEST)
Copies the file called SRC to the file DEST.(file-readable-p FILE)
Returns t if FILE available for reading from.(file-writeable-p FILE)
Returns t if FILE available for writing to.(file-exists-p FILE)
Returns t if FILE exists.(file-regular-p FILE)
Returns t if FILE is a ``normal'' file, ie, not a directory, device, symbolic
link, etc...(file-directory-p FILE)
Returns t if FILE is a directory.(file-symlink-p FILE)
Returns t if FILE is a symbolic link to another file.(file-owner-p FILE)
Returns t if the ownership (uid & gid) of file FILE (a string) is the same
as that of any files written by the editor.(file-nlinks FILE)
Returns the number of links pointing to the file called FILE. This will be
one if FILE has only one name. Doesn't count symbolic links.(file-modes FILE)
Return the access permissions of the file called FILE, an integer. Note that
the format of this integer is not defined, it differs from system to system.(set-file-modes FILE MODES)
Sets the access permissions of FILE to MODES, an integer. The only real way
you can get this integer is from `file-modes' since it changes from system
to system.(file-modtime FILE)
Return the time (an integer) that FILE was last modified.(directory-files DIRECTORY)
Returns a list of the names of all files in directory DIRECTORY, directories
in DIRECTORY have a `/' character appended to their name.(user-login-name)
Returns the login name of the user (a string).
On the Amiga this is taken from the environment variable `USERNAME'.(user-full-name)
Returns the real name of the user (a string).
On the Amiga this is taken from the environment variable `REALNAME'.(user-home-directory)
Returns the user's home directory (a string). It will be terminated by a slash
(or whatever is appropriate) so that it can be glued together with a file name
making a valid path name.
On the Amiga this is taken from the environment variable `HOME'.(system-name)
Returns the name of the host which the editor is running on.
On the Amiga this is taken from the environment variable `HOSTNAME'.(make-process [OUTPUT-STREAM] [EXIT-FUNCTION]) <UNIX-ONLY>
Creates a new process-object, OUTPUT-STREAM is where all output from this
process goes, EXIT-FUNCTION is a function to call each time a process running
on this object exits.(fork-process PROCESS FILE-NAME ARGV) <UNIX-ONLY>
Starts a process running on process-object PROCESS. The child-process runs
asynchronously with the editor.

FILE-NAME is the filename of the binary image, it will be searched for in
all directories listed in the `PATH' environment variable.
ARGV is a vector of all arguments to give to the process (including
argument zero, normally the name of the process).(run-process PROCESS FILE-NAME ARGV) <UNIX-ONLY>
Starts a process running on process-object PROCESS. Waits for the child to
exit, then returns the exit-value of the child.

FILE-NAME is the filename of the binary image, it will be searched for in
all directories listed in the `PATH' environment variable.
ARGV is a vector of all arguments to give to the process (including
argument zero, normally the name of the process).(signal-process PROCESS SIGNAL) <UNIX-ONLY>
If PROCESS is running asynchronously (or has been, and the pty is still being
used by a child) then send signal number SIGNAL to all processes running under
PROCESS's pseudo-terminal (if the process-group of the pseudo-terminal is
unobtainable, send the signal to the process group with PROCESS as leader).(interrupt-process PROCESS) <UNIX-ONLY>
Do (signal-process PROCESS SIGINT) or equivalent.(kill-process PROCESS) <UNIX-ONLY>
Do (signal-process PROCESS SIGKILL) or equivalent.(stop-process PROCESS) <UNIX-ONLY>
Suspends execution of PROCESS, see `continue-process'.(continue-process PROCESS) <UNIX-ONLY>
Restarts PROCESS after it has been stopped (via `stop-process').(process-exit-status PROCESS) <UNIX-ONLY>
Returns the unprocessed exit-status of the last process to be run on the
process-object PROCESS. If PROCESS is currently running, return nil.(process-exit-value PROCESS) <UNIX-ONLY>
Returns the return-value of the last process to be run on PROCESS, or nil if:
  a) no process has run on PROCESS
  b) PROCESS is still running
  c) PROCESS exited abnormally(process-id PROCESS) <UNIX-ONLY>
If PROCESS is running, return the process-identifier associated with it
(ie, its pid).(process-running-p PROCESS) <UNIX-ONLY>
Return t if PROCESS is running.(process-stopped-p PROCESS) <UNIX-ONLY>
Return t if PROCESS has been stopped.(process-in-use-p PROCESS) <UNIX-ONLY>
Similar to `process-running-p' except that this returns t even when the
process has stopped, or has exited but the pty connected to `PROCESS' is still
in use.(process-p ARG) <UNIX-ONLY>
Return t is ARG is a process-object.(process-name PROCESS) <UNIX-ONLY>
Return the name of the program running on PROCESS.(process-argv PROCESS) <UNIX-ONLY>
Return the arguments of the process running on PROCESS.(process-output-stream PROCESS) <UNIX-ONLY>
Return the stream to which all output from PROCESS is sent.(set-process-output-stream PROCESS STREAM) <UNIX-ONLY>
Set the output-stream of PROCESS to STREAM.(process-exit-function PROCESS) <UNIX-ONLY>
Return the function which is called when PROCESS exits.(set-process-exit-function PROCESS FUNCTION) <UNIX-ONLY>
Set the function which is called when PROCESS exits to FUNCTION.(menu-status ENABLED-P [WINDOW]) <AMIGA-ONLY>
If ENABLED-P is non-nil the menu will be active in WINDOW, if WINDOW is not
specified, menus will be enabled in *all* windows. When a menu is not enabled
in a window right mouse button events will be detectable.

Note that for a menu to be displayed the `set-menu' command must be used first
to create a menu strip.(menu-enabled-p [WINDOW]) <AMIGA-ONLY>
Returns t if a menu is being displayed in WINDOW (or the current window).(set-menu MENUS...) <AMIGA-ONLY>
Creates a new menustrip, each window then has these menus.

Each MENU defines a single menu block, it has this format,

    (MENU-NAME MENU-ITEM...)

MENU-NAME is the name of the block, each MENU-ITEM defines a single menuitem,
they are either nil (empty menu item) or look like,

    (ITEM-NAME [SHORTCUT] FORMS...)

ITEM-NAME is the item name, SHORTCUT is an optional keyboard shortcut (a one
character long string) and FORMS are the forms which get evaluated when the
menu is picked.

The shortcuts may be upper or lower case. Menu shortcuts are only
considered to be case-significant when two shortcuts of the same letter (but
different case) are defined.(rexx-async-macro NAME) <AMIGA-ONLY>
Asynchronously invokes the ARexx macro called NAME.(rexx-async-str STRING) <AMIGA-ONLY>
Gets ARexx to asynchronously interpret the string of REXX code STRING.(rexx-sync-macro NAME) <AMIGA-ONLY>
Invokes the ARexx macro NAME synchronously, returning its value when it
exits (this will either be a number or a string.(rexx-sync-str STRING) <AMIGA-ONLY>
Synchronously executes the string of ARexx commands STRING, returning their
exit value.Variable holding the name of our ARexx port. (Amiga only).(file-req TITLE [FILE-NAME] [FOR-WRITING-P])
*AMIGA ONLY*
Displays a file requester (standard one from asl.library) asking for the name
of a file. FOR-WRITING-P should be non-nil if the file being requested for
will be written to. TITLE is the name of the requester. FILE-NAME is
the starting value for the filename.

If a filename is selected its name is returned (a string), else this
function returns nil.(req BODY GADGETS) <AMIGA-ONLY>
Function to do a request.
Result is number of gadget pressed (starting at 1 for leftmost gadget and
incrementing by one, rightmost gadget is 0.This variable controls the name of the public-screen which the window
opens onto. It is only available when running on an Amiga.(open-window [BUFFER] [X] [Y] [WIDTH] [HEIGHT])
Creates a new window display BUFFER or the buffer that the current window is
showing.(close-window [WIN])
Close window WIN, or the current window.(close-other-windows [WIN])
Close all windows except for WIN, or the current one.(add-buffer BUFFER)
Make sure that BUFFER is in the `buffer-list' of all open windows. It gets
put at the end of the list.(remove-buffer BUFFER)
Delete all references to BUFFER in any of the windows' `buffer-list'(in-other-window BODY...) <MACRO>
Switches to the ``other'' window and evaluates BODY in it.(goto-other-window)
Switch to the ``other'' window.(prompt2 COMP-FUNC [TITLE] [START] [WORD-REGEXPS])
Prompts for a string using completion. COMP-FUNC is a function which takes
one argument, the string which should be completed. It should return a list
of all matches. TITLE is the optional title to print in the buffer, START the
original contents of the buffer. WORD-REGEXPS is a vector of two regexps
corresponding to the values of `word-regexp' and `word-not-regexp' for the
completion mechanism.
The string entered is returned, or nil if the prompt is cancelled (by Ctrl-g).(get-mode NAME)
Scan the alist `mode-alist' for a mode whose regexp matches NAME,
returning the initialisation function of that mode (a symbol) or nil.(init-mode BUF [NAME])
Initialise an edit-mode for buffer BUF, either calls the function named
in the buffer-local variable `major-mode' or finds a mode in `mode-alist'
using one of the following to match against:
  1. NAME
  2. The value of the variable `mode-name'
  3. The word specified on the first line of the buffer surrounded by
     `-*-...-*-' (ie, -*-texinfo-*-)
  4. The name of the file being edited in the buffer(kill-mode [BUF])
Destroy the mode being used to edit buffer BUF with.(defvar NAME DEFAULT-VALUE [DOC-STRING]) <MACRO>
Define a variable called NAME whose standard initial-value is DEFAULT-
VALUE. If NAME is already bound to a value it is left as it is.(defconst NAME DEFAULT-VALUE [DOC-STRING]) <MACRO>
Define a constant NAME whose standard value is DEFAULT-VALUE.
If NAME is already bound to a value it is left untouched.(add-hook HOOK-SYMBOL FUNCTION-NAME [AT-END])
Arrange it so that FUNCTION-NAME is added to the hook-list stored in
symbol, HOOK-SYMBOL. It will added at the head of the list unless AT-END
is non-nil in which case it is added at the end.(remove-hook HOOK-SYMBOL FUNCTION-NAME)
Remove FUNCTION-NAME from the hook HOOK-SYMBOL.(documentation SYMBOL [IS-VARIABLE])
Returns the documentation-string for SYMBOL. If IS-VARIABLE is t the
documentation for the variable stored in SYMBOL is returned, else
the function doc is provided.(document-var SYMBOL DOC-STRING)
Sets the `variable-documentation' property of SYMBOL to DOC-STRING.(read-from-string STRING [START])
Reads an object from STRING, starting at character number START (default
is 0).(autoload SYMBOL FILE)
Tell the evaluator that the function value of SYMBOL will be initialised
when the FILE is loaded.(set-variable)
Prompts for a variable and a value to set it to.(show-variable)
Prompts for a variable and returns its value.List of arguments to next `command-prompt' function(add-command-arg [ARG])
Add ARG (will prompt if not given) to the list of arguments to be given to
the next command invoked by `command-prompt'.(clear-command-args)
Discard any arguments to be used by `command-prompt'.(command-prompt [TITLE])
Prompt for the name of a function then invoke it with the contents of
`command-arg-list' as arguments.Directory to search for info files if they can't be found as-is.(info [NODE-NAME])
Start the Info viewer. If NODE-NAME is given it specifies the node to
show, otherwise the current node is used (or `(dir)' if this is the first
time that `info' has been called).Regular expression which defines a character in a word.Regular expression which defines anything that is not in a word.Regular expression which matches a paragraph-separating piece of text.Mark which some commands use to track the previous cursor position.(forward-word [NUMBER] [POS])
Move to the first character after the end of this word.
NUMBER is the number of words to move, negative values mean go backwards.(backward-word [NUMBER] [POS])
Basically `(forward-word -NUMBER POS)'(in-word-p [POS])
Returns t if POS is inside a word.(mark-word [POS])
Marks the word at POS.(next-paragraph [POS] [BUFFER])
Returns the position of the start of the next paragraph.(prev-paragraph [POS] [BUFFER])
Returns the start of the previous paragraph.(mark-paragraph)
Set the block-marks to the current paragraph.(copy-block)
If a block is marked in the current window, return the text it contains and
unmark the block.(cut-block)
Similar to `copy-block' except the block is cut from the buffer.(delete-block)
Deletes the block marked in the current window (if one exists).(insert-block [POS])
If a block is marked in the current window, copy it to position POS, then
unmark the block.(upcase-area START-POS END-POS [BUFFER])
Makes all alpha characters in the specified region of text upper case.(downcase-area START-POS END-POS [BUFFER])
Makes all alpha characters in the specified region of text lower case.(upcase-block)
Makes all characters in the currently marked block upper case.(downcase-block)
Makes all characters in the currently marked block lower case.(upcase-word)
Makes the word under the cursor upper case.(downcase-word)
Makes the word under the cursor lower case.(mark-region)
Sets the block-marks to the are between the cursor position and the auto-mark(abort-recursive-edit [VALUE])
Exits the innermost recursive edit with a value of VALUE.(top-level)
Exit all recursive-edits.(disassemble-fun FUN [STREAM])
Disassembles the lisp-code form which is the function value of FUN. If
STREAM is given prints to that stream.When t any references to variables which are marked as being constant (ie,
by `defconst' or `set-constant-variable') are evaluated at compile time.When t all doc-strings are appended to the doc file and replaced with
their position in that file.(compile-file FILE-NAME)
Compiles the file of jade-lisp code FILE-NAME into a new file called
`(concat FILE-NAME ?c)' (ie, `foo.jl' => `foo.jlc').(compile-directory DIRECTORY-NAME [FORCE-P])
Compiles all jade-lisp files in the directory DIRECTORY-NAME whose object
files are either older than their source file or don't exist. If FORCE-P
is non-nil every lisp file is recompiled.(compile-lisp-lib [FORCE-P])
Recompile all out of date files in the lisp library directory. If FORCE-P
is non-nil it's as though all files were out of date.
This makes sure that all doc strings are written to their special file.List of (ERROR-POS-MARK . ERROR-DESC-LINE)Default command which `(compile)' executes, the value of the last
command executed by `(compile)'.Buffer-local symbol which contains the command to compile this buffer. If
nil or unbound use `compile-default-cmd'.(start-compile-command SHELL-COMMAND ERROR-TYPE-STR)
Executes SHELL-COMMAND asynchronously in the directory containing the file
being edited in the current buffer. Output from the process is sent to the
`*compilation*' buffer.(next-error)
Moves the cursor to the file and line of the next error displayed in the
`*compilation*' buffer.(grep [ARGS-STRING])
Runs the `grep' program with ARGS-STRING (or the result of a prompt) and
sends its output to the `*compilation*' buffer. The `grep' process may still
be executing when this function returns.Regular-expression which `grep-buffer' scans for(grep-buffer [REGEXP])
Scans the current buffer for all matches of REGEXP (or the contents of
variable `grep-buffer-regexp'). All hits are displayed in the `*compilation*'
buffer in a form that `goto-next-error' understands.Size of indentation for c-modeWhen t cursor is automatically indented when <return> is pressed in
c-mode.(c-mode)
Simple mode for editing C source code.(c-indent-pos [LINE-POS])
*Attempts* to guess the correct indentation for this line. Returns the
position for the first non-space in the line.(c-indent-pos-empty [LINE-POS])
Returns the position for the first non-space in the line. Bases its guess
upon the assumption that the line is empty.
All positions depend on the indentation of the previous line(s).When t files are auto-save'd regularly.The number of seconds between each auto-save.When non-nil backups of files are made when they are saved.When non-nil all file backups are made by copying the file, not by
renaming it.*AMIGA ONLY*
When non-nil the normal ASL file requester is used when file names are
prompted for.List of buffers in most-recently-used order. Each window has it's own.Stream that `prin?' writes its output to by defaultStream that `read' takes it's input from by defaultHolds the modification time of the file this buffer was loaded from(goto-buffer BUFFER)
Switch the current buffer to BUFFER which can either be a buffer-object
or a string naming an existing buffer. The selected buffer is moved to
the head of the buffer list.(open-file FILE-NAME)
If no buffer containing file FILE-NAME exits try to create one.
  After creating a new buffer (named after the file's (not path) name)
it first call the hook `read-file-hook' with arguments `(file-name buffer)'
If this hook returns nil (ie, no members of the hook decided to read the
file into memory) the file is read into the buffer verbatim.
  Once the file is in memory, through the hook or otherwise, this function
then tries to initialise the correct editing mode for the file.
  `open-file' always returns the buffer holding the file, or nil if it
doesn't exist.(find-file [FILE-NAME])
Sets the current buffer to that containing the file FILE-NAME, if FILE-NAME
is unspecified it will be prompted for. If the file is not already in memory
`open-file' will be used to load it.(find-file-read-only [FILE-NAME])
Similar to `find-file' except that the buffer is edited in read-only mode.(open-alternate-file FILE-NAME [BUFFER] )
Kills BUFFER and returns a buffer containing FILE-NAME (through the
`kill-buffer' and `open-file' functions).(find-alternate-file [FILE-NAME])
If FILE-NAME is unspecified one will be prompted for. The current buffer
is killed and one editing FILE-NAME is found.(write-file BUFFER [FILE-NAME] )
Writes the contents of BUFFER to the file FILE-NAME, or to the one
that it is associated with.(save-file [BUFFER])
Saves the buffer BUFFER, or the current buffer, to the file that it is
associated with, then sets the number of modifications made to this file
to zero.
Note: if no changes have been made to this buffer, it won't be saved.(save-file-as [FILE-NAME] [BUFFER])
Saves the buffer BUFFER, or the current one, to the file FILE-NAME,
resetting the name of the buffer and the file that it is associated with
to reflect FILE-NAME. Also sets the modification count to zero.(insert-file [FILE-NAME] [BUFFER])
Inserts the file FILE-NAME (may be prompted for) into the buffer BUFFER (or
the current one) before the cursor position.(open-buffer NAME)
If no buffer called NAME exists, creates one and adds it to the main
buffer-list. Always returns the buffer.(kill-buffer [BUFFER])
Destroys BUFFER (can be an actual buffer or name of a buffer), first
checks whether or not we're allowed to with the function `check-changes'.
  If it can be deleted, all windows displaying this buffer are switched
to the buffer at the head of the buffer-list, and BUFFER is removed
from the buffer-list (if it was in it).(rotate-buffers-forward)
Moves the buffer at the head of the buffer-list to be last in the list, the
new head of the buffer-list is displayed in the current window.(check-changes [BUFFER])
Returns t if it is ok to kill BUFFER, or the current buffer. If unsaved
changes have been made to it the user is asked whether (s)he minds losing
them.(goto-mark MARK)
Switches (if necessary) to the buffer containing MARK at the position
of the mark. If the file containing MARK is not in memory then we
attempt to load it with `open-file'.(set-auto-mark)
Sets the mark `auto-mark' to the current position (buffer & cursor-pos).(swap-cursor-and-auto-mark)
Sets the `auto-mark' to the current position and then sets the current
position (buffer and cursor-pos) to the old value of `auto-mark'.(split-line-indent)
Inserts a newline at the cursor position and then indents the new line
created to the indentation of the one above it.(make-auto-save-name FILE-NAME)
Returns a string naming the file used to hold the auto-save'd file for
file FILE-NAME.(auto-save-function BUFFER)
Automatically called when BUFFER is due to be automatically saved.
This function calls the hook `auto-save-hook', if this returns nil it then
saves it to the file specified by `make-auto-save-name' appiled to the
name of the file stored in BUFFER.(delete-auto-save-file [BUFFER])
Deletes the file used to store the auto-save'd copy of the file stored in
BUFFER, if such a file exists.(auto-save-file-newer-p FILE-NAME)
Returns t if there exists an automatically saved copy of file FILE-NAME
which is newer than FILE-NAME.(recover-file [BUFFER])
Loads the auto-saved copy of the file stored in BUFFER into BUFFER
overwriting its current contents (if any changes are to be lost the user
will have to agree to this).(revert-buffer [BUFFER])
Restores the contents of BUFFER (or current buffer) to the contents of the
file it was loaded from.(switch-to-buffer)
Prompt for the name of a buffer and display it in the current window.(goto-line)
Prompt for a line number and move the cursor to it.(save-some-buffers)
Asks whether or not to save any modified buffers, returns t if no modified
buffers are left.(save-and-quit)
Calls `save-some-buffers' and quits (after asking whether it's ok to lose any
unsaved buffers).(ask-yes-or-no QUESTION)
Prompts the user for a yes or no answer to QUESTION, returns t for yes.(ask-y-or-n QUESTION)
Prompts the user for a single keypress response, either `y' or `n' to the
string QUESTION, returns t for `y'.