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. buffer-file-name [BUFFER]
Return the name of the file being edited in BUFFER. set-buffer-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'. buffer-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...
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. This is used to display the name of the edit-mode being used in the status
line. List of strings naming all minor-modes enabled in this buffer. 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. This variable holds the command currently being evaluated, or nil if no
command is active. The `command' is whatever is being evaluated; it could
be a function, a form or even a list of forms (from a menu). This variable holds the last interactive command evaluated. This will either
be from a keybinding or a menu. Setting the value of the `next-keymap-path'
variable is not considered a command. After a command finishes this variable
takes the value of `this-command'. Value of the prefix argument for the next command. Value of the prefix argument for the current command. call-command COMMAND [PREFIX-ARG]
Invoke the command COMMAND. This can be one of,
1. A symbol whose function value is to be called, the symbol must be of
type `commandp'; any interactive calling specification will be
used to find arguments to give to the function. (see `interactive')
2. A lambda-expression to call as a function name
3. A single Lisp form to be evaluated by eval
If PREFIX-ARG is non-nil it specifies the value of the COMMAND's
current-prefix-arg. This is used in call-command's interactive spec so that
any entered arg is given to the invoked COMMAND. prefix-numeric-argument ARG
Returns the numeric value of the raw prefix argument ARG. interactive CALLING-SPEC
This is a declaration used by the `call-command' function. For each Lisp
function which may be invoked as a command (interactively by the user) the
first *actual* form of the function (after the arguments and optional doc
string) must be an `interactive' declaration. For example,
(defun foo (bar)
"An illustration"
(interactive ...)
...
When called, the interactive special form just returns nil.
The CALLING-SPEC defines the arguments which are given to the command, it
can be either,
1. nil -- no arguments are given to the function, this is just used to show
that this function may be called as a command.
2. A Lisp form -- it is evaluated and expected to provide a *list* of
arguments which will be given to the function
3. A string -- zero or more lines (separated by `\n'); each line tells
how to get one argument. The first character of each line is a code
letter, the rest of the line is an optional prompt-string which the
user will see when entering the argument's value.
The code letters available are,
a A function
b An existing buffer
B A buffer, it will be created if it doesn't exist
c A character
C A command
d The position of the cursor
D The name of a directory
e The event which caused this command
E The event which caused this command as a string
f The name of an existing file
F The name of a file
k An event
m The start position of the currently-marked block
M The end of the block
n A number
N The numeric prefix arg, or an entered number
p The numeric prefix arg
P The raw prefix arg
s A string
S A symbol
t The symbol `t'
v A variable
x A Lisp object
X A Lisp object, read then evaluated
A null line produces an argument of nil.
Any non-alphabetic characters at the beginning of the CALLING-SPEC
are used as flags, the currently recognised flags are,
* If the active buffer is read-only an error will be signalled
- After building the argument list the block marked in the
current window will be unmarked.
Example usage,
(interactive) -- No arguments but function may
be called as a command
(interactive "bBuffer to kill:") -- One arg, an existing buffer
(interactive "*\nxLisp form:\nt") -- If not read-only, three arguments;
`nil', a lisp form and `t'. commandp COMMAND
Returns t if COMMAND may be called interactively. 256-byte string holding translations to turn each character into its
upper-case equivalent. 256-byte string holding translations to turn each character into its
lower-case equivalent. When bound and non-nil this variable cancels the effect of the set-buffer-
read-only command; in that the buffer is always writeable. This is
intended to be bound while a command is executing that is allowed to
modify a buffer. split-line
Splits the line into two at the cursor position. insert STRING [POS] [BUFFER]
Inserts STRING into BUFFER at POS. Returns the first position of the first
character after the end of the inserted text. delete-area START-POS END-POS [BUFFER]
Deletes from START-POS up to (but not including) END-POS. copy-area START-POS END-POS [BUFFER]
Returns the string from START-POS up to 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. 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
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. Only the text from POS to the
end of the line is matched against. match-start [EXPRESSION-INDEX]
Return the position which the EXPRESSION-INDEX'th parenthesised expression
started at in the last successful regexp match. If EXPRESSION-INDEX is
nil or 0 the start of the whole match is returned instead.
The returned value will either be a position if the last match was in a
buffer, or an integer if the last match was in a string (i.e. regexp-match). match-end [EXPRESSION-INDEX]
Return the position which the EXPRESSION-INDEX'th parenthesised expression
ended at in the last successful regexp match. If EXPRESSION-INDEX is
nil or 0 the end of the whole match is returned instead.
The returned value will either be a position if the last match was in a
buffer, or an integer if the last match was in a string (i.e. regexp-match). regexp-quote STRING
Returns a new version of STRING, any characters which the regexp routines
treat specially (asterisks, square brackets, etc...) is quoted by the escape
character `\'. If the STRING does not contain any regexp meta-characters
it is returned as-is (un-copied). glyph-table-p ARG
Returns t if ARG is a glyph-table. char-to-glyph-pos [POS] [BUFFER]
From the character position POS, find its true *physical* position when
rendered. glyph-to-char-pos POS [BUFFER]
For the physical position POS, find the closest matching actual character
position. default-glyph-table
Returns the standard glyph-table. make-glyph-table SRC
Creates a new glyph-table. If SRC is a glyph-table it will be copied, else if
SRC is a buffer that buffer's glyph-table will be copied. If SRC is nil the
default glyph-table will be copied. set-glyph GLYPH-TABLE CHARACTER GLYPH-STRING
Make the renderer draw the string GLYPH-STRING (no more than 4 characters)
for each character CHARACTER in any buffers which use the GLYPH-TABLE. get-glyph GLYPH-TABLE CHARACTER
Return the string which is the rendered representation of CHARACTER in
GLYPH-TABLE. buffer-glyph-table [BUFFER]
Returns the glyph-table being used in BUFFER. set-buffer-glyph-table [BUFFER] GLYPH-TABLE
Sets the glyph-table being used in BUFFER to GLYPH-TABLE. 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). When this variable is non-nil the `ESC' key means that the next event
is qualified by the `Meta' modifier.
This feature is included mainly for compatibility with GNU Emacs. This hook gets evaluated every second while the editor is idle. Don't depend
on how regularly this gets called, any events from the window-system will
delay it. Also, auto-saving files and garbage-collection take precedence
when there's idle time available. Use this hook sparingly, or for short
periods only! make-keytab
Return a new key-table suitable for storing bindings in. This is a 127
element vector, each element is an empty list of bindings. make-keylist
Return a new key-list suitable for storing bindings in. This is a cons
cell looking like `(keymap . LIST-OF-BINDINGS)', LIST-OF-BINDINGS starts
off empty. bind-keys KEY-MAP { EVENT-DESCRIPTION COMMAND }... unbind-keys KEY-MAP EVENT-DESCRIPTION... The value of `keymap-path' to be used for the *next* keypress. This is
usually used to chain together multi-key bindings. current-event-string
Returns the string which would have been inserted by the current event if
a Lisp function hadn't been called instead. current-event
Return the event which caused the current command to be invoked. last-event
Return the previous event which occurred. event-name EVENT
Returns a string naming the event EVENT. lookup-event EVENT-NAME
Return the event whose name is EVENT-NAME. lookup-event-binding EVENT [RESET-PATH]
Return the command currently associated with the event EVENT.
If RESET-PATH is non-nil the value of `next-keymap-path' will be cleared
after being used. keymapp ARG
Returns t if ARG can be used as a keymap. eventp ARG
Returns t if the ARG is an input event. eval FORM
Evaluates FORM and returns its value. funcall FUNCTION ARGS...
Calls FUNCTION with arguments ARGS... and returns its result. progn FORMS...
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...
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
'ARG
Returns ARG. function ARG
#'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...)' defvar NAME DEFAULT-VALUE [DOC-STRING]
Define a variable called NAME whose standard value is DEFAULT-
VALUE. If NAME is already bound to a value it is left as it is.
If the symbol NAME is marked buffer-local the *default value* of the
variable will be set (if necessary) not the local value. defconst NAME VALUE [DOC-STRING]
Define a constant NAME whose (default) value is VALUE. If NAME is already
bound an error is signalled.
Constants are treated specially by the Lisp compiler, basically they are
hard-coded into the byte-code. For more details see the comments in
the compiler source (`lisp/compiler.jl'). 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 elements ARGS... 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
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...
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). When this window-local variable is non-nil the window's cursor is drawn at
the end of the message in the status line, not in the main display. List of buffers in most-recently-used order. Each window has it's own. 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-writable-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.
The first place we look for the directory name is the `HOME' environment
variable. If this doesn't exist we either use the `SYS:' assignment when
on AmigaDOS or look in the /etc/passwd file if on Unix. 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'. setenv VARIABLE [VALUE]
Sets the value of the environment variable called VARIABLE (a string) to
the string VALUE. If VALUE is undefined or nil the variable is removed from
the environment. make-process [OUTPUT-STREAM] [FUN] [DIR] [PROGRAM] [ARGS]
<UNIX-ONLY>
Creates a new process-object, OUTPUT-STREAM is where all output from this
process goes, FUN is a function to call each time the process running
on this object changes state. DIR is the process' current directory,
PROGRAM the filename of the program to run and ARGS a list of arguments
passed to the process.
Any of the arguments may be unspecified, in which case they can be set
either by the functions provided or by the function called to create the
actual running process. start-process [PROCESS] [PROGRAM] [ARGS...]
<UNIX-ONLY>
Starts a process running on process-object PROCESS. The child-process runs
asynchronously with the editor. If PROCESS is unspecified the make-process
function will be called (with zero arguments) to create one.
PROGRAM is the filename of the binary image, it will be searched for in
all directories listed in the `PATH' environment variable.
ARGS are the arguments to give to the process.
If any of the optional parameters are unspecified they should have been
set in the PROCESS prior to calling this function. run-process [PROCESS] [IN-FILE] [PROGRAM] [ARGS...]
<UNIX-ONLY>
Starts a process running on process-object PROCESS. Waits for the child to
exit, then returns the exit-value of the child. If PROCESS is unspecified
the make-process function will be called (with zero arguments) to create one.
IN-FILE is the name of the file to connect to the process' standard input,
if this is not defined `/dev/null' is used.
PROGRAM is the filename of the binary image, it will be searched for in
all directories listed in the `PATH' environment variable.
ARGS are the arguments to give to the process.
If any of the optional parameters are unspecified they should have been
set in the PROCESS prior to calling this function. signal-process PROCESS SIGNAL [SIGNAL-GROUP]
<UNIX-ONLY>
If PROCESS is running asynchronously then send signal number SIGNAL to it.
If SIGNAL-GROUP is non-nil also send the signal to all processes in the
process group of PROCESS. interrupt-process PROCESS [SIGNAL-GROUP]
<UNIX-ONLY>
Do (signal-process PROCESS SIGINT SIGNAL-GROUP) or equivalent. kill-process PROCESS [SIGNAL-GROUP]
<UNIX-ONLY>
Do (signal-process PROCESS SIGKILL SIGNAL-GROUP) or equivalent. stop-process PROCESS [SIGNAL-GROUP]
<UNIX-ONLY>
Suspends execution of PROCESS, see `continue-process'. If SIGNAL-GROUP is
non-nil also suspends the processes in the process group of PROCESS. continue-process PROCESS [SIGNAL-GROUP]
<UNIX-ONLY>
Restarts PROCESS after it has been stopped (via `stop-process'). If
SIGNAL-GROUP is non-nil also continues the processes in the process group of
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. processp ARG
<UNIX-ONLY>
Return t is ARG is a process-object. process-prog PROCESS
<UNIX-ONLY>
Return the name of the program in PROCESS. set-process-prog PROCESS PROGRAM
<UNIX-ONLY>
Sets the name of the program to run on PROCESS to FILE. process-args PROCESS
<UNIX-ONLY>
Return the list of arguments to PROCESS. set-process-args PROCESS ARG-LIST
<UNIX-ONLY>
Set the arguments to 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-function PROCESS
<UNIX-ONLY>
Return the function which is called when PROCESS changes state (i.e. it
exits or is stopped). set-process-function PROCESS FUNCTION
<UNIX-ONLY>
Set the function which is called when PROCESS changes state to FUNCTION. process-dir PROCESS
<UNIX-ONLY>
Return the name of the directory which becomes the working directory of
PROCESS when it is started. set-process-dir PROCESS DIR
<UNIX-ONLY>
Set the directory of PROCESS to DIR. process-connection-type PROCESS
<UNIX-ONLY>
Returns a symbol defining the type of stream (i.e. pipe or pty) used to
connect PROCESS with its physical process. set-process-connection-type PROCESS TYPE
<UNIX-ONLY>
Define how PROCESS communicates with it's child process, TYPE can be one of
the following symbols,
pty Use a pty
pty-echo Similar to `pty' but the ECHO flag is set in the slave
pipe Two pipes are used
This function can only be used when PROCESS is not in use. server-open-p
t if the edit-server is open. server-open
Creates the socket (or whatever) so that the editor's client program can
send us messages. server-close
Stops listening for client messages. server-reply [FILE-NAME] [RETURN-CODE]
Replies to the editor client which asked us to edit the file FILE-NAME.
RETURN-CODE is the optional result for the client, by default it is zero
which denotes no errors. Returns nil if the file doesn't have a client. set-menu-enabled 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] COMMAND)
ITEM-NAME is the item name, SHORTCUT is an optional keyboard shortcut (a one
character long string) and COMMAND is the command to be called when the
menu is selected (see the function `call-command').
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-STRING GADGETS-STRING
<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. List of buffers marked for deletion. List of buffers marked to be saved. Buffer Menu Mode:
This major mode is used in the `*Buffer Menu*' buffer; it provides
interactive commands for manipulating the list of buffers loaded into
the editor.
Commands available are,
`d' Mark buffer for deletion.
`s', `Ctrl-s' Mark buffer to be saved.
`x' Execute marked saves and deletions.
`u' Unmark the current line.
`1' Select the current line's buffer in this window.
`o' Display the current line's buffer in a different
window.
`~' Toggle the buffer's `modified' flag.
`%', `-' Toggle the buffer's read-only status.
`Ctrl-f', `TAB' Move forwards through the menu.
`Ctrl-b', `Shift-TAB' Cycle backwards through the menu.
`Ctrl-l' Redraw the menu, incorporating any changes to the
buffer-list.
`q' Quit the buffer menu. The file name of the gdb program to run. When non-nil the current line in the source window is automatically
centred each time it changes. (FILE . LINE-NUMBER) representing the last frame we displayed. This is the last *gdb* buffer which was used. Flag that says this buffer is for running a gdb process. Run the gdb debugger in an editor buffer (called `*gdb*'). PROG is the
program which is to be debugged.
See the `gdb-mode' documentation for details of the available commands.
There is no limit to the number of gdb processes you may run at once. Gdb Mode:
This major-mode is used to run the GDB debugger in an editor buffer. To
start a gdb subprocess use the `ESC x gdb' command.
Each time the target process stops executing the source line of the
current frame is highlighted in a separate window.
The following commands are available in the `*gdb*' buffer,
`Ctrl-c Ctrl-n' Next line
`Ctrl-c Ctrl-s' Step
`Ctrl-c Ctrl-i' Step the next instruction
`Ctrl-c Ctrl-I' Next instruction
`Ctrl-c Ctrl-f' Finish this frame
`Ctrl-c Ctrl-r' Continue execution
`Ctrl-c Ctrl-<' Move up one frame
`Ctrl-c Ctrl->' Move down one frame
`Ctrl-c Ctrl-b' Set a breakpoint at the current line
`Ctrl-c Ctrl-t' Set a temporary breakpoint
`Ctrl-c Ctrl-d' Delete the breakpoint at the current line
`Ctrl-c Ctrl-l' Redisplay the current frame
They are also accessible in any buffer by replacing the `Ctrl-c' prefix
with `Ctrl-x Ctrl-a'.
Since this command is built on top of the shell-mode all commands from
that mode are available as well. The name of the shell program. When non-nil the whole line (minus the prompt) is sent to the shell
process when `RET' is typed, even if the cursor is not at the end of the
line. The program to run, by default the standard shell. The arguments to give to the program when it's started. A regexp matching the prompt of the shell. Holds the function to call when the process changes state. Stream to output to from subprocess. If nil the process' buffer is
written to. This is only consulted when the process is started. The process that the Shell mode created in the current buffer. Keymap for shell-mode. Keymap for ctrl-c in shell-mode. Shell Mode:
Major mode for running a subprocess in a buffer. Special commands are,
`Ctrl-a' Move to the start of this line (after the prompt)
`Ctrl-d' If at the end of the buffer send the ^D character,
otherwise delete the current character.
`RET' Send the current line to the process
`Ctrl-c Ctrl-c' Send the `intr' character to the process (`^C')
`Ctrl-c Ctrl-z' Send the `susp' character (`^Z')
`Ctrl-c Ctrl-d' Send the `eof' character (`^D')
`Ctrl-c Ctrl-\' Send the `quit' character (`^\')
`Ctrl-c Ctrl-n' Move to the next prompt
`Ctrl-c Ctrl-p' Move to the previous prompt Go to the beginning of this shell line (but after the prompt). When at the very end of the buffer send the subprocess the EOF character,
otherwise delete the first COUNT characters under the cursor. Send the current line to the shell process. If the current line is not the
last in the buffer the current command is copied to the end of the buffer. Run a subshell in a buffer called `*shell*' using the major mode
`shell-mode'. Prints a description of the installed keymaps in the current buffer. Read the next event and return a cons cell containing the two integers that
define that event. Read an event sequence from the user then display details of the command it
would invoke. Indentation of code with respect to its containing block. Extra indentation of braces relative to the body of the code they
contain. Extra indentation for case statements. Extra indentation for labels. Indent the line at POS (or the cursor) assuming that it's C source code. List of all opened windows. Hook called when an input event saying that a window should be closed
is received. Creates a new window display BUFFER or the buffer that the current window is
showing. Close window WIN, or the current window. Close all windows except for WIN, or the current one. Make sure that BUFFER is in the `buffer-list' of all open windows. It gets
put at the end of the list. Delete all references to BUFFER in any of the windows' `buffer-list' Switches to the `other' window then calls the command COMMAND in it. Switch to the `other' window. (other-window)
Return the `other' window. Toggle the current window between iconified and normal states. Mode for editing English text in. Variant of `text-mode' in which the TAB key indents to the depth of the
previous line, then works as normal. Centre the line at POS. Centre the paragraph surrounding POS. Texinfo Mode:
Major mode for editing Texinfo source files.
Special commands available are,
`Ctrl-c Ctrl-c c' Insert `@code'
`Ctrl-c Ctrl-c d' Insert `@dfn'
`Ctrl-c Ctrl-c e' Insert the correct `@end' command for the current
context.
`Ctrl-c Ctrl-c f' Insert `@file'
`Ctrl-c Ctrl-c i' Insert `@item'
`Ctrl-c Ctrl-c l' Insert `@lisp'
`Ctrl-c Ctrl-c m' Insert `@menu'
`Ctrl-c Ctrl-c Ctrl-m' Insert a menu item.
`Ctrl-c Ctrl-c n' Prompt for each part of an `@node' line and insert
the constructed line.
`Ctrl-c Ctrl-c s' Insert `@samp'
`Ctrl-c Ctrl-c v' Insert `@var'
`Ctrl-c Ctrl-c {' Insert a pair of braces and place the cursor between
them.
`Ctrl-c Ctrl-c }',
`Ctrl-c Ctrl-c ]' Move the cursor to the character after the next closing
brace. Determines which window a client file gets displayed in. There are three
possible values,
nil - Use the current window
other - Use the `other' window
t - Open a new window This function is called by the editor's main event loop when a client
process asks us to edit a file -- its job is to load the specified file
into a new buffer and display it at line LINE-NUMBER. Tell the client program which asked us to edit the file in the current
buffer that we've finished with it. *The file will NOT be saved* automatically
-- you're supposed to do that before calling this function if you want to. Replace all occurrences of the regexp FROM with the expansion from TEMPLATE
for that particular occurrence (see the `replace-regexp' function for details
of what can be in TEMPLATE). Command to interactively replace all occurrences of the regexp
QUERY-REPLACE-FROM with the expansion of the template QUERY-RFEPLACE-TO.
If FROM or TO are not given they are prompted for.
As each occurrence is found the editor pauses, waiting for the user to
type one of the following special commands,
`SPC', `y' replace this occurrence and find the next
`BS', `n' ignore this occurrence and search for the next
`,' replace this match and wait for another command
`RET', `ESC', `q' exit the query-replace
`.' replace this occurrence then exit the query-replace
`!' replace all matches from here to the end of the buffer
`^' return to the previous match
`Ctrl-r' enter a recursive edit (`ESC Ctrl-c' to exit)
`Ctrl-w' delete the match, then enter a recursive edit
`Ctrl-h' show some help text Stack of buffers which can be used for prompts. Optional function taking one argument, the string to be completed. It
should return a list of all matches. Optional function taking one argument, the string which has been entered.
Should return non-nil when this string may be accepted (and therefore the
prompt will end). If it returns the symbol t the string is returned as-is,
if some other non-nil value is returned *that* is the value returned by
the prompt. Default value of `prompt-word-regexps' Vector of two regexps; the values of `word-regexp' and `word-not-regexp'
for the prompt. Used by the `prompt-complete-from-list' and `prompt-validate-from-list'
to supply possible completions. Predicate used when prompting for symbols. *AMIGA ONLY*
When non-nil the normal ASL file requester is used when file names are
prompted for. The buffer being used for the prompt. Position at which the list of completions should be printed. Prompts for a string using completion. TITLE is the optional title to
print in the buffer, START the original contents of the buffer.
The string entered is returned, or nil if the prompt is cancelled (by Ctrl-g). A regexp, if it matches the file being considered for completion, the file
is rejected. Prompt for a file, if EXISTING is t only files which exist are
allowed to be entered. Prompt for a directory, if EXISTING is t only files which exist are
allowed to be entered. Prompt for a buffer, if EXISTING is t the buffer selected must exist,
otherwise if EXISTING is nil the buffer will be created if it doesn't
exist already. DEFAULT is the value to return if the user enters the null
string, if nil the current buffer is returned. Prompt for an existing symbol. If PROMPT-SYMBOL-PREDICATE is given the
symbol must agree with it. Prompt for a lisp object. Prompt for a function. Prompt for a variable. Prompt for a command. Return a selected choice from the list of options (strings) PROMPT-LIST.
PROMPT is the title displayed, START the starting choice. List of all major modes which can be enabled by loading a file into
a buffer. List is made of `(REGEXP . MODE)' cells; the REGEXP is matched
against the mode specification (i.e. the filename), if it matches the
function MODE is called to install the mode. The function which was used to initialise the buffer's major mode. The function which should be called to remove the buffer's major mode. Buffer-local variable containing the canonical column number which
comments should begin at. If the line extends past this column the next
tab stop after the end of the line is used instead. A function called to indent a specified line in the current buffer. Function like `lisp-forward-sexp'. Function like `lisp-backward-sexp'. Scan the alist `mode-alist' for a mode whose regexp matches NAME,
returning the initialisation function of that mode (a symbol) or nil. 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 word specified on the first line of the buffer surrounded by
`-*-...-*-' (ie, -*-texinfo-*-)
3. The value of the variable `mode-name'
4. The name of the file being edited in the buffer Destroy the mode being used to edit buffer BUF with. List of all minor-modes enabled in this buffer. Buffer-local keymap to be used by minor-modes. This is only created
the first time a minor mode calls `add-minor-mode' in the buffer. For use by minor-modes. MODE is the mode's function symbol. This sets up the
current buffer. All minor-modes should call this before doing anything drastic.
NAME is the string to be displayed in the status-line to show that the mode
is enabled. For use by minor-modes. MODE is the mode's function symbol. Removes MODE
from the current buffer. Insert comment delimeters on the current line, place the cursor where the
comment should be written. This may or not be defined by each major mode. Use the `mode-indent-line' function to indent each line between START and
END. (newline-and-indent)
Insert a newline then either call this buffer's `mode-indent-line' function
or insert a tab. Indent the current line. Move forward NUMBER expressions. Move backwards NUMBER expressions. Kill the next NUMBER expressions. Kills from the start of this NUMBER'th previous expression to the cursor. Move the expression before the cursor COUNT expressions forwards. The root keymap. Default `Ctrl-x' keymap. Default `Ctrl-x 4' keymap. Default `Ctrl-x 5' keymap. Hook to hang major mode `Ctrl-c' keymap from. Keymap for user-defined bindings, hung from `Ctrl-c'. This function can be bound to a key to make it insert its usual character
sequence. This is usually used to ``hide'' a previously bound definition of
the key. Add a digit to the prefix-arg. Negate the prefix-arg. Bound to `Meta--'. A list of symbols definining which ``features'' Jade currently has loaded.
This is used by the `featurep', `provide' and `require' functions. If FEATURE (a symbol) has not already been loaded, load it. The file
loaded is either FILE (if given), or the print name of FEATURE. Show that the feature FEATURE (a symbol) has been loaded. Return non-nil if feature FEATURE has already been loaded. Tell the evaluator that the function value of SYMBOL will be initialised
from a named file. The AUTOLOAD-DEFN is the contents of the SYMBOL's
autoload definition. Currently two items are used, the first is the name
of the file to load the value of SYMBOL from. The second says whether or
not the function SYMBOL may be called interactively (as a command). 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 FUNCTION-NAME from the hook HOOK-SYMBOL. Return a string representing OBJECT. Reads an object from STRING, starting at character number START (default
is 0). Eval FORM then print its value in the status line. Lisp Mode:
Major mode for editing Lisp source. Special commands in this mode are,
`Ctrl-j' Evaluate the current s-expression as Jade Lisp code
and insert its value into the current buffer.
`TAB' Indent the current line.
`Ctrl-Meta-x' Evaluate the current sexp and print its value in
the status line.
`Ctrl-Meta-f' Move to the past the current s-expression.
`Ctrl-Meta-b' Move to the beginning of the current sexp.
`Ctrl-Meta-k' Kill from the cursor to the end of this sexp.
`Ctrl-Meta-BS' Kill from the start of this sexp to the cursor. Evaluates the Lisp expression before the cursor and returns its value. Evaluates the Lisp expression before the cursor, then inserts its value
into the buffer. Evaluates the Lisp expression before the cursor, then displays its value
in the status line. Return the position of the NUMBER'th next s-expression from POS. Return the position of the NUMBER'th previous s-expression from ORIG-POS. Number of columns to indent code bodies by. Returns the correct indentation position for the specified line. Non-nil when the Latin-1 character set is being used. Toggles whether or not the characters with numeric values from 160 to 256
are displayed as octal escape sequences or in the Latin-1 character set. Buffer-local variable, when non-nil case of characters is ignored when
searching. The last regexp successfully (i.e. entered with RET) found by isearch. Enters the incremental search mode. You are then able to type letters to add
to the regexp being searched for. Special commands are,
`Ctrl-s' Search forwards for another occurrence
`Ctrl-r' Search backwards
`Ctrl-g' If the search is failing, backtrack to the first non-failing
match, else, cancel the search leaving the cursor at its
original position.
`Ctrl-w' Copy the rest of the current word into the search string
`Ctrl-y' Copy the rest of the line to the search string
`RET' Exit isearch leaving the cursor at its current position
`BS' Retrace your movements one step Similar to `isearch-forward' except the first searching is done in the other
direction. List of directories to search for info files if they can't be found as-is. Keymap for Info. Buffer in which Info nodes are displayed. Buffer for storing the current Info file's tag table. List of `(FILE NODE POS)' showing how we got to the current node. The true name (in the filesystem) of the current Info file. The name of the current Info node. The modtime of file `info-file-name' last time we read something from it. List of `(START-OFFSET . FILE-NAME)' saying where the current Info file
is split. t when we were able to load a tag table for this Info file. Protection against being loaded multiple times. Start the Info viewer. If START-NODE 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). Info mode:
This mode is used to browse through the Info tree of documentation, special
commands are,
`SPC' Next screen of text
`BS' Previous screen
`b' Move to the start of this node
`1' to `9' Go to the Nth menu item in this node
`d' Find the `(dir)' node -- the root of Info
`f' Find the node of the next cross-reference in this node
`g NODE RET' Go to the node called NODE
`h' Display the Info tutorial, the node `(info)Help'
`l' Backtrack one node
`m' Choose a menu item from this node
`n' Find the `next' node
`p' Go to the `previous' node
`u' Display the parent node of this one
`q' Quit Info
`?', `HELP' Display this command summary
`RET',
`LMB-CLICK2' Go to the link (menu item or xref) on this line
`TAB' Put the cursor on the next link in this node
`Meta-TAB' Move to the previous link in this node Entrance to the online-help system. Displays some text describing the options in the help system. Print the full contents of the current keymap (and the keymaps that
it leads to). Display the documentation of a function, macro or special-form. Print the help text for the current editing mode. 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. Sets the `variable-documentation' property of SYMBOL to DOC-STRING. Add all functions, macros or variables in the BUFFER marked by the magic
rune `;;;###autoload' to the `autoload.jl' file. Removes all autoload definitions in the buffer BUFFER which are marked by
the string `;;;###autoload' from the `autoload.jl' file. Position at which the text filling commands break lines. Minor mode for automatically filling lines, i.e. word-wrapping. This makes
the SPC key checks if the cursor is past the fill-column. If so, the next
line is started. Sets the column number for filling to (the variable `fill-column') to
COLUMN or the current column. 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. Return the position of first character after the end of this word.
NUMBER is the number of words to move, negative values mean go backwards.
If MOVE is t then the cursor is moved to the result. Basically `(forward-word -NUMBER POS MOVE)' Kills from the cursor to the end of the word. Kills from the start of the word to the cursor. Returns the position of the start of *this* word. Returns t if POS is inside a word. Marks COUNT words from POS. Move the word at (before) the cursor COUNT words forwards. Returns the position of the start of the next paragraph. If MOVE
is t then the cursor is set to this position. Returns the start of the previous paragraph. If MOVE is t the cursor is
set to this position. Set the block-marks to the current paragraph. If a block is marked in the current window, return the text it contains and
unmark the block. Similar to `copy-block' except the block is cut (copied then deleted) from
the buffer. Deletes the block marked in the current window (if one exists). If a block is marked in the current window, copy it to position POS, then
unmark the block. Toggles the state of the flag saying whether blocks in this window are
marked sequentially (the default) or as rectangles. Kills the block marked in this window. Kills the block marked in this window but doesn't actually delete it from
the buffer. Mark a block from START to END. This does an extra redraw if there's already
a block marked to save lots of flicker. Mark a block containing the whole of the buffer. Makes all alpha characters in the specified region of text upper-case. Makes all alpha characters in the specified region of text lower-case. Makes the next COUNT words from the cursor upper-case. The first character of this word (the one under the cursor) is made
upper-case, the rest lower-case. Makes the word under the cursor lower case. Sets the block-marks to the area between the cursor position and the
auto-mark Adds STRING to the kill storage. If the last command also kill'ed something
the string is appended to. Returns the string in the kill-buffer at position DEPTH. Currently only one
string is stored so DEPTH must be zero or not specified. Kills a region of text in the current buffer from START to END. Copies a region of text in the current buffer (from START to END) to the
kill storage. If the cursor is not at the end of the line kill the text from the cursor
to the end of the line, else kill from the end of the line to the start of
the next line. Kill the whole of the current line. Kill from the cursor to the start of the line. Inserts text before the cursor. If a block is marked in the current buffer
and DONT-YANK-BLOCK is nil insert the text in the block. Else yank the last
killed text. Similar to `yank' except that the inserted text is treated as a rectangle. Does a `(yank)' inserting at the current position of the mouse cursor. The
cursor is left at the end of the inserted text. Transpose the areas defined by the functions FORWARD-ITEM and BACKWARD-
ITEM (in the style of `forward-word', `backward-word' etc).
COUNT is the number of items to drag the item at the cursor past.
What actually happens is that the item before the cursor is dragged forward
over the COUNT following items. Exits the innermost recursive edit with a value of VALUE (or nil). Abort all recursive-edits. Non-nil when overwrite-mode is enabled. Minor mode to toggle overwrite. Delete COUNT characters preceding the cursor, if the cursor is past the
end of the line simply move COUNT characters to the left. Delete the character under the cursor. Insert enough spaces before the cursor to move it to the next tab position. Ensure that there are only COUNT spaces around the cursor. Delete all space and tab characters surrounding the cursor. Break the current line creating COUNT new lines, leaving the cursor in
its original position. Move the character before the cursor COUNT characters forwards. Disassembles the byte code form which is the function value of FUN. If
STREAM is given all output goes to that stream. Buffer to use for the Lisp debugger. Keymap for debugger's ctrl-c prefix. Debug Mode:
The major mode controlling the Lisp debugger. Commands available within
the debugger are,
`Ctrl-c Ctrl-s' Step into this form.
`Ctrl-c Ctrl-i' Ignore this form.
`Ctrl-c Ctrl-n' Continue until the next form.
`Ctrl-c Ctrl-r' Continue execution.
`Ctrl-c Ctrl-b' Print a backtrace of the Lisp call stack.
`Ctrl-c Ctrl-x' Set the value which this form will return. When t all doc-strings are appended to the doc file and replaced with
their position in that file. List of symbols, when the name of the function called by a top-level form
is one of these that form is compiled. Compiles the file of jade-lisp code FILE-NAME into a new file called
`(concat FILE-NAME ?c)' (ie, `foo.jl' => `foo.jlc'). 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.
EXCLUDE-LIST is a list of files which shouldn't be compiled. 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 and
that files which shouldn't be compiled aren't. Compile the Lisp form FORM into a byte code form. String used to match error messages in compilation output. Expansion template for the name of the file in an error matched by
`compile-error-regexp'. Expansion template for the line number of an error matched by
`compile-error-regexp'. Expansion template for the error description in an error matched by
`compile-error-regexp'. 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'. The filename of the shell to use to run the compilation in. <UNIX-ONLY>
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. TYPE-STR is a string describing the type of messages
the command may output (i.e. `errors' for a compilation). <UNIX-ONLY>
Runs the SHELL-COMMAND in the `*compilation*' buffer. If SHELL-COMMAND isn't
given you will be prompted for a command. Moves the cursor to the file and line of the next error displayed in the
`*compilation*' buffer. <UNIX-ONLY>
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 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 C Mode:
Simple mode for editing C source code. Its main feature is to be able to
indent lines to their (probably) correct depth.
Special commands are,
`{', `}', `:' Insert the character then indent the line
`TAB' Indent the current line
`Ctrl-c Ctrl-\' Aligns backslash characters at the end
of each line in the current block.
`ESC Ctrl-b' Move backwards one expression.
`ESC Ctrl-f' Move forward one expression. Indent the line at POS (or the cursor) assuming that it's C source code. *Attempts* to guess the correct indentation for this line. Returns the
position for the first non-space in the line. 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). Insert (or align) backslash characters at the end of each line in between
START and END except for the last line. 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. Non-nil means make file backups by copying the file if it's not a good
idea to rename it. If `backup-by-copying' is non-nil this variable has no
effect. The `*jade*' buffer. 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 When a buffer's `special' attribute is set kill-buffer will only kill
it totally if this variable is non-nil. Tells how to process local variable lists. t means process them
silently, nil means ignore them, anything else means to query each
variable being set. Tells how to process the `eval' local variable. Same options as
with `enable-local-variables'. This variable defines how many of the bottom-most lines in a file are
searched for a `Local Variables:' section. 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. If BUFFER is a string and it doesn't name
an existing buffer a new one will be created with that name. If no buffer containing 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 `(buffer-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. Sets the current buffer to that containing the file NAME, if NAME
is unspecified it will be prompted for. If the file is not already in memory
`open-file' will be used to load it. Similar to `find-file' except that the buffer is edited in read-only mode. If NAME is unspecified one will be prompted for. The current buffer is
killed and one editing NAME is found. If necessary make a backup of FILE-NAME. The file called FILE-NAME may or
may not exist after this function returns. Writes the contents of BUFFER to the file NAME, or to the one
that it is associated with. 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. Saves the buffer BUFFER, or the current one, to the file NAME,
resetting the name of the buffer and the file that it is associated with
to reflect NAME. Also sets the modification count to zero. Inserts the file NAME into the buffer BUFFER (or the current one) before
the cursor position. If no buffer called NAME exists, creates one and adds it to the main
buffer-list. Always returns the 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). Puts BUFFER (or the currently displayed buffer) at the end of the current
window's buffer-list then switch to the buffer at the head of the list.
If ALL-WINDOWS is non-nil this is done in all windows (the same buffer
will be buried in each window though). Prompt the user for the name of a buffer, then display it. 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. 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. 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'. Sets the mark `auto-mark' to the current position (buffer & cursor-pos). 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'. Inserts a newline at the cursor position and then indents the new line
created to the indentation of the one above it. Returns a string naming the file used to hold the auto-save'd file for
file NAME. 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. Deletes the file used to store the auto-save'd copy of the file stored in
BUFFER, if such a file exists. Returns t if there exists an automatically saved copy of file NAME which
is newer than NAME. 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). Restores the contents of BUFFER (or current buffer) to the contents of the
file it was loaded from. Goto line number LINE. LINE counts from 1. Returns t of FILE1 was modified more recently than FILE2. Asks whether or not to save any modified buffers, returns t if no modified
buffers are left. Calls `save-some-buffers' and quits (after asking whether it's ok to lose
any unsaved buffers). When this mode is enabled files are autosaved regularly if
they've been modified. When non-nil lines are indented after being split in asm-mode. Strings which denotes the start of a comment in asm-mode. Asm Mode:
Major mode for editing generic assembler source. Special commands are,
`RET' break line and indent (unless asm-indent is nil)
`:' undent line, then insert a tab
`.' if line is not empty, delete its indentation, then insert
a dot. Asm-CPP Mode:
Major mode for editing assembler source which is passed through cpp before
being assembled. Currently this only differs from asm-mode in the comments
it inserts. Prompts the user for a yes or no answer to QUESTION, returns t for yes. Prompts the user for a single keypress response, either `y' or `n' to the
string QUESTION, returns t for `y'. Email address for use in change logs User's proper name, for change logs File name of change logs
