Start Deuce like this: make run-dev

This will put you in scratch, with the keyboard enabled. There's no minibuffer yet, so you have to switch buffer from the REPL. Several keyboard commands fail or are a bit off (like move-end-of-line).

Connect to nREPL from Emacs on port 7888: user> (in-ns 'deuce.emacs) ;; We're now in Emacs Lisp

Tail the log at ~/.deuce.d/deuce.log Errors are also visible in the Echo Area

The way this does this is probably utterly wrong, written by data inspection, not reading Emacs source. But produces the expected result:

Renders a single window using Lanterna. Scrolling is not properly taken care of. Hard to bootstrap, requires fiddling when connected to nREPL inside Deuce atm. Consider moving all this into deuce.emacs.dispnew

If the screen gets messed up by other output like a stack trace you need to call this.

Not the real thing, but keeps the UI changing while using the REPL before we got a real command loop.

Callback run by faces/tty-run-terminal-initialization based on deuce.emacs.term/tty-type returning "lanterna" Has Emacs Lisp proxy in deuce.emacs.

We want to support emacs -q initially. -q is --no-init-file

There's also an obsolete (as of Emacs 22.2) concept of frame locals. See deuce.emacs.data/make-variable-frame-local and deuce.emacs.frame/modify-frame-parameters This is the set of variables which can potentially be buffer local, values are stored in local-var-alist on Buffer. It's initialized by deuce.emacs.buffer/init-buffer-locals

build cached invoker to use once target is resolved?

Break this up and explain what the different branches are doing and why.

Emacs Lisp allows an atom to be spliced if it is in the last position, like this: (let ((upat 'x) (sym 'x)) `(match ,sym ,@upat)) => (match x . x) Doesn't handle this wonderful case: `,@2 => 2

There's a version of this already defined as macro in backquote.el, use it / override it? What's their relationship?

Defined in eval.clj

Define NAME as a function. The definition is (lambda ARGLIST [DOCSTRING] BODY...). See also the function `interactive'.

Return a lambda expression. A call of the form (lambda ARGS DOCSTRING INTERACTIVE BODY) is self-quoting; the result of evaluating the lambda expression is the expression itself. The lambda expression may then be treated as a function, i.e., stored as the function value of a symbol, passed to funcall' ormapcar', etc.

ARGS should take the same form as an argument list for a `defun'. DOCSTRING is an optional documentation string. If present, it should describe how to call the function. But documentation strings are usually not useful in nameless functions. INTERACTIVE should be a call to the function `interactive', which see. It may also be omitted. BODY should be a list of Lisp expressions.

Defined in subr.el

Return a function that is a partial application of FUN to ARGS. ARGS is a list of the first N arguments to pass to FUN. The result is a new function which does the same as FUN, except that the first N arguments are fixed at the values with which this function was called.

Defined in subr.el

Define a compiler-only macro. This is like `defmacro', but macro expansion occurs only if the call to FUNC is compiled (i.e., not interpreted). Compiler macros should be used for optimizing the way calls to FUNC are compiled; the form returned by BODY should do the same thing as a call to the normal function called FUNC, though possibly more efficiently. Note that, like regular macros, compiler macros are expanded repeatedly until no further expansions are possible. Unlike regular macros, BODY can decide to "punt" and leave the original function call alone by declaring an initial `&whole foo' parameter and then returning foo.

Defined in cl-macs.el. Optimizes existing fns which complicates things a lot.

Do BODYFORM, protecting with UNWINDFORMS. If BODYFORM completes normally, its value is returned after executing the UNWINDFORMS. If BODYFORM exits nonlocally, the UNWINDFORMS are executed anyway.

Regain control when an error is signaled. Executes BODYFORM and returns its value if no error happens. Each element of HANDLERS looks like (CONDITION-NAME BODY...) where the BODY is made of Lisp expressions.

A handler is applicable to an error if CONDITION-NAME is one of the error's condition names. If an error happens, the first applicable handler is run.

The car of a handler may be a list of condition names instead of a single condition name; then it handles all of them. If the special condition name `debug' is present in this list, it allows another condition in the list to run the debugger if `debug-on-error' and the other usual mechanisms says it should (otherwise, `condition-case' suppresses the debugger).

When a handler handles an error, control returns to the `condition-case' and it executes the handler's BODY... with VAR bound to (ERROR-SYMBOL . SIGNAL-DATA) from the error. (If VAR is nil, the handler can't access that information.) Then the value of the last BODY form is returned from the `condition-case' expression.

See also the function `signal' for more info.

Try each clause until one succeeds. Each clause looks like (CONDITION BODY...). CONDITION is evaluated and, if the value is non-nil, this clause succeeds: then the expressions in BODY are evaluated and the last one's value is the value of the cond-form. If no clause succeeds, cond returns nil. If a clause has one element, as in (CONDITION), CONDITION's value if non-nil is returned from the cond-form.

Set each SYM to the value of its VAL. The symbols SYM are variables; they are literal (not evaluated). The values VAL are expressions; they are evaluated. Thus, (setq x (1+ y)) sets x' to the value of(1+ y)'. The second VAL is not computed until after the first SYM is set, and so on; each VAL can use the new value of variables set earlier in the `setq'. The return value of the `setq' form is the value of the last VAL.

Return the argument, without evaluating it. (quote x)' yieldsx'. Warning: `quote' does not construct its return value, but just returns the value that was pre-constructed by the Lisp reader (see info node `(elisp)Printed Representation'). This means that '(a . b) is not identical to (cons 'a 'b): the former does not cons. Quoting should be reserved for constants that will never be modified by side-effects, unless you like self-modifying code. See the common pitfall in info node `(elisp)Rearrangement' for an example of unexpected results when a quoted object is modified.

Revisit using Atoms, will make closure capture easier. We use the dynamic-vars var for dynamic scope anyway. Bindings refering to other bindings and modifying them don't work properly. The vars must be created here instead of in with-local-el-vars (which might be removed). Everytime you make a 'sane' assumption you're bound to find some Emacs Lisp breaking it: (let* ((x 2) (y (setq x 4))) (+ x y)) => 8 Also: Needs to support delayed-eval referring to earlier bindings on rhs. (currently requires the binding to be in &env). Need to deal with dots in symbols here. desktop.el has things like (let ((q.txt "something..")))

Bind variables according to VARLIST then eval BODY. The value of the last form in BODY is returned. Each element of VARLIST is a symbol (which is bound to nil) or a list (SYMBOL VALUEFORM) (which binds SYMBOL to the value of VALUEFORM). All the VALUEFORMs are evalled before any symbols are bound.

Define SYMBOL as a constant variable. This declares that neither programs nor users should ever change the value. This constancy is not actually enforced by Emacs Lisp, but SYMBOL is marked as a special variable so that it is never lexically bound.

The `defconst' form always sets the value of SYMBOL to the result of evalling INITVALUE. If SYMBOL is buffer-local, its default value is what is set; buffer-local values are not affected. If SYMBOL has a local binding, then this form sets the local binding's value. However, you should normally not make local bindings for variables defined with this form.

The optional DOCSTRING specifies the variable's documentation string.

Eval FIRST and BODY sequentially; return value from FIRST. The value of FIRST is saved during the evaluation of the remaining args, whose values are discarded.

Eval FORM1, FORM2 and BODY sequentially; return value from FORM2. The value of FORM2 is saved during the evaluation of the remaining args, whose values are discarded.

Set the default value of variable VAR to VALUE. VAR, the variable name, is literal (not evaluated); VALUE is an expression: it is evaluated and its value returned. The default value of a variable is seen in buffers that do not have their own values for the variable.

More generally, you can use multiple variables and values, as in (setq-default VAR VALUE VAR VALUE...) This sets each VAR's default value to the corresponding VALUE. The VALUE for the Nth VAR can refer to the new default values of previous VARs.

Eval args until one of them yields non-nil, then return that value. The remaining args are not evalled at all. If all args return nil, return nil.

If TEST yields non-nil, eval BODY... and repeat. The order of execution is thus TEST, BODY, TEST, BODY and so on until TEST returns nil.

Define NAME as a macro. The actual definition looks like (macro lambda ARGLIST [DOCSTRING] [DECL] BODY...). When the macro is called, as in (NAME ARGS...), the function (lambda ARGLIST BODY...) is applied to the list ARGS... as it appears in the expression, and the result should be a form to be evaluated instead of the original.

DECL is a declaration, optional, which can specify how to indent calls to this macro, how Edebug should handle it, and which argument should be treated as documentation. It looks like this: (declare SPECS...) The elements can look like this: (indent INDENT) Set NAME's `lisp-indent-function' property to INDENT.

(debug DEBUG)
Set NAME's `edebug-form-spec' property to DEBUG.  (This is
equivalent to writing a `def-edebug-spec' for the macro.)

(doc-string ELT)
Set NAME's `doc-string-elt' property to ELT.

Like `quote', but preferred for objects which are functions. In byte compilation, `function' causes its argument to be compiled. `quote' cannot do that.

Eval args until one of them yields nil, then return nil. The remaining args are not evalled at all. If no arg yields nil, return the last arg's value.

Eval BODY forms sequentially and return value of last one.

Bind variables according to VARLIST then eval BODY. The value of the last form in BODY is returned. Each element of VARLIST is a symbol (which is bound to nil) or a list (SYMBOL VALUEFORM) (which binds SYMBOL to the value of VALUEFORM). Each VALUEFORM can refer to the symbols already bound by this VARLIST.

Define SYMBOL as a variable, and return SYMBOL. You are not required to define a variable in order to use it, but defining it lets you supply an initial value and documentation, which can be referred to by the Emacs help facilities and other programming tools. The `defvar' form also declares the variable as "special", so that it is always dynamically bound even if `lexical-binding' is t.

The optional argument INITVALUE is evaluated, and used to set SYMBOL, only if SYMBOL's value is void. If SYMBOL is buffer-local, its default value is what is set; buffer-local values are not affected. If INITVALUE is missing, SYMBOL's value is not set.

If SYMBOL has a local binding, then this form affects the local binding. This is usually not what you want. Thus, if you need to load a file defining variables, with this form or with `defconst' or `defcustom', you should always load that file outside any bindings for these variables. (defconst' anddefcustom' behave similarly in this respect.)

The optional argument DOCSTRING is a documentation string for the variable.

To define a user option, use defcustom' instead ofdefvar'. The function `user-variable-p' also identifies a variable as a user option if its DOCSTRING starts with *, but this behavior is obsolete.

Throw to the catch for TAG and return VALUE from it. Both TAG and VALUE are evalled.

defined as fn in eval.clj

Eval BODY allowing nonlocal exits using `throw'. TAG is evalled to get the tag to use; it must not be nil.

Then the BODY is executed. Within BODY, a call to throw' with the same TAG exits BODY and thiscatch'. If no throw happens, `catch' returns the value of the last BODY form. If a throw happens, it specifies the value to return from `catch'.

If COND yields non-nil, do THEN, else do ELSE... Returns the value of THEN or the value of the last of the ELSE's. THEN must be one expression, but ELSE... can be zero or more expressions. If COND yields nil, and there are no ELSE's, the value is nil.

Execute BODY, saving and restoring current buffer's restrictions. The buffer's restrictions make parts of the beginning and end invisible. (They are set up with narrow-to-region' and eliminated withwiden'.) This special form, `save-restriction', saves the current buffer's restrictions when it is entered, and restores them when it is exited. So any `narrow-to-region' within BODY lasts only until the end of the form. The old restrictions settings are restored even in case of abnormal exit (throw or error).

The value returned is the value of the last form in BODY.

Note: if you are using both save-excursion' andsave-restriction', use `save-excursion' outermost: (save-excursion (save-restriction ...))

Save point, mark, and current buffer; execute BODY; restore those things. Executes BODY just like `progn'. The values of point, mark and the current buffer are restored even in case of abnormal exit (throw or error). The state of activation of the mark is also restored.

This construct does not save `deactivate-mark', and therefore functions that change the buffer will still cause deactivation of the mark at the end of the command. To prevent that, bind deactivate-mark' withlet'.

If you only want to save the current buffer but not point nor mark, then just use save-current-buffer', or evenwith-current-buffer'.

Specify a way of parsing arguments for interactive use of a function. For example, write (defun foo (arg buf) "Doc string" (interactive "P\nbbuffer: ") .... ) to make ARG be the raw prefix argument, and set BUF to an existing buffer, when `foo' is called as a command. The "call" to `interactive' is actually a declaration rather than a function; it tells `call-interactively' how to read arguments to pass to the function. When actually called, `interactive' just returns nil.

Usually the argument of `interactive' is a string containing a code letter followed optionally by a prompt. (Some code letters do not use I/O to get the argument and do not use prompts.) To get several arguments, concatenate the individual strings, separating them by newline characters. Prompts are passed to format, and may use % escapes to print the arguments that have already been read. If the argument is not a string, it is evaluated to get a list of arguments to pass to the function. Just `(interactive)' means pass no args when calling interactively.

Code letters available are: a -- Function name: symbol with a function definition. b -- Name of existing buffer. B -- Name of buffer, possibly nonexistent. c -- Character (no input method is used). C -- Command name: symbol with interactive function definition. d -- Value of point as number. Does not do I/O. D -- Directory name. e -- Parameterized event (i.e., one that's a list) that invoked this command. If used more than once, the Nth `e' returns the Nth parameterized event. This skips events that are integers or symbols. f -- Existing file name. F -- Possibly nonexistent file name. G -- Possibly nonexistent file name, defaulting to just directory name. i -- Ignored, i.e. always nil. Does not do I/O. k -- Key sequence (downcase the last event if needed to get a definition). K -- Key sequence to be redefined (do not downcase the last event). m -- Value of mark as number. Does not do I/O. M -- Any string. Inherits the current input method. n -- Number read using minibuffer. N -- Numeric prefix arg, or if none, do like code `n'. p -- Prefix arg converted to number. Does not do I/O. P -- Prefix arg in raw form. Does not do I/O. r -- Region: point and mark as 2 numeric args, smallest first. Does no I/O. s -- Any string. Does not inherit the current input method. S -- Any symbol. U -- Mouse up event discarded by a previous k or K argument. v -- Variable name: symbol that is user-variable-p. x -- Lisp expression read but not evaluated. X -- Lisp expression read and evaluated. z -- Coding system. Z -- Coding system, nil if no prefix arg.

In addition, if the string begins with `*', an error is signaled if the buffer is read-only. If `@' appears at the beginning of the string, and if the key sequence used to invoke the command includes any mouse events, then the window associated with the first of those events is selected before the command is run. If the string begins with ^' andshift-select-mode' is non-nil, Emacs first calls the function `handle-shift-selection'. You may use @',*', and `^' together. They are processed in the order that they appear, before reading any arguments.

Save the current buffer; execute BODY; restore the current buffer. Executes BODY just like `progn'.

Navgeet's helper macro, will revisit, basically condition-case but for use from Clojure

Last input event that was part of a command.

If not -1, an object to be read as next command input event.

Function to call to handle deferred actions, after each command. This function is called with no arguments after each command whenever `deferred-action-list' is non-nil.

Last input event.

Non-nil means menu bar, specified Lucid style, needs to be recomputed.

Number of input events between auto-saves. Zero means disable autosaving due to number of characters typed.

You can customize this variable.

Non-nil means generate motion events for mouse motion.

Non-nil if the key sequence activating this command was shift-translated. Shift-translation occurs when there is no binding for the key sequence as entered, but a binding was found by changing an upper-case letter to lower-case, or a shifted function key to an unshifted one.

Normal hook run before each command is executed. If an unhandled error happens in running this hook, the function in which the error occurred is unconditionally removed, since otherwise the error might happen repeatedly and make Emacs nonfunctional.

Keymap that translates key sequences to key sequences during input. This is used mainly for mapping key sequences into some preferred key events (symbols).

The `read-key-sequence' function replaces any subsequence bound by `local-function-key-map' with its binding. More precisely, when the active keymaps have no binding for the current key sequence but `local-function-key-map' binds a suffix of the sequence to a vector or string, `read-key-sequence' replaces the matching suffix with its binding, and continues with the new sequence.

If the binding is a function, it is called with one argument (the prompt) and its return value (a key sequence) is used.

The events that come from bindings in `local-function-key-map' are not themselves looked up in `local-function-key-map'.

For example, suppose local-function-key-map' bindsESC O P' to [f1]. Typing ESC O P' toread-key-sequence' would return [f1]. Typing `C-x ESC O P' would return [?\C-x f1]. If [f1] were a prefix key, typing `ESC O P x' would return [f1 x].

`local-function-key-map' has a separate binding for each terminal device. See Info node `(elisp)Multiple Terminals'. If you need to define a binding on all terminals, change `function-key-map' instead. Initially, `local-function-key-map' is an empty keymap that has `function-key-map' as its parent on all terminal devices.

List of active absolute time timers in order of increasing time.

The ERASE character as set by the user with stty.

Command to run when `help-char' character follows a prefix key. This command is used only when there is no actual binding for that character after that prefix key.

When `input-method-function' is called, hold the previous echo area message. This variable exists because `read-event' clears the echo area before running the input method. It is nil if there was no message.

List of input events to recognize as meaning Help. These work just like the value of `help-char' (see that).

You can customize this variable.

Maximum mouse movement between clicks to make a double-click. On window-system frames, value is the number of pixels the mouse may have moved horizontally or vertically between two clicks to make a double-click. On non window-system frames, value is interpreted in units of 1/8 characters instead of pixels.

This variable is also the threshold for motion of the mouse to count as a drag.

You can customize this variable.

Alist of system-specific X windows key symbols. Each element should have the form (N . SYMBOL) where N is the numeric keysym code (sans the "system-specific" bit 1<<28) and SYMBOL is its name.

`system-key-alist' has a separate binding for each terminal device. See Info node `(elisp)Multiple Terminals'.

List of events to be processed as input by input methods. These events are processed after `unread-command-events', but before actual keyboard input. If there's an active input method, the events are given to `input-method-function'.

Nonzero means echo unfinished commands after this many seconds of pause. The value may be integer or floating point. If the value is zero, don't echo at all.

You can customize this variable.

List of events to be processed as input by input methods. These events are processed before `unread-command-events' and actual keyboard input, but are not given to `input-method-function'.

A mask of additional modifier keys to use with every keyboard character. Emacs applies the modifiers of the character stored here to each keyboard character it reads. For example, after evaluating the expression (setq extra-keyboard-modifiers ?\C-x) all input characters will have the control modifier applied to them.

Note that the character ?\C-@, equivalent to the integer zero, does not count as a control character; rather, it counts as a character with no modifiers; thus, setting `extra-keyboard-modifiers' to zero cancels any modification.

Non-nil means to always spawn a subshell instead of suspending. (Even if the operating system has support for stopping a process.)

Normal hook run after each command is executed. If an unhandled error happens in running this hook, the function in which the error occurred is unconditionally removed, since otherwise the error might happen repeatedly and make Emacs nonfunctional.

How long to display an echo-area message when the minibuffer is active. If the value is not a number, such messages don't time out.

If non-nil, don't ignore events produced by disabled menu items and tool-bar.

Help functions bind this to allow help on disabled menu items and tool-bar buttons.

If non-nil, the function that implements the current input method. It's called with one argument, a printing character that was just read. (That means a character with code 040...0176.) Typically this function uses `read-event' to read additional events. When it does so, it should first bind `input-method-function' to nil so it will not be called recursively.

The function should return a list of zero or more events to be used as input. If it wants to put back some events to be reconsidered, separately, by the input method, it can add them to the beginning of `unread-command-events'.

The input method function can find in `input-method-previous-message' the previous echo area message.

The input method function should refer to the variables input-method-use-echo-area' andinput-method-exit-on-first-char' for guidance on what to do.

Per-terminal keymap that overrides all other local keymaps. If this variable is non-nil, it is used as a keymap instead of the buffer's local map, and the minor mode keymaps and text property keymaps. It also replaces `overriding-local-map'.

This variable is intended to let commands such as `universal-argument' set up a different keymap for reading the next command.

`overriding-terminal-local-map' has a separate binding for each terminal device. See Info node `(elisp)Multiple Terminals'.

If non-nil, the function that implements the display of help. It's called with one argument, the help string to display.

If non-nil, an active region automatically sets the primary selection. If the value is `only', only temporarily active regions (usually made by mouse-dragging or shift-selection) set the window selection.

This takes effect only when Transient Mark mode is enabled.

You can customize this variable.

The last command executed. Normally a symbol with a function definition, but can be whatever was found in the keymap, or whatever the variable `this-command' was set to by that command.

The value `mode-exit' is special; it means that the previous command read an event that told it to exit, and it did so and unread that event. In other words, the present command is the event that made the previous command exit.

The value `kill-region' is special; it means that the previous command was a kill command.

`last-command' has a separate binding for each terminal device. See Info node `(elisp)Multiple Terminals'.

Translate table for local keyboard input, or nil. If non-nil, the value should be a char-table. Each character read from the keyboard is looked up in this char-table. If the value found there is non-nil, then it is used instead of the actual input character.

The value can also be a string or vector, but this is considered obsolete. If it is a string or vector of length N, character codes N and up are left untranslated. In a vector, an element which is nil means "no translation".

This is applied to the characters supplied to input methods, not their output. See also `translation-table-for-input'.

This variable has a separate binding for each terminal. See Info node `(elisp)Multiple Terminals'.

Non-nil means inhibit local map menu bar menus.

You can customize this variable.

List of warnings to be displayed after this command. Each element must be a list (TYPE MESSAGE [LEVEL [BUFFER-NAME]]), as per the args of `display-warning' (which see). If this variable is non-nil, `delayed-warnings-hook' will be run immediately after running `post-command-hook'.

Non-nil means `overriding-local-map' applies to the menu bar. Otherwise, the menu bar continues to reflect the buffer's local map and the minor mode maps regardless of `overriding-local-map'.

The frame in which the most recently read event occurred. If the last event came from a keyboard macro, this is set to `macro'.

Last input event in a command, except for mouse menu events. Mouse menus give back keys that don't look like mouse events; this variable holds the actual mouse event that led to the menu, so that you can determine whether the command was run by mouse or not.

Keymap defining bindings for special events to execute at low level.

Non-nil means prompt with menus when appropriate. This is done when reading from a keymap that has a prompt string, for elements that have prompt strings. The menu is displayed on the screen if X menus were enabled at configuration time and the previous event was a mouse click prefix key. Otherwise, menu prompting uses the echo area.

You can customize this variable.

The parent keymap of all `local-function-key-map' instances. Function key definitions that apply to all terminal devices should go here. If a mapping is defined in both the current `local-function-key-map' binding and this variable, then the local definition will take precedence.

Contents of active region prior to buffer modification. If `select-active-regions' is non-nil, Emacs sets this to the text in the region before modifying the buffer. The next `deactivate-mark' call uses this to set the window selection.

If non-nil, always suppress point adjustment.

The default value is nil, in which case, point adjustment are suppressed only after special commands that set `disable-point-adjustment' (which see) to non-nil.

Interval between polling for input during Lisp execution. The reason for polling is to make C-g work to stop a running program. Polling is needed only when using X windows and SIGIO does not work. Polling is automatically disabled in all other cases.

You can customize this variable.

Keymap that overrides all other local keymaps. If this variable is non-nil, it is used as a keymap--replacing the buffer's local map, the minor mode keymaps, and char property keymaps.

Form to evaluate when Emacs starts up. Useful to set before you dump a modified Emacs.

Keymap that decodes input escape sequences. This is used mainly for mapping ASCII function key sequences into real Emacs function key events (symbols).

The `read-key-sequence' function replaces any subsequence bound by input-decode-map' with its binding. Contrary tofunction-key-map', this map applies its rebinding regardless of the presence of an ordinary binding. So it is more like `key-translation-map' except that it applies before `function-key-map' rather than after.

If the binding is a function, it is called with one argument (the prompt) and its return value (a key sequence) is used.

The events that come from bindings in `input-decode-map' are not themselves looked up in `input-decode-map'.

This variable is keyboard-local.

Last command that may be repeated. The last command executed that was not bound to an input event. This is the command `repeat' will try to repeat.

Number of input events read from the keyboard so far. This does not include events generated by keyboard macros.

If non-nil, any keyboard input throws to this symbol. The value of that variable is passed to `quit-flag' and later causes a peculiar kind of quitting.

Same as `last-command', but never altered by Lisp code.

Character to recognize as meaning Help. When it is read, do `(eval help-form)', and display result if it's a string. If the value of `help-form' is nil, this char can be read normally.

You can customize this variable.

If non-nil, suppress point adjustment after executing a command.

After a command is executed, if point is moved into a region that has special properties (e.g. composition, display), we adjust point to the boundary of the region. But, when a command sets this variable to non-nil, we suppress the point adjustment.

This variable is set to nil before reading a command, and is checked just after executing the command.

Enter debugger on this event. When Emacs receives the special event specified by this variable, it will try to break into the debugger as soon as possible instead of processing the event normally through `special-event-map'.

Currently, the only supported values for this variable are sigusr1' andsigusr2'.

You can customize this variable.

List of deferred actions to be performed at a later time. The precise format isn't relevant here; we just check whether it is nil.

Number of complete key sequences read as input so far. This includes key sequences read from keyboard macros. The number is effectively the number of interactive command invocations.

If non-nil, function to output error messages. The arguments are the error data, a list of the form (SIGNALED-CONDITIONS . SIGNAL-DATA) such as just as `condition-case' would bind its variable to, the context (a string which normally goes at the start of the message), and the Lisp function within which the error was signaled.

Non-nil means show the equivalent key-binding when M-x command has one. The value can be a length of time to show the message for. If the value is non-nil and not a number, we wait 2 seconds.

You can customize this variable.

List of commands which should not update the selection. Normally, if `select-active-regions' is non-nil and the mark remains active after a command (i.e. the mark was not deactivated), the Emacs command loop sets the selection to the text in the region. However, if the command is in this list, the selection is not updated.

List of menu bar items to move to the end of the menu bar. The elements of the list are event types that may have menu bar bindings.

Expression evaluating to the image spec for a tool-bar separator. This is used internally by graphical displays that do not render tool-bar separators natively. Otherwise it is unused (e.g. on GTK).

Maximum time between mouse clicks to make a double-click. Measured in milliseconds. The value nil means disable double-click recognition; t means double-clicks have no time limit and are detected by position only.

You can customize this variable.

Meta-prefix character code. Meta-foo as command input turns into this character followed by foo.

You can customize this variable.

Number of seconds idle time before auto-save. Zero or nil means disable auto-saving due to idleness. After auto-saving due to this many seconds of idle time, Emacs also does a garbage collection if that seems to be warranted.

You can customize this variable.

List of active idle-time timers in order of increasing time.

Normal hook run when clearing the echo area.

The command now being executed. The command can set this variable; whatever is put here will be in `last-command' during the following command.

If an editing command sets this to t, deactivate the mark afterward. The command loop sets this to nil before each command, and tests the value when the command returns. Buffer modification stores t in this variable.

Form to execute when character `help-char' is read. If the form returns a string, that string is displayed. If `help-form' is nil, the help char is not recognized.

List of events to be read as the command input. These events are processed first, before actual keyboard input. Events read from this list are not normally added to `this-command-keys', as they will already have been added once as they were read for the first time. An element of the form (t . EVENT) forces EVENT to be added to that list.

Character to see next line of menu prompt. Type this character while in a menu prompt to rotate around the lines of it.

The command bound to the current key sequence before remapping. It equals `this-command' if the original command was not remapped through any of the active keymaps. Otherwise, the value of `this-command' is the result of looking up the original command in the active keymaps.

Keymap of key translations that can override keymaps. This keymap works like `function-key-map', but comes after that, and its non-prefix bindings override ordinary bindings. Another difference is that it is global rather than keyboard-local.

We bypass Lanterna with System/in but utilize their setup of private mode, see UnixTerminal/enterPrivateMode: (do (require '[clojure.java.shell :as sh]) (sh/sh "/bin/sh" "-c" "/bin/stty -echo < /dev/tty") ;; Disables echo, leave this out for manual testing. (sh/sh "/bin/sh" "-c" "/bin/stty -icanon < /dev/tty") ;; Enable all chars for reading. (sh/sh "/bin/sh" "-c" "/bin/stty min 1 < /dev/tty")) ;; Read single chars.

We report our TERM as "lanterna" to allow terminal-init-lanterna to be run first, then init the real one. All this has only been tested on TERM=xterm input-decode-map is setup in term/xterm. We should also look in local-function-key-map This interfers badly with Lanterna's get-size, occasionally locks up, needs fix.

DEUCE: For reference, this is the main low level read_char function in Emacs. We don't use nmaps (or most arguments yet). We use currentTimeMillis for internal times instead of Emacs style time. Maybe totally revamped, but let's start with something "similar" to Emacs. Is normally called from readkeysequence (C internal version) from commandloop1.

/* read a character from the keyboard; call the redisplay if needed */ /* commandflag 0 means do not autosave, but do redisplay. -1 means do not redisplay, but do autosave. 1 means do both. */

/* The arguments MAPS and NMAPS are for menu prompting. MAPS is an array of keymaps; NMAPS is the length of MAPS.

PREV_EVENT is the previous input event, or nil if we are reading the first event of a key sequence (or not reading a key sequence). If PREV_EVENT is t, that is a "magic" value that says not to run input methods, but in other respects to act as if not reading a key sequence.

If USEDMOUSEMENU is non-null, then we set *USEDMOUSEMENU to 1 if we used a mouse menu to read the input, or zero otherwise. If USEDMOUSEMENU is null, we don't dereference it.

Value is -2 when we find input on another keyboard. A second call to read_char will read it.

If ENDTIME is non-null, it is a pointer to an EMACSTIME specifying the maximum time to wait until. If no input arrives by that time, stop waiting and return nil.

Value is t if we showed a menu and the user rejected it. */

Convert the event description list EVENT-DESC to an event type. EVENT-DESC should contain one base event type (a character or symbol) and zero or more modifier names (control, meta, hyper, super, shift, alt, drag, down, double or triple). The base must be last. The return value is an event type (a character or symbol) which has the same base event type and all the specified modifiers.

Return t if command input is currently available with no wait. Actually, the value is nil only if we can be sure that no input is available; if there is a doubt, the value is t.

Return position information for buffer POS in WINDOW. POS defaults to point in WINDOW; WINDOW defaults to the selected window.

Return nil if position is not visible in window. Otherwise, the return value is similar to that returned by `event-start' for a mouse click at the upper left corner of the glyph corresponding to the given buffer position: (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW) IMAGE (DX . DY) (WIDTH . HEIGHT)) The `posn-' functions access elements of such lists.

Return the raw events that were read for this command. More generally, it returns the last key sequence read, either by the command loop or by `read-key-sequence'. Unlike `this-single-command-keys', this function's value shows the events before all translations (except for input methods). The value is always a vector.

Return vector of last 300 events, not counting those from keyboard macros.

Return information about the way Emacs currently reads keyboard input. The value is a list of the form (INTERRUPT FLOW META QUIT), where INTERRUPT is non-nil if Emacs is using interrupt-driven input; if nil, Emacs is using CBREAK mode. FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the terminal; this does not apply if Emacs uses interrupt-driven input. META is t if accepting 8-bit input with 8th bit as Meta flag. META nil means ignoring the top bit, on the assumption it is parity. META is neither t nor nil if accepting 8-bit input and using all 8 bits as the character code. QUIT is the character Emacs currently uses to quit. The elements of this list correspond to the arguments of `set-input-mode'.

Execute CMD as an editor command. CMD must be a symbol that satisfies the `commandp' predicate. Optional second arg RECORD-FLAG non-nil means unconditionally put this command in `command-history'. Otherwise, that is done only if an arg is read using the minibuffer. The argument KEYS specifies the value to use instead of (this-command-keys) when reading the arguments; if it is nil, (this-command-keys) is used. The argument SPECIAL, if non-nil, means that this command is executing a special event, so ignore the prefix argument and don't clear it.

Stop Emacs and return to superior process. You can resume later. If `cannot-suspend' is non-nil, or if the system doesn't support job control, run a subshell instead.

If optional arg STUFFSTRING is non-nil, its characters are stuffed to be read as terminal input by Emacs's parent, after suspension.

Before suspending, run the normal hook `suspend-hook'. After resumption run the normal hook `suspend-resume-hook'.

Some operating systems cannot stop the Emacs process and resume it later. On such systems, Emacs starts a subshell instead of suspending.

Return the current depth in recursive edits.

Like `read-key-sequence' but always return a vector.

Set mode of reading keyboard input. First arg INTERRUPT non-nil means use input interrupts; nil means use CBREAK mode. Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal (no effect except in CBREAK mode). Third arg META t means accept 8-bit input (for a Meta key). META nil means ignore the top bit, on the assumption it is parity. Otherwise, accept 8-bit input and don't use the top bit for Meta. Optional fourth arg QUIT if non-nil specifies character to use for quitting. See also `current-input-mode'.

Read a sequence of keystrokes and return as a string or vector. The sequence is sufficient to specify a non-prefix command in the current local and global maps.

First arg PROMPT is a prompt string. If nil, do not prompt specially. Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos as a continuation of the previous key.

The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not convert the last event to lower case. (Normally any upper case event is converted to lower case if the original event is undefined and the lower case equivalent is defined.) A non-nil value is appropriate for reading a key sequence to be defined.

A C-g typed while in this function is treated like any other character, and `quit-flag' is not set.

If the key sequence starts with a mouse click, then the sequence is read using the keymaps of the buffer of the window clicked in, not the buffer of the selected window as normal.

`read-key-sequence' drops unbound button-down events, since you normally only care about the click or drag events which follow them. If a drag or multi-click event is unbound, but the corresponding click event would be bound, `read-key-sequence' turns the event into a click event at the drag's starting position. This means that you don't have to distinguish between click and drag, double, or triple events unless you want to.

`read-key-sequence' prefixes mouse events on mode lines, the vertical lines separating windows, and scroll bars with imaginary keys mode-line',vertical-line', and `vertical-scroll-bar'.

Optional fourth argument CAN-RETURN-SWITCH-FRAME non-nil means that this function will process a switch-frame event if the user switches frames before typing anything. If the user switches frames in the middle of a key sequence, or at the start of the sequence but CAN-RETURN-SWITCH-FRAME is nil, then the event will be put off until after the current key sequence.

read-key-sequence' checksfunction-key-map' for function key sequences, where they wouldn't conflict with ordinary bindings. See `function-key-map' for more details.

The optional fifth argument CMD-LOOP, if non-nil, means that this key sequence is being read by something that will read commands one after another. It should be nil if the caller will read just one key sequence.

Return position information for pixel coordinates X and Y. By default, X and Y are relative to text area of the selected window. Optional third arg FRAME-OR-WINDOW non-nil specifies frame or window. If optional fourth arg WHOLE is non-nil, X is relative to the left edge of the window.

The return value is similar to a mouse click position: (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW) IMAGE (DX . DY) (WIDTH . HEIGHT)) The `posn-' functions access elements of such lists.

Start writing all keyboard characters to a dribble file called FILE. If FILE is nil, close any open dribble file. The file will be closed when Emacs exits.

Invoke the editor command loop recursively. To get out of the recursive edit, a command can do `(throw 'exit nil)'; that tells this function to return. Alternatively, `(throw 'exit t)' makes this function signal an error. This function is called by the editor initialization to begin editing.

Return the key sequence that invoked this command, as a vector. However, if the command has called `read-key-sequence', it returns the last key sequence that has been read.

See also `this-command-keys'.

Exit all recursive editing levels. This also exits all active minibuffers.

Read function name, then read its arguments and call it.

To pass a numeric argument to the command you are invoking with, specify the numeric argument to this command.

Noninteractively, the argument PREFIXARG is the prefix argument to give to the command you invoke, if it asks for an argument.

Discard the contents of the terminal input buffer. Also end any kbd macro being defined.

Make the unread events replace the last command and echo. Used in `universal-argument-other-key'.

`universal-argument-other-key' rereads the event just typed. It then gets translated through `function-key-map'. The translated event has to replace the real events, both in the value of (this-command-keys) and in echoing. To achieve this, `universal-argument-other-key' calls `reset-this-command-lengths', which discards the record of reading these events the first time.

Enable or disable 8-bit input on TERMINAL. If META is t, Emacs will accept 8-bit input, and interpret the 8th bit as the Meta modifier.

If META is nil, Emacs will ignore the top bit, on the assumption it is parity.

Otherwise, Emacs will accept and pass through 8-bit input without specially interpreting the top bit.

This setting only has an effect on tty terminal devices.

Optional parameter TERMINAL specifies the tty terminal device to use. It may be a terminal object, a frame, or nil for the terminal used by the currently selected frame.

See also `current-input-mode'.

Return the key sequence that invoked this command. More generally, it returns the last key sequence read, either by the command loop or by `read-key-sequence'. Unlike `this-command-keys', this function's value does not include prefix arguments. The value is always a vector.

Exit from the innermost recursive edit or minibuffer.

Specify character used for quitting. QUIT must be an ASCII character.

This function only has an effect on the controlling tty of the Emacs process.

See also `current-input-mode'.

Abort the command that requested this recursive edit or minibuffer input.

Set interrupt mode of reading keyboard input. If INTERRUPT is non-nil, Emacs will use input interrupts; otherwise Emacs uses CBREAK mode.

See also `current-input-mode'.

Parse the event symbol. For internal use.

Enable or disable ^S/^Q flow control for output to TERMINAL. If FLOW is non-nil, flow control is enabled and you cannot use C-s or C-q in key sequences.

This setting only has an effect on tty terminals and only when Emacs reads input in CBREAK mode; see `set-input-interrupt-mode'.

See also `current-input-mode'.

Return the key sequence that invoked this command. However, if the command has called `read-key-sequence', it returns the last key sequence that has been read. The value is a string or a vector.

See also `this-command-keys-vector'.

Return the current length of Emacs idleness, or nil. The value when Emacs is idle is a list of three integers. The first has the most significant 16 bits of the seconds, while the second has the least significant 16 bits. The third integer gives the microsecond count.

The value when Emacs is not idle is nil.

The microsecond count is zero on systems that do not provide resolution finer than a second.

Clear out the vector that `this-command-keys' returns. Also clear the record of the last 100 events, unless optional arg KEEP-RECORD is non-nil.

Convert following word (or ARG words) to upper case, moving over. With negative argument, convert previous words but do not move. See also `capitalize-word'.

Convert argument to upper case and return that. The argument may be a character or string. The result has the same type. The argument object is not altered--the value is a copy. See also capitalize',downcase' and `upcase-initials'.

Capitalize the following word (or ARG words), moving over. This gives the word(s) a first character in upper case and the rest lower case. With negative argument, capitalize previous words but do not move.

Convert the region to lower case. In programs, wants two arguments. These arguments specify the starting and ending character numbers of the region to operate on. When used as a command, the text between point and the mark is operated on.

Convert the region to capitalized form. Capitalized form means each word's first character is upper case and the rest of it is lower case. In programs, give two arguments, the starting and ending character positions to operate on.

Convert the initial of each word in the argument to upper case. Do not change the other letters of each word. The argument may be a character or string. The result has the same type. The argument object is not altered--the value is a copy.

Convert following word (or ARG words) to lower case, moving over. With negative argument, convert previous words but do not move.

Convert the region to upper case. In programs, wants two arguments. These arguments specify the starting and ending character numbers of the region to operate on. When used as a command, the text between point and the mark is operated on. See also `capitalize-region'.

Convert argument to capitalized form and return that. This means that each word's first character is upper case and the rest is lower case. The argument may be a character or string. The result has the same type. The argument object is not altered--the value is a copy.

Upcase the initial of each word in the region. Subsequent letters of each word are not changed. In programs, give two arguments, the starting and ending character positions to operate on.

Convert argument to lower case and return that. The argument may be a character or string. The result has the same type. The argument object is not altered--the value is a copy.

Function to adjust composition of buffer text.

This function is called with three arguments: FROM, TO, and OBJECT. FROM and TO specify the range of text whose composition should be adjusted. OBJECT, if non-nil, is a string that contains the text.

This function is called after a text with `composition' property is inserted or deleted to keep `composition' property of buffer text valid.

The default value is the function `compose-chars-after'.

Non-nil if Auto-Composition mode is enabled. Use the command `auto-composition-mode' to change this variable.

Function to call to compose characters automatically. This function is called from the display routine with four arguments: FROM, TO, WINDOW, and STRING.

If STRING is nil, the function must compose characters in the region between FROM and TO in the current buffer.

Otherwise, STRING is a string, and FROM and TO are indices into the string. In this case, the function must compose characters in the string.

Char-table of functions for automatic character composition. For each character that has to be composed automatically with preceding and/or following characters, this char-table contains a function to call to compose that character.

The element at index C in the table, if non-nil, is a list of composition rules of this form: ([PATTERN PREV-CHARS FUNC] ...)

PATTERN is a regular expression which C and the surrounding characters must match.

PREV-CHARS is a non-negative integer (less than 4) specifying how many characters before C to check the matching with PATTERN. If it is 0, PATTERN must match C and the following characters. If it is 1, PATTERN must match a character before C and the following characters.

If PREV-CHARS is 0, PATTERN can be nil, which means that the single character C should be composed.

FUNC is a function to return a glyph-string representing a composition of the characters that match PATTERN. It is called with one argument GSTRING.

GSTRING is a template of a glyph-string to return. It is already filled with a proper header for the characters to compose, and glyphs corresponding to those characters one by one. The function must return a new glyph-string with the same header as GSTRING, or modify GSTRING itself and return it.

See also the documentation of `auto-composition-mode'.

Internal use only.

Return information about composition at or nearest to position POS. See `find-composition' for more details.

Internal use only.

Compose text between indices START and END of STRING. Optional 4th and 5th arguments are COMPONENTS and MODIFICATION-FUNC for the composition. See `compose-string' for more details.

Internal use only.

Compose text in the region between START and END. Optional 3rd and 4th arguments are COMPONENTS and MODIFICATION-FUNC for the composition. See `compose-region' for more details.

Return a glyph-string for characters between FROM and TO. If the glyph string is for graphic display, FONT-OBJECT must be a font-object to use for those characters. Otherwise (for terminal display), FONT-OBJECT must be a terminal ID, a frame, or nil for the selected frame's terminal device.

If the optional 4th argument STRING is not nil, it is a string containing the target characters between indices FROM and TO.

A glyph-string is a vector containing information about how to display a specific character sequence. The format is: [HEADER ID GLYPH ...]

HEADER is a vector of this form: [FONT-OBJECT CHAR ...] where FONT-OBJECT is a font-object for all glyphs in the glyph-string, or the terminal coding system of the specified terminal. CHARs are characters to be composed by GLYPHs.

ID is an identification number of the glyph-string. It may be nil if not yet shaped.

GLYPH is a vector whose elements have this form: [ FROM-IDX TO-IDX C CODE WIDTH LBEARING RBEARING ASCENT DESCENT [ [X-OFF Y-OFF WADJUST] | nil] ] where FROM-IDX and TO-IDX are used internally and should not be touched. C is the character of the glyph. CODE is the glyph-code of C in FONT-OBJECT. WIDTH thru DESCENT are the metrics (in pixels) of the glyph. X-OFF and Y-OFF are offsets to the base position for the glyph. WADJUST is the adjustment to the normal width of the glyph.

If GLYPH is nil, the remaining elements of the glyph-string vector should be ignored.

Set to non-nil when `read' encounters an old-style backquote.

List of values of all expressions which were read, evaluated and printed. Order is reverse chronological.

Non-nil means force printing messages when loading Lisp files. This overrides the value of the NOMESSAGE argument to `load'.

If non-nil, add position of read symbols to `read-symbol-positions-list'.

If this variable is a buffer, then only forms read from that buffer will be added to `read-symbol-positions-list'. If this variable is t, then all read forms will be added. The effect of all other values other than nil are not currently defined, although they may be in the future.

The positions are relative to the last call to `read' or `read-from-string'. It is probably a bad idea to set this variable at the toplevel; bind it instead.

A list mapping read symbols to their positions. This variable is modified during calls to `read' or read-from-string', but only whenread-with-symbol-positions' is non-nil.

Each element of the list looks like (SYMBOL . CHAR-POSITION), where CHAR-POSITION is an integer giving the offset of that occurrence of the symbol from the position where read' orread-from-string' started.

Note that a symbol will appear multiple times in this list, if it was read multiple times. The list is in the same order as the symbols were read in.

*List of directories to search for files to load. Each element is a string (directory name) or nil (try default directory). Initialized based on EMACSLOADPATH environment variable, if any, otherwise to default specified by file `epaths.h' when Emacs was built.

Alist mapping loaded file names to symbols and features. Each alist element should be a list (FILE-NAME ENTRIES...), where FILE-NAME is the name of a file that has been loaded into Emacs. The file name is absolute and true (i.e. it doesn't contain symlinks). As an exception, one of the alist elements may have FILE-NAME nil, for symbols and features not associated with any file.

The remaining ENTRIES in the alist element describe the functions and variables defined in that file, the features provided, and the features required. Each entry has the form `(provide . FEATURE)', (require . FEATURE)',(defun . FUNCTION)', `(autoload . SYMBOL)', (defface . SYMBOL)', or(t . SYMBOL)'. Entries like `(t . SYMBOL)' may precede a `(defun . FUNCTION)' entry, and means that SYMBOL was an autoload before this file redefined it as a function. In addition, entries may also be single symbols, which means that SYMBOL was defined by defvar' ordefconst'.

During preloading, the file name recorded is relative to the main Lisp directory. These file names are converted to absolute at startup.

File name, including directory, of user's initialization file. If the file loaded had extension `.elc', and the corresponding source file exists, this variable contains the name of source file, suitable for use by functions like `custom-save-all' which edit the init file. While Emacs loads and evaluates the init file, value is the real name of the file, regardless of whether or not it has the `.elc' extension.

List of files that were preloaded (when dumping Emacs).

Regular expression matching safe to load compiled Lisp files. When Emacs loads a compiled Lisp file, it reads the first 512 bytes from the file, and matches them against this regular expression. When the regular expression matches, the file is considered to be safe to load. See also `load-dangerous-libraries'.

Full name of file being loaded by `load'.

List of suffixes for (compiled or source) Emacs Lisp files. This list should not include the empty string. `load' and related functions try to append these suffixes, in order, to the specified file name if a Lisp suffix is allowed or required.

Non-nil means `read' converts strings to unibyte whenever possible. This is normally bound by load' andeval-buffer' to control `read', and is not meant for users to change.

List of suffixes that indicate representations of the same file. This list should normally start with the empty string.

Enabling Auto Compression mode appends the suffixes in `jka-compr-load-suffixes' to this list and disabling Auto Compression mode removes them again. `load' and related functions use this list to determine whether they should look for compressed versions of a file and, if so, which suffixes they should try to append to the file name in order to do so. However, if you want to customize which suffixes the loading functions recognize as compression suffixes, you should customize `jka-compr-load-suffixes' rather than the present variable.

Function called in `load' for loading an Emacs Lisp source file. This function is for doing code conversion before reading the source file. If nil, loading is done without any code conversion. Arguments are FULLNAME, FILE, NOERROR, NOMESSAGE, where FULLNAME is the full name of FILE. See `load' for the meaning of the remaining arguments.

Function used by load' andeval-region' for reading expressions. The default is nil, which means use the function `read'.

Symbol table for use by intern' andread'. It is a vector whose length ought to be prime for best results. The vector's contents don't make sense if examined from Lisp programs; to find all the symbols in an obarray, use `mapatoms'.

Non-nil means read recursive structures using #N= and #N# syntax.

List of buffers being read from by calls to eval-buffer' andeval-region'.

Non-nil means `load' should force-load all dynamic doc strings. This is useful when the file being loaded is a temporary copy.

List of all DEFVAR_BOOL variables, used by the byte code optimizer.

An alist of expressions to be evalled when particular files are loaded. Each element looks like (REGEXP-OR-FEATURE FORMS...).

REGEXP-OR-FEATURE is either a regular expression to match file names, or a symbol (a feature name).

When `load' is run and the file-name argument matches an element's REGEXP-OR-FEATURE, or when `provide' is run and provides the symbol REGEXP-OR-FEATURE, the FORMS in the element are executed.

An error in FORMS does not undo the load, but does prevent execution of the rest of the FORMS.

Non-nil if inside of `load'.

Non-nil means load dangerous compiled Lisp files. Some versions of XEmacs use different byte codes than Emacs. These incompatible byte codes can make Emacs crash when it tries to execute them.

Used for internal purposes by `load'.

Directory in which Emacs sources were found when Emacs was built. You cannot count on them to still be there!

Whether to use lexical binding when evaluating code. Non-nil means that the code in the current buffer should be evaluated with lexical binding. This variable is automatically set from the file variables of an interpreted Lisp file read using `load'. Unlike other file local variables, this must be set in the first line of a file.

Stream for read to get input from. See documentation of `read' for possible values.

Read an event object from the input stream. If the optional argument PROMPT is non-nil, display that as a prompt. If the optional argument INHERIT-INPUT-METHOD is non-nil and some input method is turned on in the current buffer, that input method is used for reading a character. If the optional argument SECONDS is non-nil, it should be a number specifying the maximum number of seconds to wait for input. If no input arrives in that time, return nil. SECONDS may be a floating-point value.

Read a character from the command input (keyboard or macro). It is returned as a number. Non-character events are ignored. If the character has modifiers, they are resolved and reflected to the character code if possible (e.g. C-SPC -> 0).

If the optional argument PROMPT is non-nil, display that as a prompt. If the optional argument INHERIT-INPUT-METHOD is non-nil and some input method is turned on in the current buffer, that input method is used for reading a character. If the optional argument SECONDS is non-nil, it should be a number specifying the maximum number of seconds to wait for input. If no input arrives in that time, return nil. SECONDS may be a floating-point value.

Read one Lisp expression as text from STREAM, return as Lisp object. If STREAM is nil, use the value of `standard-input' (which see). STREAM or the value of `standard-input' may be: a buffer (read from point and advance it) a marker (read from where it points and advance it) a function (call it with no arguments for each character, call it with a char as argument to push a char back) a string (takes text from string, starting at the beginning) t (read text line using minibuffer and use it, or read from standard input in batch mode).

Read a character from the command input (keyboard or macro). It is returned as a number. If the character has modifiers, they are resolved and reflected to the character code if possible (e.g. C-SPC -> 0).

If the user generates an event which is not a character (i.e. a mouse click or function key event), `read-char' signals an error. As an exception, switch-frame events are put off until non-character events can be read. If you want to read non-character events, or ignore them, call read-event' orread-char-exclusive' instead.

If the optional argument PROMPT is non-nil, display that as a prompt. If the optional argument INHERIT-INPUT-METHOD is non-nil and some input method is turned on in the current buffer, that input method is used for reading a character. If the optional argument SECONDS is non-nil, it should be a number specifying the maximum number of seconds to wait for input. If no input arrives in that time, return nil. SECONDS may be a floating-point value.

Execute the current buffer as Lisp code. When called from a Lisp program (i.e., not interactively), this function accepts up to five optional arguments: BUFFER is the buffer to evaluate (nil means use current buffer). PRINTFLAG controls printing of output: A value of nil means discard it; anything else is stream for print. FILENAME specifies the file name to use for `load-history'. UNIBYTE, if non-nil, specifies `load-convert-to-unibyte' for this invocation. DO-ALLOW-PRINT, if non-nil, specifies that `print' and related functions should work normally even if PRINTFLAG is nil.

This function preserves the position of point.

Read one Lisp expression which is represented as text by STRING. Returns a cons: (OBJECT-READ . FINAL-STRING-INDEX). FINAL-STRING-INDEX is an integer giving the position of the next remaining character in STRING. START and END optionally delimit a substring of STRING from which to read; they default to 0 and (length STRING) respectively.

Execute the region as Lisp code. When called from programs, expects two arguments, giving starting and ending indices in the current buffer of the text to be executed. Programs can pass third argument PRINTFLAG which controls output: A value of nil means discard it; anything else is stream for printing it. Also the fourth argument READ-FUNCTION, if non-nil, is used instead of `read' to read each expression. It gets one argument which is the input stream for reading characters.

This function does not move point.

Return the canonical symbol whose name is STRING. If there is none, one is created by this function and returned. A second optional argument specifies the obarray to use; it defaults to the value of `obarray'.

Return the suffixes that `load' should try if a suffix is required. This uses the variables load-suffixes' andload-file-rep-suffixes'.

Execute a file of Lisp code named FILE. First try FILE with .elc' appended, then try with.el', then try FILE unmodified (the exact suffixes in the exact order are determined by `load-suffixes'). Environment variable references in FILE are replaced with their values by calling `substitute-in-file-name'. This function searches the directories in `load-path'.

If optional second arg NOERROR is non-nil, report no error if FILE doesn't exist. Print messages at start and end of loading unless optional third arg NOMESSAGE is non-nil (but `force-load-messages' overrides that). If optional fourth arg NOSUFFIX is non-nil, don't try adding suffixes .elc' or.el' to the specified name FILE. If optional fifth arg MUST-SUFFIX is non-nil, insist on the suffix .elc' or.el'; don't accept just FILE unless it ends in one of those suffixes or includes a directory name.

If this function fails to find a file, it may look for different representations of that file before trying another file. It does so by adding the non-empty suffixes in `load-file-rep-suffixes' to the file name. Emacs uses this feature mainly to find compressed versions of files when Auto Compression mode is enabled.

The exact suffixes that this function tries out, in the exact order, are given by the value of the variable `load-file-rep-suffixes' if NOSUFFIX is non-nil and by the return value of the function `get-load-suffixes' if MUST-SUFFIX is non-nil. If both NOSUFFIX and MUST-SUFFIX are nil, this function first tries out the latter suffixes and then the former.

Loading a file records its definitions, and its `provide' and require' calls, in an element ofload-history' whose car is the file name loaded. See `load-history'.

While the file is in the process of being loaded, the variable load-in-progress' is non-nil and the variableload-file-name' is bound to the file's name.

Return t if the file exists and loads successfully.

Call FUNCTION on every symbol in OBARRAY. OBARRAY defaults to the value of `obarray'.

Search for FILENAME through PATH. Returns the file's name in absolute form, or nil if not found. If SUFFIXES is non-nil, it should be a list of suffixes to append to file name when searching. If non-nil, PREDICATE is used instead of `file-readable-p'. PREDICATE can also be an integer to pass to the access(2) function, in which case file-name-handlers are ignored. This function will normally skip directories, so if you want it to find directories, make sure the PREDICATE function returns `dir-ok' for them.

Delete the symbol named NAME, if any, from OBARRAY. The value is t if a symbol was found and deleted, nil otherwise. NAME may be a string or a symbol. If it is a symbol, that symbol is deleted, if it belongs to OBARRAY--no other symbol is deleted. OBARRAY defaults to the value of the variable `obarray'.

Don't use this yourself.

Return the canonical symbol named NAME, or nil if none exists. NAME may be a string or a symbol. If it is a symbol, that exact symbol is searched for. A second optional argument specifies the obarray to use; it defaults to the value of `obarray'.

*Indentation can insert tabs if this is non-nil.

You can customize this variable.

Return the indentation of the current line. This is the horizontal position of the character following any initial whitespace.

Return the horizontal position of point. Beginning of line is column 0. This is calculated by adding together the widths of all the displayed representations of the character between the start of the previous line and point (eg. control characters will have a width of 2 or 4, tabs will have a variable width). Ignores finite width of frame, which means that this function may return values greater than (frame-width). Whether the line is visible (if `selective-display' is t) has no effect; however, ^M is treated as end of line when `selective-display' is t. Text that has an invisible property is considered as having width 0, unless `buffer-invisibility-spec' specifies that it is replaced by an ellipsis.

Scan through the current buffer, calculating screen position. Scan the current buffer forward from offset FROM, assuming it is at position FROMPOS--a cons of the form (HPOS . VPOS)-- to position TO or position TOPOS--another cons of the form (HPOS . VPOS)-- and return the ending buffer position and screen location.

If TOPOS is nil, the actual width and height of the window's text area are used.

There are three additional arguments:

WIDTH is the number of columns available to display text; this affects handling of continuation lines. A value of nil corresponds to the actual number of available text columns.

OFFSETS is either nil or a cons cell (HSCROLL . TAB-OFFSET). HSCROLL is the number of columns not being displayed at the left margin; this is usually taken from a window's hscroll member. TAB-OFFSET is the number of columns of the first tab that aren't being displayed, perhaps because the line was continued within it. If OFFSETS is nil, HSCROLL and TAB-OFFSET are assumed to be zero.

WINDOW is the window to operate on. It is used to choose the display table; if it is showing the current buffer, it is used also for deciding which overlay properties apply. Note that `compute-motion' always operates on the current buffer.

The value is a list of five elements: (POS HPOS VPOS PREVHPOS CONTIN) POS is the buffer position where the scan stopped. VPOS is the vertical position where the scan stopped. HPOS is the horizontal position where the scan stopped.

PREVHPOS is the horizontal position one character back from POS. CONTIN is t if a line was continued after (or within) the previous character.

For example, to find the buffer position of column COL of line LINE of a certain window, pass the window's starting location as FROM and the window's upper-left coordinates as FROMPOS. Pass the buffer's (point-max) as TO, to limit the scan to the end of the visible section of the buffer, and pass LINE and COL as TOPOS.

Indent from point with tabs and spaces until COLUMN is reached. Optional second argument MINIMUM says always do at least MINIMUM spaces even if that goes past COLUMN; by default, MINIMUM is zero.

The return value is COLUMN.

Move point to column COLUMN in the current line. Interactively, COLUMN is the value of prefix numeric argument. The column of a character is calculated by adding together the widths as displayed of the previous characters in the line. This function ignores line-continuation; there is no upper limit on the column number a character can have and horizontal scrolling has no effect.

If specified column is within a character, point goes after that character. If it's past end of line, point goes to end of line.

Optional second argument FORCE non-nil means if COLUMN is in the middle of a tab character, change it to spaces. In addition, if FORCE is t, and the line is too short to reach COLUMN, add spaces/tabs to get there.

The return value is the current column.

Move point to start of the screen line LINES lines down. If LINES is negative, this means moving up.

This function is an ordinary cursor motion function which calculates the new position based on how text would be displayed. The new position may be the start of a line, or just the start of a continuation line. The function returns number of screen lines moved over; that usually equals LINES, but may be closer to zero if beginning or end of buffer was reached.

The optional second argument WINDOW specifies the window to use for parameters such as width, horizontal scrolling, and so on. The default is to use the selected window's parameters.

LINES can optionally take the form (COLS . LINES), in which case the motion will not stop at the start of a screen line but on its column COLS (if such exists on that line, that is).

`vertical-motion' always uses the current buffer, regardless of which buffer is displayed in WINDOW. This is consistent with other cursor motion functions and makes it possible to use `vertical-motion' in any buffer, whether or not it is currently displayed in some window.

Truncate a floating point number to an integral float value. Rounds the value toward zero.

Return the tangent of ARG.

Return the inverse tangent of the arguments. If only one argument Y is given, return the inverse tangent of Y. If two arguments Y and X are given, return the inverse tangent of Y divided by X, i.e. the angle in radians between the vector (X, Y) and the x-axis.

Return the exponential ARG1 ** ARG2.

Return the square root of ARG.

Return the absolute value of ARG.

Construct number X from significand SGNFCAND and exponent EXP. Returns the floating point value resulting from multiplying SGNFCAND (the significand) by 2 raised to the power of EXP (the exponent).

Return the smallest integer no less than ARG, as a float. (Round toward +inf.)

Return the floating point number equal to ARG.

Return the natural logarithm of ARG. If the optional argument BASE is given, return log ARG using that base.

Return the largest integer no greater than ARG. This rounds the value towards -inf. With optional DIVISOR, return the largest integer no greater than ARG/DIVISOR.

Return the nearest integer to ARG. With optional DIVISOR, return the nearest integer to ARG/DIVISOR.

Rounding a value equidistant between two integers may choose the integer closer to zero, or it may prefer an even integer, depending on your machine. For example, (round 2.5) can return 3 on some systems, but 2 on others.

Return the logarithm base 10 of ARG.

Return non nil iff argument X is a NaN.

Return the largest integer no greater than ARG, as a float. (Round towards -inf.)

Truncate a floating point number to an int. Rounds ARG toward zero. With optional DIVISOR, truncate ARG/DIVISOR.

Return the smallest integer no less than ARG. This rounds the value towards +inf. With optional DIVISOR, return the smallest integer no less than ARG/DIVISOR.

Return the sine of ARG.

Copy sign of X2 to value of X1, and return the result. Cause an error if X1 or X2 is not a float.

Return the inverse sine of ARG.

Return the nearest integer to ARG, as a float.

Return the inverse cosine of ARG.

Get significand and exponent of a floating point number. Breaks the floating point number X into its binary significand SGNFCAND (a floating point value between 0.5 (included) and 1.0 (excluded)) and an integral exponent EXP for 2, such that:

X = SGNFCAND * 2^EXP

The function returns the cons cell (SGNFCAND . EXP). If X is zero, both parts (SGNFCAND and EXP) are zero.

Return the exponential base e of ARG.

Return the cosine of ARG.

Returns largest integer <= the base 2 log of the magnitude of ARG. This is the same as the exponent of a float.

Used internally by the `combine-after-change-calls' macro.

Non-nil means enable debugging checks for invalid marker positions.

Non-nil means don't run any of the hooks that respond to buffer changes. This affects before-change-functions' andafter-change-functions', as well as hooks attached to text properties and overlays.

This function is for use internally in `combine-after-change-calls'.

Vector of valid font weight values. Each element has the form: [NUMERIC-VALUE SYMBOLIC-NAME ALIAS-NAME ...] NUMERIC-VALUE is an integer, and SYMBOLIC-NAME and ALIAS-NAME are symbols.

Alist of fontname patterns vs the corresponding encoding and repertory info. Each element looks like (REGEXP . (ENCODING . REPERTORY)), where ENCODING is a charset or a char-table, and REPERTORY is a charset, a char-table, or nil.

If ENCODING and REPERTORY are the same, the element can have the form (REGEXP . ENCODING).

ENCODING is for converting a character to a glyph code of the font. If ENCODING is a charset, encoding a character by the charset gives the corresponding glyph code. If ENCODING is a char-table, looking up the table by a character gives the corresponding glyph code.

REPERTORY specifies a repertory of characters supported by the font. If REPERTORY is a charset, all characters belonging to the charset are supported. If REPERTORY is a char-table, all characters who have a non-nil value in the table are supported. If REPERTORY is nil, Emacs gets the repertory information by an opened font and ENCODING.

*Logging list of font related actions and results. The value t means to suppress the logging. The initial value is set to nil if the environment variable EMACSFONTLOG is set. Otherwise, it is set to t.

Alist of font width symbols vs the corresponding numeric values. See `font-weight-table' for the format of the vector.

Vector of font slant symbols vs the corresponding numeric values. See `font-weight-table' for the format of the vector.

Return XLFD name of FONT. FONT is a font-spec, font-entity, or font-object. If the name is too long for XLFD (maximum 255 chars), return nil. If the 2nd optional arg FOLD-WILDCARDS is non-nil, the consecutive wildcards are folded into one.

Return a font-object for displaying a character at POSITION. Optional second arg WINDOW, if non-nil, is a window displaying the current buffer. It defaults to the currently selected window.

Return a list of variation glyphs for CHAR in FONT-OBJECT. Each element of the value is a cons (VARIATION-SELECTOR . GLYPH-ID), where VARIATION-SELECTOR is a character code of variation selection (#xFE00..#xFE0F or #xE0100..#xE01EF) GLYPH-ID is a glyph code of the corresponding variation glyph.

Open FONT-ENTITY.

List available fonts matching FONT-SPEC on the current frame. Optional 2nd argument FRAME specifies the target frame. Optional 3rd argument NUM, if non-nil, limits the number of returned fonts. Optional 4th argument PREFER, if non-nil, is a font-spec to control the order of the returned list. Fonts are sorted by how close they are to PREFER.

Return a vector of FONT-OBJECT's glyphs for the specified characters. FROM and TO are positions (integers or markers) specifying a region of the current buffer. If the optional fourth arg OBJECT is not nil, it is a string or a vector containing the target characters.

Each element is a vector containing information of a glyph in this format: [FROM-IDX TO-IDX C CODE WIDTH LBEARING RBEARING ASCENT DESCENT ADJUSTMENT] where FROM is an index numbers of a character the glyph corresponds to. TO is the same as FROM. C is the character of the glyph. CODE is the glyph-code of C in FONT-OBJECT. WIDTH thru DESCENT are the metrics (in pixels) of the glyph. ADJUSTMENT is always nil. If FONT-OBJECT doesn't have a glyph for a character, the corresponding element is nil.

Set one property of FONT: give property KEY value VAL. FONT is a font-spec, a font-entity, or a font-object.

If FONT is a font-spec, KEY can be any symbol. But if KEY is the one accepted by the function `font-spec' (which see), VAL must be what allowed in `font-spec'.

If FONT is a font-entity or a font-object, KEY must not be the one accepted by `font-spec'.

Return a newly created font-spec with arguments as properties.

ARGS must come in pairs KEY VALUE of font properties. KEY must be a valid font property name listed below:

:family',:weight', :slant',:width'

They are the same as face attributes of the same name. See `set-face-attribute'.

`:foundry'

VALUE must be a string or a symbol specifying the font foundry, e.g. ``misc''.

`:adstyle'

VALUE must be a string or a symbol specifying the additional typographic style information of a font, e.g. ``sans''.

`:registry'

VALUE must be a string or a symbol specifying the charset registry and encoding of a font, e.g. ``iso8859-1''.

`:size'

VALUE must be a non-negative integer or a floating point number specifying the font size. It specifies the font size in pixels (if VALUE is an integer), or in points (if VALUE is a float).

`:name'

VALUE must be a string of XLFD-style or fontconfig-style font name.

`:script'

VALUE must be a symbol representing a script that the font must support. It may be a symbol representing a subgroup of a script listed in the variable `script-representative-chars'.

`:lang'

VALUE must be a symbol of two-letter ISO-639 language names, e.g. `ja'.

`:otf'

VALUE must be a list (SCRIPT-TAG LANGSYS-TAG GSUB [ GPOS ]) to specify required OpenType features.

SCRIPT-TAG: OpenType script tag symbol (e.g. `deva').
LANGSYS-TAG: OpenType language system tag symbol,
   or nil for the default language system.
GSUB: List of OpenType GSUB feature tag symbols, or nil if none required.
GPOS: List of OpenType GPOS feature tag symbols, or nil if none required.

GSUB and GPOS may contain `nil' element. In such a case, the font must not have any of the remaining elements.

For instance, if the VALUE is `(thai nil nil (mark))', the font must be an OpenType font whose GPOS table of `thai' script's default language system must contain `mark' feature.

Return a font-entity matching with FONT-SPEC on the current frame. Optional 2nd argument FRAME, if non-nil, specifies the target frame.

Shape the glyph-string GSTRING. Shaping means substituting glyphs and/or adjusting positions of glyphs to get the correct visual image of character sequences set in the header of the glyph-string.

If the shaping was successful, the value is GSTRING itself or a newly created glyph-string. Otherwise, the value is nil.

Return information about FONT-OBJECT. The value is a vector: [ NAME FILENAME PIXEL-SIZE SIZE ASCENT DESCENT SPACE-WIDTH AVERAGE-WIDTH CAPABILITY ]

NAME is the font name, a string (or nil if the font backend doesn't provide a name).

FILENAME is the font file name, a string (or nil if the font backend doesn't provide a file name).

PIXEL-SIZE is a pixel size by which the font is opened.

SIZE is a maximum advance width of the font in pixels.

ASCENT, DESCENT, SPACE-WIDTH, AVERAGE-WIDTH are metrics of the font in pixels.

CAPABILITY is a list whose first element is a symbol representing the font format (x, opentype, truetype, type1, pcf, or bdf) and the remaining elements describe the details of the font capability.

If the font is OpenType font, the form of the list is (opentype GSUB GPOS) where GSUB shows which "GSUB" features the font supports, and GPOS shows which "GPOS" features the font supports. Both GSUB and GPOS are lists of the format: ((SCRIPT (LANGSYS FEATURE ...) ...) ...)

If the font is not OpenType font, currently the length of the form is one.

SCRIPT is a symbol representing OpenType script tag.

LANGSYS is a symbol representing OpenType langsys tag, or nil representing the default langsys.

FEATURE is a symbol representing OpenType feature tag.

If the font is not OpenType font, CAPABILITY is nil.

Return the value of FONT's property KEY. FONT is a font-spec, a font-entity, or a font-object. KEY is any symbol, but these are reserved for specific meanings: :family, :weight, :slant, :width, :foundry, :adstyle, :registry, :size, :name, :script, :otf See the documentation of `font-spec' for their meanings. In addition, if FONT is a font-entity or a font-object, values of :script and :otf are different from those of a font-spec as below:

The value of :script may be a list of scripts that are supported by the font.

The value of :otf is a cons (GSUB . GPOS) where GSUB and GPOS are lists representing the OpenType features supported by the font by this form: ((SCRIPT (LANGSYS FEATURE ...) ...) ...) SCRIPT, LANGSYS, and FEATURE are all symbols representing OpenType Layout tags.

Return t if OBJECT is a font-spec, font-entity, or font-object. Return nil otherwise. Optional 2nd argument EXTRA-TYPE, if non-nil, specifies to check which kind of font it is. It must be one of font-spec',font-entity', `font-object'.

Return t if and only if font-spec SPEC matches with FONT. FONT is a font-spec, font-entity, or font-object.

List available font families on the current frame. Optional argument FRAME, if non-nil, specifies the target frame.

Clear font cache.

Close FONT-OBJECT.

Property-list used as default values. The value of a property in this list is seen as the value for every character that does not have its own value for that property.

Alist of properties vs the corresponding non-stickiness. Each element has the form (PROPERTY . NONSTICKINESS).

If a character in a buffer has PROPERTY, new text inserted adjacent to the character doesn't inherit PROPERTY if NONSTICKINESS is non-nil, inherits it if NONSTICKINESS is nil. The `front-sticky' and `rear-nonsticky' properties of the character override NONSTICKINESS.

Alist of alternative properties for properties without a value. Each element should look like (PROPERTY ALTERNATIVE1 ALTERNATIVE2...). If a piece of text has no direct value for a particular property, then this alist is consulted. If that property appears in the alist, then the first non-nil value from the associated alternative properties is returned.

If non-nil, don't run point-left' andpoint-entered' text properties. This also inhibits the use of the `intangible' text property.

Return the position of next text property or overlay change. This scans characters forward in the current buffer from POSITION till it finds a change in some text property, or the beginning or end of an overlay, and returns the position of that. If none is found up to (point-max), the function returns (point-max).

If the optional second argument LIMIT is non-nil, don't search past position LIMIT; return LIMIT if nothing is found before LIMIT. LIMIT is a no-op if it is greater than (point-max).

Remove some properties from text from START to END. The third argument LIST-OF-PROPERTIES is a list of property names to remove. If the optional fourth argument OBJECT is a buffer (or nil, which means the current buffer), START and END are buffer positions (integers or markers). If OBJECT is a string, START and END are 0-based indices into it. Return t if any property was actually removed, nil otherwise.

Return the position of next property change. Scans characters forward from POSITION in OBJECT till it finds a change in some text property, then returns the position of the change. If the optional second argument OBJECT is a buffer (or nil, which means the current buffer), POSITION is a buffer position (integer or marker). If OBJECT is a string, POSITION is a 0-based index into it. Return nil if the property is constant all the way to the end of OBJECT. If the value is non-nil, it is a position greater than POSITION, never equal.

If the optional third argument LIMIT is non-nil, don't search past position LIMIT; return LIMIT if nothing is found before LIMIT.

Check text from START to END for property PROPERTY not equaling VALUE. If so, return the position of the first character whose property PROPERTY is not `eq' to VALUE. Otherwise, return nil. If the optional fifth argument OBJECT is a buffer (or nil, which means the current buffer), START and END are buffer positions (integers or markers). If OBJECT is a string, START and END are 0-based indices into it.

Add properties to the text from START to END. The third argument PROPERTIES is a property list specifying the property values to add. If the optional fourth argument OBJECT is a buffer (or nil, which means the current buffer), START and END are buffer positions (integers or markers). If OBJECT is a string, START and END are 0-based indices into it. Return t if any property value actually changed, nil otherwise.

Return the position of previous text property or overlay change for a specific property. Scans characters backward from POSITION till it finds a change in the PROP property, then returns the position of the change. If the optional third argument OBJECT is a buffer (or nil, which means the current buffer), POSITION is a buffer position (integer or marker). If OBJECT is a string, POSITION is a 0-based index into it.

In a string, scan runs to the start of the string. In a buffer, it runs to (point-min), and the value cannot be less than that.

The property values are compared with `eq'. If the property is constant all the way to the start of OBJECT, return the first valid position in OBJECT. If the optional fourth argument LIMIT is non-nil, don't search back past position LIMIT; return LIMIT if nothing is found before reaching LIMIT.

Check text from START to END for property PROPERTY equaling VALUE. If so, return the position of the first character whose property PROPERTY is `eq' to VALUE. Otherwise return nil. If the optional fifth argument OBJECT is a buffer (or nil, which means the current buffer), START and END are buffer positions (integers or markers). If OBJECT is a string, START and END are 0-based indices into it.

Like `get-char-property', but with extra overlay information. The value is a cons cell. Its car is the return value of `get-char-property' with the same arguments--that is, the value of POSITION's property PROP in OBJECT. Its cdr is the overlay in which the property was found, or nil, if it was found as a text property or not found at all.

OBJECT is optional and defaults to the current buffer. OBJECT may be a string, a buffer or a window. For strings, the cdr of the return value is always nil, since strings do not have overlays. If OBJECT is a window, then that window's buffer is used, but window-specific overlays are considered only if they are associated with OBJECT. If POSITION is at the end of OBJECT, both car and cdr are nil.

Return the position of previous text property or overlay change. Scans characters backward in the current buffer from POSITION till it finds a change in some text property, or the beginning or end of an overlay, and returns the position of that. If none is found since (point-min), the function returns (point-min).

If the optional second argument LIMIT is non-nil, don't search past position LIMIT; return LIMIT if nothing is found before LIMIT. LIMIT is a no-op if it is less than (point-min).

Set one property of the text from START to END. The third and fourth arguments PROPERTY and VALUE specify the property to add. If the optional fifth argument OBJECT is a buffer (or nil, which means the current buffer), START and END are buffer positions (integers or markers). If OBJECT is a string, START and END are 0-based indices into it.

Remove some properties from text from START to END. The third argument PROPERTIES is a property list whose property names specify the properties to remove. (The values stored in PROPERTIES are ignored.) If the optional fourth argument OBJECT is a buffer (or nil, which means the current buffer), START and END are buffer positions (integers or markers). If OBJECT is a string, START and END are 0-based indices into it. Return t if any property was actually removed, nil otherwise.

Use `set-text-properties' if you want to remove all text properties.

Return the value of POSITION's property PROP, in OBJECT. Both overlay properties and text properties are checked. OBJECT is optional and defaults to the current buffer. If POSITION is at the end of OBJECT, the value is nil. If OBJECT is a buffer, then overlay properties are considered as well as text properties. If OBJECT is a window, then that window's buffer is used, but window-specific overlays are considered only if they are associated with OBJECT.

Return the position of next text property or overlay change for a specific property. Scans characters forward from POSITION till it finds a change in the PROP property, then returns the position of the change. If the optional third argument OBJECT is a buffer (or nil, which means the current buffer), POSITION is a buffer position (integer or marker). If OBJECT is a string, POSITION is a 0-based index into it.

In a string, scan runs to the end of the string. In a buffer, it runs to (point-max), and the value cannot exceed that.

The property values are compared with `eq'. If the property is constant all the way to the end of OBJECT, return the last valid position in OBJECT. If the optional fourth argument LIMIT is non-nil, don't search past position LIMIT; return LIMIT if nothing is found before LIMIT.

Return the position of next property change for a specific property. Scans characters forward from POSITION till it finds a change in the PROP property, then returns the position of the change. If the optional third argument OBJECT is a buffer (or nil, which means the current buffer), POSITION is a buffer position (integer or marker). If OBJECT is a string, POSITION is a 0-based index into it. The property values are compared with `eq'. Return nil if the property is constant all the way to the end of OBJECT. If the value is non-nil, it is a position greater than POSITION, never equal.

If the optional fourth argument LIMIT is non-nil, don't search past position LIMIT; return LIMIT if nothing is found before LIMIT.

Return the value of POSITION's property PROP, in OBJECT. OBJECT is optional and defaults to the current buffer. If POSITION is at the end of OBJECT, the value is nil.

Return the list of properties of the character at POSITION in OBJECT. If the optional second argument OBJECT is a buffer (or nil, which means the current buffer), POSITION is a buffer position (integer or marker). If OBJECT is a string, POSITION is a 0-based index into it. If POSITION is at the end of OBJECT, the value is nil.

Completely replace properties of text from START to END. The third argument PROPERTIES is the new property list. If the optional fourth argument OBJECT is a buffer (or nil, which means the current buffer), START and END are buffer positions (integers or markers). If OBJECT is a string, START and END are 0-based indices into it. If PROPERTIES is nil, the effect is to remove all properties from the designated part of OBJECT.

Return the position of previous property change for a specific property. Scans characters backward from POSITION till it finds a change in the PROP property, then returns the position of the change. If the optional third argument OBJECT is a buffer (or nil, which means the current buffer), POSITION is a buffer position (integer or marker). If OBJECT is a string, POSITION is a 0-based index into it. The property values are compared with `eq'. Return nil if the property is constant all the way to the start of OBJECT. If the value is non-nil, it is a position less than POSITION, never equal.

If the optional fourth argument LIMIT is non-nil, don't search back past position LIMIT; return LIMIT if nothing is found until LIMIT.

Return the position of previous property change. Scans characters backwards from POSITION in OBJECT till it finds a change in some text property, then returns the position of the change. If the optional second argument OBJECT is a buffer (or nil, which means the current buffer), POSITION is a buffer position (integer or marker). If OBJECT is a string, POSITION is a 0-based index into it. Return nil if the property is constant all the way to the start of OBJECT. If the value is non-nil, it is a position less than POSITION, never equal.

If the optional third argument LIMIT is non-nil, don't search back past position LIMIT; return LIMIT if nothing is found until LIMIT.

A list of files used to build this Emacs binary.

Name of file containing documentation strings of built-in symbols.

Used during Emacs initialization to scan the `etc/DOC...' file. This searches the `etc/DOC...' file for doc strings and records them in function and variable definitions. The function takes one argument, FILENAME, a string; it specifies the file name (without a directory) of the DOC file. That file is found in `../etc' now; later, when the dumped Emacs is run, the same file name is found in the `doc-directory'.

Substitute key descriptions for command names in STRING. Each substring of the form [COMMAND] is replaced by either a keystroke sequence that invokes COMMAND, or "M-x COMMAND" if COMMAND is not on any keys.

Each substring of the form {MAPVAR} is replaced by a summary of the value of MAPVAR as a keymap. This summary is similar to the one produced by `describe-bindings'. The summary ends in two newlines (used by the helper function `help-make-xrefs' to find the end of the summary).

Each substring of the form \<MAPVAR> specifies the use of MAPVAR as the keymap for future [COMMAND] substrings. \= quotes the following character and is discarded; thus, \=\= puts \= into the output, and \=[ puts [ into the output.

Return the original STRING if no substitutions are made. Otherwise, return a new string, without any text properties.

Return the documentation string that is SYMBOL's PROP property. Third argument RAW omitted or nil means pass the result through `substitute-command-keys' if it is a string.

This differs from `get' in that it can refer to strings stored in the `etc/DOC' file; and that it evaluates documentation properties that aren't strings.

Return the documentation string of FUNCTION. Unless a non-nil second argument RAW is given, the string is passed through `substitute-command-keys'.

Property which (if non-nil) indicates text has been fontified. buffer-substring' need not call thebuffer-access-fontify-functions' functions if all the text being accessed has this property.

The release of the operating system Emacs is running on.

The user's name, based upon the real uid only.

List of functions called by `buffer-substring' to fontify if necessary. Each function is called with two arguments which specify the range of the buffer being accessed.

The user's name, taken from environment variables if possible.

The host name of the machine Emacs is running on.

Non-nil means text motion commands don't notice fields.

The full name of the user logged in.

You can customize this variable.

Return the character position for byte position BYTEPOS. If BYTEPOS is out of range, the value is nil.

Return the contents of the field around POS, without text properties. A field is a region of text with the same `field' property. If POS is nil, the value of point is used for POS.

Decode a time value as (SEC MINUTE HOUR DAY MONTH YEAR DOW DST ZONE). The optional SPECIFIED-TIME should be a list of (HIGH LOW . IGNORED), as from current-time' andfile-attributes', or nil to use the current time. The obsolete form (HIGH . LOW) is also still accepted. The list has the following nine members: SEC is an integer between 0 and 60; SEC is 60 for a leap second, which only some operating systems support. MINUTE is an integer between 0 and 59. HOUR is an integer between 0 and 23. DAY is an integer between 1 and 31. MONTH is an integer between 1 and 12. YEAR is an integer indicating the four-digit year. DOW is the day of week, an integer between 0 and 6, where 0 is Sunday. DST is t if daylight saving time is in effect, otherwise nil. ZONE is an integer indicating the number of seconds east of Greenwich. (Note that Common Lisp has different meanings for DOW and ZONE.)

Return the current time, as the number of seconds since 1970-01-01 00:00:00. The time is returned as a list of three integers. The first has the most significant 16 bits of the seconds, while the second has the least significant 16 bits. The third integer gives the microsecond count.

The microsecond count is zero on systems that do not provide resolution finer than a second.

Return a marker to the maximum permissible value of point in this buffer. This is (1+ (buffer-size)), unless narrowing (a buffer restriction) is in effect, in which case it is less.

Return the character preceding point, as a number. At the beginning of the buffer or accessible region, return 0.

Internal use only. From START to END, translate characters according to TABLE. TABLE is a string or a char-table; the Nth character in it is the mapping for the character with code N. It returns the number of characters changed.

Insert text at point, relocating markers and inheriting properties. Point and markers move forward to end up after the inserted text.

If the current buffer is multibyte, unibyte strings are converted to multibyte for insertion (see `unibyte-char-to-multibyte'). If the current buffer is unibyte, multibyte strings are converted to unibyte for insertion.

Return the beginning of the field surrounding POS. A field is a region of text with the same `field' property. If POS is nil, the value of point is used for POS. If ESCAPE-FROM-EDGE is non-nil and POS is at the beginning of its field, then the beginning of the previous field is returned. If LIMIT is non-nil, it is a buffer position; if the beginning of the field is before LIMIT, then LIMIT will be returned instead.

Format a string out of a format-string and arguments. The first argument is a format control string. The other arguments are substituted into it to make the result, a string.

The format control string may contain %-sequences meaning to substitute the next available argument:

%s means print a string argument. Actually, prints any object, with `princ'. %d means print as number in decimal (%o octal, %x hex). %X is like %x, but uses upper case. %e means print a number in exponential notation. %f means print a number in decimal-point notation. %g means print a number in exponential notation or decimal-point notation, whichever uses fewer characters. %c means print a number as a single character. %S means print any object as an s-expression (using `prin1').

The argument used for %d, %o, %x, %e, %f, %g or %c must be a number. Use %% to put a single % into the output.

A %-sequence may contain optional flag, width, and precision specifiers, as follows:

%<flags><width><precision>character

where flags is [+ #-0]+, width is [0-9]+, and precision is .[0-9]+

The + flag character inserts a + before any positive number, while a space inserts a space before any positive number; these flags only affect %d, %e, %f, and %g sequences, and the + flag takes precedence. The # flag means to use an alternate display form for %o, %x, %X, %e, %f, and %g sequences. The - and 0 flags affect the width specifier, as described below.

The width specifier supplies a lower limit for the length of the printed representation. The padding, if any, normally goes on the left, but it goes on the right if the - flag is present. The padding character is normally a space, but it is 0 if the 0 flag is present. The 0 flag is ignored if the - flag is present, or the format sequence is something other than %d, %e, %f, and %g.

For %e, %f, and %g sequences, the number after the "." in the precision specifier says how many decimal places to show; if zero, the decimal point itself is omitted. For %s and %S, the precision specifier truncates the string to the given width.

Return the effective uid of Emacs. Value is an integer or a float, depending on the value.

Set the local time zone using TZ, a string specifying a time zone rule. If TZ is nil, use implementation-defined default time zone information. If TZ is t, use Universal Time.

Instead of calling this function, you typically want (setenv "TZ" TZ). That changes both the environment of the Emacs process and the variable process-environment', whereasset-time-zone-rule' affects only the former.

Insert the arguments at point, inheriting properties from adjoining text. Point and before-insertion markers move forward to end up after the inserted text. Any other markers at the point of insertion remain before the text.

If the current buffer is multibyte, unibyte strings are converted to multibyte for insertion (see `unibyte-char-to-multibyte'). If the current buffer is unibyte, multibyte strings are converted to unibyte for insertion.

Return the name of the user's real uid, as a string. This ignores the environment variables LOGNAME and USER, so it differs from user-login-name' when running undersu'.

Return the process ID of Emacs, as an integer.

Return the maximum permissible value of point in the current buffer. This is (1+ (buffer-size)), unless narrowing (a buffer restriction) is in effect, in which case it is less.

Return t if two characters match, optionally ignoring case. Both arguments must be characters (i.e. integers). Case is ignored if `case-fold-search' is non-nil in the current buffer.

Convert SECOND, MINUTE, HOUR, DAY, MONTH, YEAR and ZONE to internal time. This is the reverse operation of `decode-time', which see. ZONE defaults to the current time zone rule. This can be a string or t (as from `set-time-zone-rule'), or it can be a list (as from current-time-zone') or an integer (as fromdecode-time') applied without consideration for daylight saving time.

You can pass more than 7 arguments; then the first six arguments are used as SECOND through YEAR, and the last argument is used as ZONE. The intervening arguments are ignored. This feature lets (apply 'encode-time (decode-time ...)) work.

Out-of-range values for SECOND, MINUTE, HOUR, DAY, or MONTH are allowed; for example, a DAY of 0 means the day preceding the given month. Year numbers less than 100 are treated just like other year numbers. If you want them to stand for years in this century, you must do that yourself.

Years before 1970 are not guaranteed to work. On some systems, year values as low as 1901 do work.

Return character in current buffer at position POS. POS is an integer or a marker and defaults to point. If POS is out of range, the value is nil.

Return the size of the current buffer's gap. See also `gap-position'.

Insert before point a substring of the contents of BUFFER. BUFFER may be a buffer or a buffer name. Arguments START and END are character positions specifying the substring. They default to the values of (point-min) and (point-max) in BUFFER.

Return a marker to the minimum permissible value of point in this buffer. This is the beginning, unless narrowing (a buffer restriction) is in effect.

Return the first character in STRING.

Return value of point, as a marker object.

Return the position of the gap, in the current buffer. See also `gap-size'.

Return t if point is at the end of a line. `End of a line' includes point being at the end of the buffer.

Return the character position of the last character on the current line. With argument N not nil or 1, move forward N - 1 lines first. If scan reaches end of buffer, return that position.

The returned position is of the last character in the logical order, i.e. the character whose buffer position is the largest one.

This function constrains the returned position to the current field unless that would be on a different line than the original, unconstrained result. If N is nil or 1, and a rear-sticky field ends at point, the scan stops as soon as it starts. To ignore field boundaries bind `inhibit-field-text-motion' to t.

This function does not move point.

Restrict editing in this buffer to the current region. The rest of the text becomes temporarily invisible and untouchable but is not deleted; if you save the buffer in a file, the invisible text is included in the file. C-x n w makes all visible again. See also `save-restriction'.

When calling from a program, pass two arguments; positions (integers or markers) bounding the text that should remain visible.

Return the current run time used by Emacs. The time is returned as a list of three integers. The first has the most significant 16 bits of the seconds, while the second has the least significant 16 bits. The third integer gives the microsecond count.

On systems that can't determine the run time, `get-internal-run-time' does the same thing as `current-time'. The microsecond count is zero on systems that do not provide resolution finer than a second.

Return the minimum permissible value of point in the current buffer. This is 1, unless narrowing (a buffer restriction) is in effect.

Remove restrictions (narrowing) from current buffer. This allows the buffer's full text to be seen and edited.

From START to END, replace FROMCHAR with TOCHAR each time it occurs. If optional arg NOUNDO is non-nil, don't record this change for undo and don't mark the buffer as really changed. Both characters must have the same length of multi-byte form.

Return t if point is at the beginning of a line.

Return the byte position for character position POSITION. If POSITION is out of range, the value is nil.

Return value of point, as an integer. Beginning of buffer is position (point-min).

Return the contents of the field surrounding POS as a string. A field is a region of text with the same `field' property. If POS is nil, the value of point is used for POS.

Return the integer value of point or mark, whichever is smaller.

Return the character position of the first character on the current line. With argument N not nil or 1, move forward N - 1 lines first. If scan reaches end of buffer, return that position.

The returned position is of the first character in the logical order, i.e. the one that has the smallest character position.

This function constrains the returned position to the current field unless that would be on a different line than the original, unconstrained result. If N is nil or 1, and a front-sticky field starts at point, the scan stops as soon as it starts. To ignore field boundaries bind `inhibit-field-text-motion' to t.

This function does not move point.

Return the character following point, as a number. At the end of the buffer or accessible region, return 0.

Return t if point is at the end of the buffer. If the buffer is narrowed, this means the end of the narrowed part.

Return the characters of part of the buffer, without the text properties. The two arguments START and END are character positions; they can be in either order.

Return the real uid of Emacs. Value is an integer or a float, depending on the value.

Return the end of the field surrounding POS. A field is a region of text with the same `field' property. If POS is nil, the value of point is used for POS. If ESCAPE-FROM-EDGE is non-nil and POS is at the end of its field, then the end of the following field is returned. If LIMIT is non-nil, it is a buffer position; if the end of the field is after LIMIT, then LIMIT will be returned instead.

Return the name under which the user logged in, as a string. This is based on the effective uid, not the real uid. Also, if the environment variables LOGNAME or USER are set, that determines the value of this function.

If optional argument UID is an integer or a float, return the login name of the user with that uid, or nil if there is no such user.

Return t if point is at the beginning of the buffer. If the buffer is narrowed, this means the beginning of the narrowed part.

Display a message in a dialog box or in the echo area. If this command was invoked with the mouse, use a dialog box if `use-dialog-box' is non-nil. Otherwise, use the echo area. The first argument is a format control string, and the rest are data to be formatted under control of the string. See `format' for details.

If the first argument is nil or the empty string, clear any existing message; let the minibuffer contents show.

Return a copy of STRING with text properties added. First argument is the string to copy. Remaining arguments form a sequence of PROPERTY VALUE pairs for text properties to add to the result.

Return the current local time, as a human-readable string. Programs can use this function to decode a time, since the number of columns in each field is fixed if the year is in the range 1000-9999. The format is `Sun Sep 16 01:03:52 1973'. However, see also the functions decode-time' andformat-time-string' which provide a much more powerful and general facility.

If SPECIFIED-TIME is given, it is a time to format instead of the current time. The argument should have the form (HIGH LOW . IGNORED). Thus, you can use times obtained from `current-time' and from `file-attributes'. SPECIFIED-TIME can also have the form (HIGH . LOW), but this is considered obsolete.

Return the position closest to NEW-POS that is in the same field as OLD-POS. A field is a region of text with the same `field' property.

If NEW-POS is nil, then use the current point instead, and move point to the resulting constrained position, in addition to returning that position.

If OLD-POS is at the boundary of two fields, then the allowable positions for NEW-POS depends on the value of the optional argument ESCAPE-FROM-EDGE: If ESCAPE-FROM-EDGE is nil, then NEW-POS is constrained to the field that has the same `field' char-property as any new characters inserted at OLD-POS, whereas if ESCAPE-FROM-EDGE is non-nil, NEW-POS is constrained to the union of the two adjacent fields. Additionally, if two fields are separated by another field with the special value `boundary', then any point within this special field is also considered to be `on the boundary'.

If the optional argument ONLY-IN-LINE is non-nil and constraining NEW-POS would move it to a different line, NEW-POS is returned unconstrained. This useful for commands that move by line, like C-n or M-x beginning-of-line, which should generally respect field boundaries only in the case where they can still move to the right line.

If the optional argument INHIBIT-CAPTURE-PROPERTY is non-nil, and OLD-POS has a non-nil property of that name, then any field boundaries are ignored.

Field boundaries are not noticed if `inhibit-field-text-motion' is non-nil.

Return the contents of the current buffer as a string. If narrowing is in effect, this function returns only the visible part of the buffer.

Return the string currently displayed in the echo area, or nil if none.

Delete the field surrounding POS. A field is a region of text with the same `field' property. If POS is nil, the value of point is used for POS.

Delete the text between START and END and return it.

Return the offset and name for the local time zone. This returns a list of the form (OFFSET NAME). OFFSET is an integer number of seconds ahead of UTC (east of Greenwich). A negative value means west of Greenwich. NAME is a string giving the name of the time zone. If SPECIFIED-TIME is given, the time zone offset is determined from it instead of using the current time. The argument should have the form (HIGH LOW . IGNORED). Thus, you can use times obtained from current-time' and fromfile-attributes'. SPECIFIED-TIME can also have the form (HIGH . LOW), but this is considered obsolete.

Some operating systems cannot provide all this information to Emacs; in this case, `current-time-zone' returns a list containing nil for the data it can't find.

Insert strings or characters at point, relocating markers after the text. Point and markers move forward to end up after the inserted text.

If the current buffer is multibyte, unibyte strings are converted to multibyte for insertion (see `unibyte-char-to-multibyte'). If the current buffer is unibyte, multibyte strings are converted to unibyte for insertion.

Return character in current buffer preceding position POS. POS is an integer or a marker and defaults to point. If POS is out of range, the value is nil.

Convert arg CHAR to a string containing that character.

Delete the text between START and END. If called interactively, delete the region between point and mark. This command deletes buffer text without modifying the kill ring.

Transpose region STARTR1 to ENDR1 with STARTR2 to ENDR2. The regions should not be overlapping, because the size of the buffer is never changed in a transposition.

Optional fifth arg LEAVE-MARKERS, if non-nil, means don't update any markers that happen to be located in the regions.

Transposing beyond buffer boundaries is an error.

Set point to POSITION, a number or marker. Beginning of buffer is position (point-min), end is (point-max).

The return value is POSITION.

Insert COUNT copies of CHARACTER. Point, and before-insertion markers, are relocated as in the function `insert'. The optional third arg INHERIT, if non-nil, says to inherit text properties from adjoining text, if those properties are sticky.

Return the host name of the machine you are running on, as a string.

Return the number of characters in the current buffer. If BUFFER, return the number of characters in that buffer instead.

Return the integer value of point or mark, whichever is larger.

Use FORMAT-STRING to format the time TIME, or now if omitted. TIME is specified as (HIGH LOW . IGNORED), as returned by current-time' orfile-attributes'. The obsolete form (HIGH . LOW) is also still accepted. The third, optional, argument UNIVERSAL, if non-nil, means describe TIME as Universal Time; nil means describe TIME in the local time zone. The value is a copy of FORMAT-STRING, but with certain constructs replaced by text that describes the specified date and time in TIME:

%Y is the year, %y within the century, %C the century. %G is the year corresponding to the ISO week, %g within the century. %m is the numeric month. %b and %h are the locale's abbreviated month name, %B the full name. %d is the day of the month, zero-padded, %e is blank-padded. %u is the numeric day of week from 1 (Monday) to 7, %w from 0 (Sunday) to 6. %a is the locale's abbreviated name of the day of week, %A the full name. %U is the week number starting on Sunday, %W starting on Monday, %V according to ISO 8601. %j is the day of the year.

%H is the hour on a 24-hour clock, %I is on a 12-hour clock, %k is like %H only blank-padded, %l is like %I blank-padded. %p is the locale's equivalent of either AM or PM. %M is the minute. %S is the second. %N is the nanosecond, %6N the microsecond, %3N the millisecond, etc. %Z is the time zone name, %z is the numeric form. %s is the number of seconds since 1970-01-01 00:00:00 +0000.

%c is the locale's date and time format. %x is the locale's "preferred" date format. %D is like "%m/%d/%y".

%R is like "%H:%M", %T is like "%H:%M:%S", %r is like "%I:%M:%S %p". %X is the locale's "preferred" time format.

Finally, %n is a newline, %t is a tab, %% is a literal %.

Certain flags and modifiers are available with some format controls. The flags are _',-', ^' and#'. For certain characters X, %_X is like %X, but padded with blanks; %-X is like %X, but without padding. %^X is like %X, but with all textual characters up-cased; %#X is like %X, but with letter-case of all textual characters reversed. %NX (where N stands for an integer) is like %X, but takes up at least N (a number) positions. The modifiers are E' andO'. For certain characters X, %EX is a locale's alternative version of %X; %OX is like %X, but uses the locale's number symbols.

For example, to produce full ISO 8601 format, use "%Y-%m-%dT%T%z".

Insert COUNT (second arg) copies of BYTE (first arg). Both arguments are required. BYTE is a number of the range 0..255.

If BYTE is 128..255 and the current buffer is multibyte, the corresponding eight-bit character is inserted.

Point, and before-insertion markers, are relocated as in the function `insert'. The optional third arg INHERIT, if non-nil, says to inherit text properties from adjoining text, if those properties are sticky.

Compare two substrings of two buffers; return result as number. the value is -N if first string is less after N-1 chars, +N if first string is greater after N-1 chars, or 0 if strings match. Each substring is represented as three arguments: BUFFER, START and END. That makes six args in all, three for each substring.

The value of `case-fold-search' in the current buffer determines whether case is significant or ignored.

Return this buffer's mark, as a marker object. Watch out! Moving this marker changes the mark position. If you set the marker not to point anywhere, the buffer will have no mark.

Return the full name of the user logged in, as a string. If the full name corresponding to Emacs's userid is not known, return "unknown".

If optional argument UID is an integer or float, return the full name of the user with that uid, or nil if there is no such user. If UID is a string, return the full name of the user with that login name, or nil if there is no such user.

Display a message at the bottom of the screen. The message also goes into the `Messages' buffer. (In keyboard macros, that's all it does.) Return the message.

The first argument is a format control string, and the rest are data to be formatted under control of the string. See `format' for details.

Note: Use (message "%s" VALUE) to print the value of expressions and variables to avoid accidentally interpreting `%' as format specifiers.

If the first argument is nil or the empty string, the function clears any existing message; this lets the minibuffer contents show. See also `current-message'.

Insert the arguments, either strings or characters, at point. Point and before-insertion markers move forward to end up after the inserted text. Any other markers at the point of insertion remain before the text.

If the current buffer is multibyte, unibyte strings are converted to multibyte for insertion (see `string-make-multibyte'). If the current buffer is unibyte, multibyte strings are converted to unibyte for insertion (see `string-make-unibyte').

When operating on binary data, it may be necessary to preserve the original bytes of a unibyte string when inserting it into a multibyte buffer; to accomplish this, apply `string-as-multibyte' to the string and insert the result.

Return the contents of part of the current buffer as a string. The two arguments START and END are character positions; they can be in either order. The string returned is multibyte if the buffer is multibyte.

This function copies the text properties of that part of the buffer into the result string; if you don't want the text properties, use `buffer-substring-no-properties' instead.

Convert arg BYTE to a unibyte string containing that byte.

Return the current time, as a float number of seconds since the epoch. If SPECIFIED-TIME is given, it is the time to convert to float instead of the current time. The argument should have the form (HIGH LOW) or (HIGH LOW USEC). Thus, you can use times obtained from current-time' and fromfile-attributes'. SPECIFIED-TIME can also have the form (HIGH . LOW), but this is considered obsolete.

WARNING: Since the result is floating point, it may not be exact. If precise time stamps are required, use either `current-time', or (if you need time as a string) `format-time-string'.

Display a message, in a dialog box if possible. If a dialog box is not available, use the echo area. The first argument is a format control string, and the rest are data to be formatted under control of the string. See `format' for details.

If the first argument is nil or the empty string, clear any existing message; let the minibuffer contents show.

History list symbol to add minibuffer values to. Each string of minibuffer input, as it appears on exit from the minibuffer, is added with (set minibuffer-history-variable (cons STRING (symbol-value minibuffer-history-variable)))

A history list for arguments that are Lisp expressions to evaluate. For example, `eval-expression' uses this.

List of regexps that should restrict possible completions. The basic completion functions only consider a completion acceptable if it matches all regular expressions in this list, with case-fold-search' bound to the value ofcompletion-ignore-case'. See Info node `(elisp)Basic Completion', for a description of these functions.

Normal hook run just after exit from minibuffer.

Non-nil means completing file names.

Non-nil means to allow minibuffer commands while in the minibuffer. This variable makes a difference whenever the minibuffer window is active.

You can customize this variable.

Normal hook run just after entry to minibuffer.

Text properties that are added to minibuffer prompts. These are in addition to the basic `field' property, and stickiness properties.

You can customize this variable.

Non-nil means completion ignores case when reading a buffer name.

You can customize this variable.

Current position of redoing in the history list.

If this is non-nil, `read-buffer' does its work by calling this function. The function is called with the arguments passed to `read-buffer'.

You can customize this variable.

Non-nil means to delete duplicates in history. If set to t when adding a new history element, all previous identical elements are deleted from the history list.

You can customize this variable.

Within call to `completing-read', this holds the PREDICATE argument.

Non-nil means don't consider case significant in completion. For file-name completion, `read-file-name-completion-ignore-case' controls the behavior, rather than this variable. For buffer name completion, `read-buffer-completion-ignore-case' controls the behavior, rather than this variable.

Value that `help-form' takes on inside the minibuffer.

Non-nil means `read-from-minibuffer' should not discard text properties. This also affects read-string', but it does not affectread-minibuffer', `read-no-blanks-input', or any of the functions that do minibuffer input with completion; they always discard text properties.

Minibuffer keymap used for reading Lisp expressions.

Maximum length of history lists before truncation takes place. A number means truncate to that length; truncation deletes old elements, and is done just after inserting a new element. A value of t means no truncation.

This variable only affects history lists that don't specify their own maximum lengths. Setting the `history-length' property of a history variable overrides this default.

You can customize this variable.

Non-nil means entering the minibuffer raises the minibuffer's frame. Some uses of the echo area also raise that frame (since they use it too).

You can customize this variable.

Alist or obarray used for completion in the minibuffer. This becomes the ALIST argument to try-completion' andall-completions'. The value can also be a list of strings or a hash table.

The value may alternatively be a function, which is given three arguments: STRING, the current buffer contents; PREDICATE, the predicate for filtering possible matches; CODE, which says what kind of things to do. CODE can be nil, t or `lambda': nil -- return the best completion of STRING, or nil if there is none. t -- return a list of all possible completions of STRING. lambda -- return t if STRING is a valid completion as it stands.

Non-nil means to add new elements in history. If set to nil, minibuffer reading functions don't add new elements to the history list, so it is possible to do this afterwards by calling `add-to-history' explicitly.

Whether to demand confirmation of completion before exiting minibuffer. If nil, confirmation is not required. If the value is `confirm', the user may exit with an input that is not a valid completion alternative, but Emacs asks for confirmation. If the value is `confirm-after-completion', the user may exit with an input that is not a valid completion alternative, but Emacs asks for confirmation if the user submitted the input right after any of the completion commands listed in `minibuffer-confirm-exit-commands'.

Return current depth of activations of minibuffer, a nonnegative integer.

Return non-nil if STRING is a valid completion. Takes the same arguments as all-completions' andtry-completion'. If COLLECTION is a function, it is called with three arguments: the values STRING, PREDICATE and `lambda'.

Read a string in the minibuffer, with completion. PROMPT is a string to prompt with; normally it ends in a colon and a space. COLLECTION can be a list of strings, an alist, an obarray or a hash table. COLLECTION can also be a function to do the completion itself. PREDICATE limits completion to a subset of COLLECTION. See try-completion' andall-completions' for more details on completion, COLLECTION, and PREDICATE.

REQUIRE-MATCH can take the following values: - t means that the user is not allowed to exit unless the input is (or completes to) an element of COLLECTION or is null. - nil means that the user can exit with any input. - `confirm' means that the user can exit with any input, but she needs to confirm her choice if the input is not an element of COLLECTION. - `confirm-after-completion' means that the user can exit with any input, but she needs to confirm her choice if she called minibuffer-complete' right beforeminibuffer-complete-and-exit' and the input is not an element of COLLECTION. - anything else behaves like t except that typing RET does not exit if it does non-null completion.

If the input is null, `completing-read' returns DEF, or the first element of the list of default values, or an empty string if DEF is nil, regardless of the value of REQUIRE-MATCH.

If INITIAL-INPUT is non-nil, insert it in the minibuffer initially, with point positioned at the end. If it is (STRING . POSITION), the initial input is STRING, but point is placed at zero-indexed position POSITION in STRING. (Note that this is different from `read-from-minibuffer' and related functions, which use one-indexing for POSITION.) This feature is deprecated--it is best to pass nil for INITIAL-INPUT and supply the default value DEF instead. The user can yank the default value into the minibuffer easily using M-x next-history-element.

HIST, if non-nil, specifies a history list and optionally the initial position in the list. It can be a symbol, which is the history list variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable to use, and HISTPOS is the initial position (the position in the list used by the minibuffer history commands). For consistency, you should also specify that element of the history as the value of INITIAL-INPUT. (This is the only case in which you should use INITIAL-INPUT instead of DEF.) Positions are counted starting from 1 at the beginning of the list. The variable `history-length' controls the maximum length of a history list.

DEF, if non-nil, is the default value or the list of default values.

If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits the current input method and the setting of `enable-multibyte-characters'.

Completion ignores case if the ambient value of `completion-ignore-case' is non-nil.

See also `completing-read-function'.

Read a string from the minibuffer, prompting with string PROMPT. The optional second arg INITIAL-CONTENTS is an obsolete alternative to DEFAULT-VALUE. It normally should be nil in new code, except when HIST is a cons. It is discussed in more detail below.

Third arg KEYMAP is a keymap to use whilst reading; if omitted or nil, the default is `minibuffer-local-map'.

If fourth arg READ is non-nil, interpret the result as a Lisp object and return that object: in other words, do `(car (read-from-string INPUT-STRING))'

Fifth arg HIST, if non-nil, specifies a history list and optionally the initial position in the list. It can be a symbol, which is the history list variable to use, or a cons cell (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable to use, and HISTPOS is the initial position for use by the minibuffer history commands. For consistency, you should also specify that element of the history as the value of INITIAL-CONTENTS. Positions are counted starting from 1 at the beginning of the list.

Sixth arg DEFAULT-VALUE, if non-nil, should be a string, which is used as the default to `read' if READ is non-nil and the user enters empty input. But if READ is nil, this function does not return DEFAULT-VALUE for empty input! Instead, it returns the empty string.

Whatever the value of READ, DEFAULT-VALUE is made available via the
minibuffer history commands.  DEFAULT-VALUE can also be a list of
strings, in which case all the strings are available in the history,
and the first string is the default to `read' if READ is non-nil.

Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits the current input method and the setting of `enable-multibyte-characters'.

If the variable `minibuffer-allow-text-properties' is non-nil, then the string which is returned includes whatever text properties were present in the minibuffer. Otherwise the value has no text properties.

The remainder of this documentation string describes the INITIAL-CONTENTS argument in more detail. It is only relevant when studying existing code, or when HIST is a cons. If non-nil, INITIAL-CONTENTS is a string to be inserted into the minibuffer before reading input. Normally, point is put at the end of that string. However, if INITIAL-CONTENTS is (STRING . POSITION), the initial input is STRING, but point is placed at one-indexed position POSITION in the minibuffer. Any integer value less than or equal to one puts point at the beginning of the string. Note that this behavior differs from the way such arguments are used in `completing-read' and some related functions, which use zero-indexing for POSITION.

Like `assoc' but specifically for strings (and symbols).

This returns the first element of LIST whose car matches the string or symbol KEY, or nil if no match exists. When performing the comparison, symbols are first converted to strings, and unibyte strings to multibyte. If the optional arg CASE-FOLD is non-nil, case is ignored.

Unlike `assoc', KEY can also match an entry in LIST consisting of a single string, rather than a cons cell whose car is a string.

Read a string from the terminal, not allowing blanks. Prompt with PROMPT. Whitespace terminates the input. If INITIAL is non-nil, it should be a string, which is used as initial input, with point positioned at the end, so that SPACE will accept the input. (Actually, INITIAL can also be a cons of a string and an integer. Such values are treated as in `read-from-minibuffer', but are normally not useful in this function.) Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits the current input method and the setting of`enable-multibyte-characters'.

Return the prompt string of the currently-active minibuffer. If no minibuffer is active, return nil.

Read the name of a command and return as a symbol. Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element if it is a list.

Return common substring of all completions of STRING in COLLECTION. Test each possible completion specified by COLLECTION to see if it begins with STRING. The possible completions may be strings or symbols. Symbols are converted to strings before testing, see `symbol-name'. All that match STRING are compared together; the longest initial sequence common to all these matches is the return value. If there is no match at all, the return value is nil. For a unique match which is exact, the return value is t.

If COLLECTION is an alist, the keys (cars of elements) are the possible completions. If an element is not a cons cell, then the element itself is the possible completion. If COLLECTION is a hash-table, all the keys that are strings or symbols are the possible completions. If COLLECTION is an obarray, the names of all symbols in the obarray are the possible completions.

COLLECTION can also be a function to do the completion itself. It receives three arguments: the values STRING, PREDICATE and nil. Whatever it returns becomes the value of `try-completion'.

If optional third argument PREDICATE is non-nil, it is used to test each possible match. The match is a candidate only if PREDICATE returns non-nil. The argument given to PREDICATE is the alist element or the symbol from the obarray. If COLLECTION is a hash-table, predicate is called with two arguments: the key and the value. Additionally to this predicate, `completion-regexp-list' is used to further constrain the set of candidates.

Return value of Lisp expression read using the minibuffer. Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS is a string to insert in the minibuffer before reading. (INITIAL-CONTENTS can also be a cons of a string and an integer. Such arguments are used as in `read-from-minibuffer'.)

Read a string from the minibuffer, prompting with string PROMPT. If non-nil, second arg INITIAL-INPUT is a string to insert before reading. This argument has been superseded by DEFAULT-VALUE and should normally be nil in new code. It behaves as in `read-from-minibuffer'. See the documentation string of that function for details. The third arg HISTORY, if non-nil, specifies a history list and optionally the initial position in the list. See `read-from-minibuffer' for details of HISTORY argument. Fourth arg DEFAULT-VALUE is the default value or the list of default values. If non-nil, it is used for history commands, and as the value (or the first element of the list of default values) to return if the user enters the empty string. Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits the current input method and the setting of `enable-multibyte-characters'.

Return the buffer position of the end of the minibuffer prompt. Return (point-min) if current buffer is not a minibuffer.

Specify which minibuffer window to use for the minibuffer. This affects where the minibuffer is displayed if you put text in it without invoking the usual minibuffer commands.

Return t if BUFFER is a minibuffer. No argument or nil as argument means use current buffer as BUFFER. BUFFER can be a buffer or a buffer name.

Perform completion on buffer names. If the argument FLAG is nil, invoke `try-completion', if it's t, invoke all-completions', otherwise invoketest-completion'.

The arguments STRING and PREDICATE are as in `try-completion', all-completions', andtest-completion'.

Search for partial matches to STRING in COLLECTION. Test each of the possible completions specified by COLLECTION to see if it begins with STRING. The possible completions may be strings or symbols. Symbols are converted to strings before testing, see `symbol-name'. The value is a list of all the possible completions that match STRING.

If COLLECTION is an alist, the keys (cars of elements) are the possible completions. If an element is not a cons cell, then the element itself is the possible completion. If COLLECTION is a hash-table, all the keys that are strings or symbols are the possible completions. If COLLECTION is an obarray, the names of all symbols in the obarray are the possible completions.

COLLECTION can also be a function to do the completion itself. It receives three arguments: the values STRING, PREDICATE and t. Whatever it returns becomes the value of `all-completions'.

If optional third argument PREDICATE is non-nil, it is used to test each possible match. The match is a candidate only if PREDICATE returns non-nil. The argument given to PREDICATE is the alist element or the symbol from the obarray. If COLLECTION is a hash-table, predicate is called with two arguments: the key and the value. Additionally to this predicate, `completion-regexp-list' is used to further constrain the set of candidates.

An obsolete optional fourth argument HIDE-SPACES is still accepted for backward compatibility. If non-nil, strings in COLLECTION that start with a space are ignored unless STRING itself starts with a space.

Read the name of a buffer and return as a string. Prompt with PROMPT. Optional second arg DEF is value to return if user enters an empty line. If DEF is a list of default values, return its first element. Optional third arg REQUIRE-MATCH determines whether non-existing buffer names are allowed. It has the same meaning as the REQUIRE-MATCH argument of `completing-read'. The argument PROMPT should be a string ending with a colon and a space. If `read-buffer-completion-ignore-case' is non-nil, completion ignores case while reading the buffer name. If `read-buffer-function' is non-nil, this works by calling it as a function, instead of the usual behavior.

Return a Lisp object read using the minibuffer, unevaluated. Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS is a string to insert in the minibuffer before reading. (INITIAL-CONTENTS can also be a cons of a string and an integer. Such arguments are used as in `read-from-minibuffer'.)

Return the user input in a minibuffer as a string, without text-properties. If the current buffer is not a minibuffer, return its entire contents.

Return the user input in a minibuffer as a string. If the current buffer is not a minibuffer, return its entire contents.

Read the name of a user variable and return it as a symbol. Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element if it is a list. A user variable is one for which `user-variable-p' returns non-nil.

Return the currently active minibuffer window, or nil if none.

Pop up a deck-of-cards menu and return user's selection. POSITION is a position specification. This is either a mouse button event or a list ((XOFFSET YOFFSET) WINDOW) where XOFFSET and YOFFSET are positions in pixels from the top left corner of WINDOW. (WINDOW may be a window or a frame object.) This controls the position of the top left of the menu as a whole. If POSITION is t, it means to use the current mouse position.

MENU is a specifier for a menu. For the simplest case, MENU is a keymap. The menu items come from key bindings that have a menu string as well as a definition; actually, the "definition" in such a key binding looks like (STRING . REAL-DEFINITION). To give the menu a title, put a string into the keymap as a top-level element.

If REAL-DEFINITION is nil, that puts a nonselectable string in the menu. Otherwise, REAL-DEFINITION should be a valid key binding definition.

You can also use a list of keymaps as MENU. Then each keymap makes a separate pane.

When MENU is a keymap or a list of keymaps, the return value is the list of events corresponding to the user's choice. Note that `x-popup-menu' does not actually execute the command bound to that sequence of events.

Alternatively, you can specify a menu of multiple panes with a list of the form (TITLE PANE1 PANE2...), where each pane is a list of form (TITLE ITEM1 ITEM2...). Each ITEM is normally a cons cell (STRING . VALUE); but a string can appear as an item--that makes a nonselectable line in the menu. With this form of menu, the return value is VALUE from the chosen item.

If POSITION is nil, don't display the menu at all, just precalculate the cached information about equivalent key sequences.

If the user gets rid of the menu without making a valid choice, for instance by clicking the mouse away from a valid choice or by typing keyboard input, then this normally results in a quit and `x-popup-menu' does not return. But if POSITION is a mouse button event (indicating that the user invoked the menu with the mouse) then no quit occurs and `x-popup-menu' returns nil.

*Coding system for encoding file names. If it is nil, `default-file-name-coding-system' (which see) is used.

If non-nil, a function to call to decide a coding system of file. Two arguments are passed to this function: the file name and the length of a file contents following the point. This function should return a coding system to decode the file contents. It should check the file name against `auto-coding-alist'. If no coding system is decided, it should check a coding system specified in the heading lines with the format: -- ... coding: CODING-SYSTEM; ... -- or local variable spec of the tailing lines with `coding:' tag.

Specifies whether to use the system's trash can. When non-nil, certain file deletion commands use the function `move-file-to-trash' instead of deleting files outright. This includes interactive calls to `delete-file' and `delete-directory' and the Dired deletion commands.

You can customize this variable.

File name in which we write a list of all auto save file names. This variable is initialized automatically from `auto-save-list-file-prefix' shortly after Emacs reads your `.emacs' file, if you have not yet given it a non-nil value.

Default coding system for encoding file names. This variable is used only when `file-name-coding-system' is nil.

This variable is set/changed by the command `set-language-environment'. User should not set this variable manually, instead use `file-name-coding-system' to get a constant encoding of file names regardless of the current language environment.

When an annotation function is called, this holds the previous annotations. These are the annotations made by other annotation functions that were already called. See also `write-region-annotate-functions'.

The operation for which `inhibit-file-name-handlers' is applicable.

*Non-nil means don't call fsync in `write-region'. This variable affects calls to `write-region' as well as save commands. A non-nil value may result in data loss!

Non-nil says auto-save a buffer in the file it is visiting, when practical. Normally auto-save files are written under other names.

You can customize this variable.

A list of functions to be called at the start of `write-region'. Each is passed two arguments, START and END as for `write-region'. These are usually two numbers but not always; see the documentation for `write-region'. The function should return a list of pairs of the form (POSITION . STRING), consisting of strings to be effectively inserted at the specified positions of the file being written (1 means to insert before the first byte written). The POSITIONs must be sorted into increasing order.

If there are several annotation functions, the lists returned by these functions are merged destructively. As each annotation function runs, the variable `write-region-annotations-so-far' contains a list of all annotations returned by previous annotation functions.

An annotation function can return with a different buffer current. Doing so removes the annotations returned by previous functions, and resets START and END to point-min' andpoint-max' of the new buffer.

After `write-region' completes, Emacs calls the function stored in `write-region-post-annotation-function', once for each buffer that was current when building the annotations (i.e., at least once), with that buffer current.

Alist of elements (REGEXP . HANDLER) for file names handled specially. If a file name matches REGEXP, all I/O on that file is done by calling HANDLER. If a file name matches more than one handler, the handler whose match starts last in the file name gets precedence. The function `find-file-name-handler' checks this list for a handler for its argument.

HANDLER should be a function. The first argument given to it is the name of the I/O primitive to be handled; the remaining arguments are the arguments that were passed to that primitive. For example, if you do (file-exists-p FILENAME) and FILENAME is handled by HANDLER, then HANDLER is called like this:

(funcall HANDLER 'file-exists-p FILENAME)

Note that HANDLER must be able to handle all I/O primitives; if it has nothing special to do for a primitive, it should reinvoke the primitive to handle the operation "the usual way". See Info node `(elisp)Magic File Names' for more details.

If non-nil, auto-save even if a large part of the text is deleted. If nil, deleting a substantial portion of the text disables auto-save in the buffer; this is the default behavior, because the auto-save file is usually more useful if it contains the deleted text.

A list of functions to be called at the end of `insert-file-contents'. Each is passed one argument, the number of characters inserted, with point at the start of the inserted text. Each function should leave point the same, and return the new character count. If `insert-file-contents' is intercepted by a handler from `file-name-handler-alist', that handler is responsible for calling the functions in `after-insert-file-functions' if appropriate.

A list of file name handlers that temporarily should not be used. This applies only to the operation `inhibit-file-name-operation'.

Function to call after `write-region' completes. The function is called with no arguments. If one or more of the annotation functions in `write-region-annotate-functions' changed the current buffer, the function stored in this variable is called for each of those additional buffers as well, in addition to the original buffer. The relevant buffer is current during each function call.

Clear any record of a recent auto-save failure in the current buffer.

Return t if file FILENAME specifies an absolute file name. On Unix, this is a name starting with a /' or a~'.

Update buffer's recorded modification time from the visited file's time. Useful if the buffer was not read from the file normally or if the file itself has been changed for some known benign reason. An argument specifies the modification time value to use (instead of that of the visited file), in the form of a list (HIGH . LOW) or (HIGH LOW).

Set the file permission bits for newly created files. The argument MODE should be an integer; only the low 9 bits are used. This setting is inherited by subprocesses.

Return t if file FILENAME can be written or created by you.

Return t if (car A) is numerically less than (car B).

Convert filename NAME to absolute, and canonicalize it. Second arg DEFAULT-DIRECTORY is directory to start with if NAME is relative (does not start with slash or tilde); if DEFAULT-DIRECTORY is nil or missing, the current buffer's value of `default-directory' is used. NAME should be a string that is a valid file name for the underlying filesystem. File name components that are `.' are removed, and so are file name components followed by ..', along with the..' itself; note that these simplifications are done without checking the resulting file names in the file system. Multiple consecutive slashes are collapsed into a single slash, except at the beginning of the file name when they are significant (e.g., UNC file names on MS-Windows.) An initial `~/' expands to your home directory. An initial `~USER/' expands to USER's home directory. See also the function `substitute-in-file-name'.

For technical reasons, this function can return correct but non-intuitive results for the root directory; for instance, (expand-file-name ".." "/") returns "/..". For this reason, use (directory-file-name (file-name-directory dirname)) to traverse a filesystem tree, not (expand-file-name ".." dirname).

Write current region into specified file. When called from a program, requires three arguments: START, END and FILENAME. START and END are normally buffer positions specifying the part of the buffer to write. If START is nil, that means to use the entire buffer contents. If START is a string, then output that string to the file instead of any buffer contents; END is ignored.

Optional fourth argument APPEND if non-nil means append to existing file contents (if any). If it is an integer, seek to that offset in the file before writing. Optional fifth argument VISIT, if t or a string, means set the last-save-file-modtime of buffer to this file's modtime and mark buffer not modified. If VISIT is a string, it is a second file name; the output goes to FILENAME, but the buffer is marked as visiting VISIT. VISIT is also the file name to lock and unlock for clash detection. If VISIT is neither t nor nil nor a string, that means do not display the "Wrote file" message. The optional sixth arg LOCKNAME, if non-nil, specifies the name to use for locking and unlocking, overriding FILENAME and VISIT. The optional seventh arg MUSTBENEW, if non-nil, insists on a check for an existing file with the same name. If MUSTBENEW is `excl', that means to get an error if the file already exists; never overwrite. If MUSTBENEW is neither nil nor `excl', that means ask for confirmation before overwriting, but do go ahead and overwrite the file if the user confirms.

This does code conversion according to the value of coding-system-for-write',buffer-file-coding-system', or `file-coding-system-alist', and sets the variable `last-coding-system-used' to the coding system actually used.

This calls `write-region-annotate-functions' at the start, and `write-region-post-annotation-function' at the end.

Return t if file FILENAME exists (whether or not you can read it.) See also file-readable-p' andfile-attributes'. This returns nil for a symlink to a nonexistent file. Use `file-symlink-p' to test for such links.

Set SELinux context of file named FILENAME to CONTEXT. CONTEXT should be a list (USER ROLE TYPE RANGE), where the list elements are strings naming the components of a SELinux context.

This function does nothing if SELinux is disabled, or if Emacs was not compiled with SELinux support.

Auto-save all buffers that need it. This is all buffers that have auto-saving enabled and are changed since last auto-saved. Auto-saving writes the buffer into a file so that your editing is not lost if the system crashes. This file is not the file you visited; that changes only when you save. Normally we run the normal hook `auto-save-hook' before saving.

A non-nil NO-MESSAGE argument means do not print any message if successful. A non-nil CURRENT-ONLY argument means save only current buffer.

Return SELinux context of file named FILENAME. The return value is a list (USER ROLE TYPE RANGE), where the list elements are strings naming the user, role, type, and range of the file's SELinux security context.

Return (nil nil nil nil) if the file is nonexistent or inaccessible, or if SELinux is disabled, or if Emacs lacks SELinux support.

Delete the directory named DIRECTORY. Does not follow symlinks.

Return FILENAME's handler function for OPERATION, if it has one. Otherwise, return nil. A file name is handled if one of the regular expressions in `file-name-handler-alist' matches it.

If OPERATION equals `inhibit-file-name-operation', then we ignore any handlers that are members of `inhibit-file-name-handlers', but we still do run any other handlers. This lets handlers use the standard functions without calling themselves recursively.

Rename FILE as NEWNAME. Both args must be strings. If file has names other than FILE, it continues to have those names. Signals a `file-already-exists' error if a file NEWNAME already exists unless optional third argument OK-IF-ALREADY-EXISTS is non-nil. A number as third arg means request confirmation if NEWNAME already exists. This is what happens in interactive use with M-x.

Make a symbolic link to FILENAME, named LINKNAME. Both args must be strings. Signals a `file-already-exists' error if a file LINKNAME already exists unless optional third argument OK-IF-ALREADY-EXISTS is non-nil. A number as third arg means request confirmation if LINKNAME already exists. This happens for interactive use with M-x.

Return the default file protection for created files. The value is an integer.

Clear out records of last mod time of visited file. Next attempt to save will certainly not complain of a discrepancy.

Return the current buffer's recorded visited file modification time. The value is a list of the form (HIGH LOW), like the time values that `file-attributes' returns. If the current buffer has no recorded file modification time, this function returns 0. If the visited file doesn't exist, HIGH will be -1. See Info node `(elisp)Modification Time' for more details.

Tell Unix to finish all pending disk updates.

Return t if last mod time of BUF's visited file matches what BUF records. This means that the file has not been changed since it was visited or saved. If BUF is omitted or nil, it defaults to the current buffer. See Info node `(elisp)Modification Time' for more details.

Returns the file name of the directory named DIRECTORY. This is the name of the file that holds the data for the directory DIRECTORY. This operation exists because a directory is also a file, but its name as a directory is different from its name as a file. In Unix-syntax, this function just removes the final slash.

Create a new directory named DIRECTORY.

Return t if file FILE1 is newer than file FILE2. If FILE1 does not exist, the answer is nil; otherwise, if FILE2 does not exist, the answer is t.

Return t if file FILENAME exists and you can read it. See also file-exists-p' andfile-attributes'.

Delete file named FILENAME. If it is a symlink, remove the symlink. If file has multiple names, it continues to exist with the other names. TRASH non-nil means to trash the file instead of deleting, provided `delete-by-moving-to-trash' is non-nil.

When called interactively, TRASH is t if no prefix argument is given. With a prefix argument, TRASH is nil.

Return t if FILENAME can be executed by you. For a directory, this means you can access files in that directory.

Generate temporary file name (string) starting with PREFIX (a string). The Emacs process number forms part of the result, so there is no danger of generating a name being used by another process.

In addition, this function makes an attempt to choose a name which has no existing file. To make this work, PREFIX should be an absolute file name.

There is a race condition between calling `make-temp-name' and creating the file which opens all kinds of security holes. For that reason, you should probably use `make-temp-file' instead, except in three circumstances:

• If you are creating the file in the user's home directory.
• If you are creating a directory rather than an ordinary file.
• If you are taking special precautions as `make-temp-file' does.

Access file FILENAME, and get an error if that does not work. The second argument STRING is used in the error message. If there is no error, returns nil.

Give FILE additional name NEWNAME. Both args must be strings. Signals a `file-already-exists' error if a file NEWNAME already exists unless optional third argument OK-IF-ALREADY-EXISTS is non-nil. A number as third arg means request confirmation if NEWNAME already exists. This is what happens in interactive use with M-x.

Return t if current buffer has been auto-saved recently. More precisely, if it has been auto-saved since last read from or saved in the visited file. If the buffer has no visited file, then any auto-save counts as "recent".

Insert contents of file FILENAME after point. Returns list of absolute file name and number of characters inserted. If second argument VISIT is non-nil, the buffer's visited filename and last save file modtime are set, and it is marked unmodified. If visiting and the file does not exist, visiting is completed before the error is signaled.

The optional third and fourth arguments BEG and END specify what portion of the file to insert. These arguments count bytes in the file, not characters in the buffer. If VISIT is non-nil, BEG and END must be nil.

If optional fifth argument REPLACE is non-nil, replace the current buffer contents (in the accessible portion) with the file contents. This is better than simply deleting and inserting the whole thing because (1) it preserves some marker positions and (2) it puts less data in the undo list. When REPLACE is non-nil, the second return value is the number of characters that replace previous buffer contents.

This function does code conversion according to the value of coding-system-for-read' orfile-coding-system-alist', and sets the variable `last-coding-system-used' to the coding system actually used.

Return file name FILENAME sans its directory. For example, in a Unix-syntax file name, this is everything after the last slash, or the entire name if it contains no slash.

Substitute environment variables referred to in FILENAME. `$FOO' where FOO is an environment variable name means to substitute the value of that variable. The variable name should be terminated with a character not a letter, digit or underscore; otherwise, enclose the entire variable name in braces.

If /~' appears, all of FILENAME through that/' is discarded. If `//' appears, everything up to and including the first of those `/' is discarded.

Return t if FILENAME names an existing directory. Symbolic links to directories count as directories. See `file-symlink-p' to distinguish symlinks.

Mark current buffer as auto-saved with its current text. No auto-save file will be written until the buffer changes again.

Set times of file FILENAME to TIMESTAMP. Set both access and modification times. Return t on success, else nil. Use the current time if TIMESTAMP is nil. TIMESTAMP is in the format of `current-time'.

Set mode bits of file named FILENAME to MODE (an integer). Only the 12 low bits of MODE are used.

Interactively, mode bits are read by `read-file-modes', which accepts symbolic notation, like the `chmod' command from GNU Coreutils.

Return t if file FILENAME names a directory you can open. For the value to be t, FILENAME must specify the name of a directory as a file, and the directory must allow you to open files in it. In order to use a directory as a buffer's current directory, this predicate must return true. A directory name spec may be given instead; then the value is t if the directory so specified exists and really is a readable and searchable directory.

Return a string representing the file name FILE interpreted as a directory. This operation exists because a directory is also a file, but its name as a directory is different from its name as a file. The result can be used as the value of `default-directory' or passed as second argument to `expand-file-name'. For a Unix-syntax file name, just appends a slash.

Copy FILE to NEWNAME. Both args must be strings. If NEWNAME names a directory, copy FILE there.

This function always sets the file modes of the output file to match the input file.

The optional third argument OK-IF-ALREADY-EXISTS specifies what to do if file NEWNAME already exists. If OK-IF-ALREADY-EXISTS is nil, we signal a `file-already-exists' error without overwriting. If OK-IF-ALREADY-EXISTS is a number, we request confirmation from the user about overwriting; this is what happens in interactive use with M-x. Any other value for OK-IF-ALREADY-EXISTS means to overwrite the existing file.

Fourth arg KEEP-TIME non-nil means give the output file the same last-modified time as the old one. (This works on only some systems.)

A prefix arg makes KEEP-TIME non-nil.

If PRESERVE-UID-GID is non-nil, we try to transfer the uid and gid of FILE to NEWNAME.

If PRESERVE-SELINUX-CONTEXT is non-nil and SELinux is enabled on the system, we copy the SELinux context of FILE to NEWNAME.

Return t if FILENAME names a regular file. This is the sort of file that holds an ordinary stream of data bytes. Symbolic links to regular files count as regular files. See `file-symlink-p' to distinguish symlinks.

Return the directory component in file name FILENAME. Return nil if FILENAME does not include a directory. Otherwise return a directory name. Given a Unix syntax file name, returns a string ending in slash.

Return non-nil if file FILENAME is the name of a symbolic link. The value is the link target, as a string. Otherwise it returns nil.

This function returns t when given the name of a symlink that points to a nonexistent file.

Return a directly usable directory name somehow associated with FILENAME. A `directly usable' directory name is one that may be used without the intervention of any file handler. If FILENAME is a directly usable file itself, return (file-name-directory FILENAME). If FILENAME refers to a file which is not accessible from a local process, then this should return nil. The call-process' andstart-process' functions use this function to get a current directory to run processes in.

Return mode bits of file named FILENAME, as an integer. Return nil, if file does not exist or is not accessible.

Return t if a call to `read-file-name' will use a dialog. The return value is only relevant for a call to `read-file-name' that happens before any other event (mouse or keypress) is handled.

If t, splitting a window makes a new parent window. If this variable is nil, splitting a window will create a new parent window only if the window has no parent window or the window shall become a combination orthogonal to the one it is part of.

If this variable is t, splitting a window always creates a new parent window. If all splits behave this way, each frame's window tree is a binary tree and every window but the frame's root window has exactly one sibling.

Other values are reserved for future use.

The value of this variable is also assigned to the combination limit of the new parent window. The combination limit of a window can be retrieved via the function `window-combination-limit' and altered by the function `set-window-combination-limit'.

You can customize this variable.

Functions to call when window configuration changes. The buffer-local part is run once per window, with the relevant window selected; while the global part is run only once for the modified frame, with the relevant frame selected.

If non-nil, this is a buffer and C-M-v should scroll its window.

Alist of persistent window parameters. This alist specifies which window parameters shall get saved by current-window-configuration' andwindow-state-get' and subsequently restored to their previous values by `set-window-configuration' and `window-state-put'.

The car of each entry of this alist is the symbol specifying the parameter. The cdr is one of the following:

nil means the parameter is neither saved by `window-state-get' nor by `current-window-configuration'.

t means the parameter is saved by `current-window-configuration' and, provided its WRITABLE argument is nil, by `window-state-get'.

The symbol `writable' means the parameter is saved unconditionally by both current-window-configuration' andwindow-state-get'. Do not use this value for parameters without read syntax (like windows or frames).

Parameters not saved by `current-window-configuration' or window-state-get' are left alone byset-window-configuration' respectively are not installed by `window-state-put'.

Non-nil means it is the window that C-M-v in minibuffer should scroll.

Non-nil means to automatically adjust `window-vscroll' to view tall lines.

Non-nil means to use `mode-line-inactive' face in non-selected windows. If the minibuffer is active, the `minibuffer-scroll-window' mode line is displayed in the `mode-line' face.

You can customize this variable.

Non-nil means call as function to display a help buffer. The function is called with one argument, the buffer to be displayed. Used by `with-output-to-temp-buffer'. If this function is used, then it must do the entire job of showing the buffer; `temp-buffer-show-hook' is not run unless this function runs it.

You can customize this variable.

Number of lines of continuity when scrolling by screenfuls.

You can customize this variable.

Type of marker to use for `window-point'.

Non-nil means `recenter' redraws entire frame. If this option is non-nil, then the `recenter' command with a nil argument will redraw the entire frame; the special value `tty' causes the frame to be redrawn only if it is a tty frame.

You can customize this variable.

Controls if scroll commands move point to keep its screen position unchanged. A value of nil means point does not keep its screen position except at the scroll margin or window boundary respectively. A value of t means point keeps its screen position if the scroll command moved it vertically out of the window, e.g. when scrolling by full screens. Any other value means point always keeps its screen position. Scroll commands should have the `scroll-command' property on their symbols to be controlled by this variable.

You can customize this variable.

If t, resize window combinations proportionally. If this variable is nil, splitting a window gets the entire screen space for displaying the new window from the window to split. Deleting and resizing a window preferably resizes one adjacent window only.

If this variable is t, splitting a window tries to get the space proportionally from all windows in the same combination. This also allows to split a window that is otherwise too small or of fixed size. Resizing and deleting a window proportionally resize all windows in the same combination.

Other values are reserved for future use.

This variable takes no effect if `window-combination-limit' is non-nil.

You can customize this variable.

Return t if OBJECT is a live window and nil otherwise. A live window is a window that displays a buffer. Internal windows and deleted windows are not live.

Return combination limit of window WINDOW. If the return value is nil, child windows of WINDOW can be recombined with WINDOW's siblings. A return value of t means that child windows of WINDOW are never (re-)combined with WINDOW's siblings.

Return the total width, in columns, of window WINDOW. If WINDOW is omitted or nil, it defaults to the selected window.

The return value includes any vertical dividers or scroll bars belonging to WINDOW. If WINDOW is an internal window, the total width is the width of the screen areas spanned by its children.

On a graphical display, this total width is reported as an integer multiple of the default character width.

Return the normal height of window WINDOW. If WINDOW is omitted or nil, it defaults to the selected window. If HORIZONTAL is non-nil, return the normal width of WINDOW.

Scroll next window upward ARG lines; or near full screen if no ARG. A near full screen is `next-screen-context-lines' less than a full screen. The next window is the one below the current one; or the one at the top if the current one is at the bottom. Negative ARG means scroll downward. If ARG is the atom `-', scroll downward by nearly full screen. When calling from a program, supply as argument a number, nil, or `-'.

If `other-window-scroll-buffer' is non-nil, scroll the window showing that buffer, popping the buffer up if necessary. If in the minibuffer, `minibuffer-scroll-window' if non-nil specifies the window to scroll. This takes precedence over `other-window-scroll-buffer'.

Return a list of the edge pixel coordinates of WINDOW's text area. The list has the form (LEFT TOP RIGHT BOTTOM), all relative to (0,0) at the top left corner of the frame's window area.

RIGHT is one more than the rightmost x position of WINDOW's text area. BOTTOM is one more than the bottommost y position of WINDOW's text area. The inside edges do not include the space used by WINDOW's scroll bar, display margins, fringes, header line, and/or mode line.

Set number of columns WINDOW is scrolled from left margin to NCOL. If WINDOW is nil, the selected window is used. Return NCOL. NCOL should be zero or positive.

Note that if `automatic-hscrolling' is non-nil, you cannot scroll the window so that the location of point moves off-window.

Center point in selected window and maybe redisplay frame. With prefix argument ARG, recenter putting point on screen line ARG relative to the selected window. If ARG is negative, it counts up from the bottom of the window. (ARG should be less than the height of the window.)

If ARG is omitted or nil, then recenter with point on the middle line of the selected window; if the variable `recenter-redisplay' is non-nil, also erase the entire frame and redraw it (when `auto-resize-tool-bars' is set to `grow-only', this resets the tool-bar's height to the minimum height needed); if recenter-redisplay' has the special valuetty', then only tty frames are redrawn.

Just C-u as prefix means put point in the center of the window and redisplay normally--don't erase and redraw the frame.

Scroll text of selected window down ARG lines. If ARG is omitted or nil, scroll down by a near full screen. A near full screen is `next-screen-context-lines' less than a full screen. Negative ARG means scroll upward. If ARG is the atom `-', scroll upward by nearly full screen. When calling from a program, supply as argument a number, nil, or `-'.

Return t if OBJECT is a window-configuration object.

Return the minibuffer window for frame FRAME. If FRAME is omitted or nil, it defaults to the selected frame.

Scroll text of selected window upward ARG lines. If ARG is omitted or nil, scroll upward by a near full screen. A near full screen is `next-screen-context-lines' less than a full screen. Negative ARG means scroll downward. If ARG is the atom `-', scroll downward by nearly full screen. When calling from a program, supply as argument a number, nil, or `-'.

Return the other window for "other window scroll" commands. If `other-window-scroll-buffer' is non-nil, a window showing that buffer is used. If in the minibuffer, `minibuffer-scroll-window' if non-nil specifies the window. This takes precedence over `other-window-scroll-buffer'.

Set WINDOW's display-table to TABLE.

Return the parent window of window WINDOW. If WINDOW is omitted or nil, it defaults to the selected window. Return nil for a window with no parent (e.g. a root window).

Return non-nil if position POS is currently on the frame in WINDOW. Return nil if that position is scrolled vertically out of view. If a character is only partially visible, nil is returned, unless the optional argument PARTIALLY is non-nil. If POS is only out of view because of horizontal scrolling, return non-nil. If POS is t, it specifies the position of the last visible glyph in WINDOW. POS defaults to point in WINDOW; WINDOW defaults to the selected window.

If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil, return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]), where X and Y are the pixel coordinates relative to the top left corner of the window. The remaining elements are omitted if the character after POS is fully visible; otherwise, RTOP and RBOT are the number of pixels off-window at the top and bottom of the row, ROWH is the height of the display row, and VPOS is the row number (0-based) containing POS.

Resize minibuffer window WINDOW.

Return position at which display currently ends in WINDOW. WINDOW must be a live window and defaults to the selected one. This is updated by redisplay, when it runs to completion. Simply changing the buffer text or setting `window-start' does not update this value. Return nil if there is no recorded value. (This can happen if the last redisplay of WINDOW was preempted, and did not finish.) If UPDATE is non-nil, compute the up-to-date position if it isn't already recorded.

Set width of marginal areas of window WINDOW. If WINDOW is nil, set margins of the currently selected window. Second arg LEFT-WIDTH specifies the number of character cells to reserve for the left marginal area. Optional third arg RIGHT-WIDTH does the same for the right marginal area. A nil width parameter means no margin.

Make point value in WINDOW be at position POS in WINDOW's buffer. Return POS.

Return current value of point in WINDOW. WINDOW must be a live window and defaults to the selected one.

For a nonselected window, this is the value point would have if that window were selected.

Note that, when WINDOW is the selected window and its buffer is also currently selected, the value returned is the same as (point). It would be more strictly correct to return the `top-level' value of point, outside of any save-excursion forms. But that is hard to define.

Return a list of the edge pixel coordinates of WINDOW. The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at the top left corner of the frame.

RIGHT is one more than the rightmost x position occupied by WINDOW. BOTTOM is one more than the bottommost y position occupied by WINDOW. The pixel edges include the space used by WINDOW's scroll bar, display margins, fringes, header line, and/or mode line. For the pixel edges of just the text area, use `window-inside-pixel-edges'.

Return left column of window WINDOW. This is the distance, in columns, between the left edge of WINDOW and the left edge of the frame's window area. For instance, the return value is 0 if there is no window to the left of WINDOW.

If WINDOW is omitted or nil, it defaults to the selected window.

Return the next sibling window of window WINDOW. If WINDOW is omitted or nil, it defaults to the selected window. Return nil if WINDOW has no next sibling.

Return list of buffers recently re-shown in WINDOW. WINDOW must be a live window and defaults to the selected one.

Set combination limit of window WINDOW to LIMIT; return LIMIT. If LIMIT is nil, child windows of WINDOW can be recombined with WINDOW's siblings. LIMIT t means that child windows of WINDOW are never (re-)combined with WINDOW's siblings. Other values are reserved for future use.

Set WINDOW's next buffers to NEXT-BUFFERS. WINDOW must be a live window and defaults to the selected one. NEXT-BUFFERS should be a list of buffers.

This function is obsolete since 23.1.

Set WINDOW's redisplay end trigger value to VALUE. VALUE should be a buffer position (typically a marker) or nil. If it is a buffer position, then if redisplay in WINDOW reaches a position beyond VALUE, the functions in `redisplay-end-trigger-functions' are called with two arguments: WINDOW, and the end trigger value. Afterwards the end-trigger value is reset to nil.

Return an object representing the current window configuration of FRAME. If FRAME is nil or omitted, use the selected frame. This describes the number of windows, their sizes and current buffers, and for each displayed buffer, where display starts, and the positions of point and mark. An exception is made for point in the current buffer: its value is -not- saved. This also records the currently selected frame, and FRAME's focus redirection (see `redirect-frame-focus'). The variable `window-persistent-parameters' specifies which window parameters are saved by this function.

Set WINDOW's value of PARAMETER to VALUE. WINDOW defaults to the selected window. Return VALUE.

Return non-nil if COORDINATES are in WINDOW. WINDOW must be a live window. COORDINATES is a cons of the form (X . Y), X and Y being distances measured in characters from the upper-left corner of the frame. (0 . 0) denotes the character in the upper left corner of the frame. If COORDINATES are in the text portion of WINDOW, the coordinates relative to the window are returned. If they are in the mode line of WINDOW, `mode-line' is returned. If they are in the top mode line of WINDOW, `header-line' is returned. If they are in the left fringe of WINDOW, `left-fringe' is returned. If they are in the right fringe of WINDOW, `right-fringe' is returned. If they are on the border between WINDOW and its right sibling, `vertical-line' is returned. If they are in the windows's left or right marginal areas, `left-margin' or `right-margin' is returned.

Return top line of window WINDOW. This is the distance, in lines, between the top of WINDOW and the top of the frame's window area. For instance, the return value is 0 if there is no window above WINDOW.

If WINDOW is omitted or nil, it defaults to the selected window.

Return height in pixels of text line LINE in window WINDOW. WINDOW defaults to the selected window.

Return height of current line if LINE is omitted or nil. Return height of header or mode line if LINE is header-line' ormode-line'. Otherwise, LINE is a text line number starting from 0. A negative number counts from the end of the window.

Value is a list (HEIGHT VPOS YPOS OFFBOT), where HEIGHT is the height in pixels of the visible part of the line, VPOS and YPOS are the vertical position in lines and pixels of the line, relative to the top of the first text line, and OFFBOT is the number of off-window pixels at the bottom of the text line. If there are off-window pixels at the top of the (first) text line, YPOS is negative.

Return nil if window display is not up-to-date. In that case, use `pos-visible-in-window-p' to obtain the information.

Set width and type of scroll bars of window WINDOW. If window is nil, set scroll bars of the currently selected window. Second parameter WIDTH specifies the pixel width for the scroll bar; this is automatically adjusted to a multiple of the frame column width. Third parameter VERTICAL-TYPE specifies the type of the vertical scroll bar: left, right, or nil. If WIDTH is nil, use the frame's scroll-bar width. If VERTICAL-TYPE is t, use the frame's scroll-bar type. Fourth parameter HORIZONTAL-TYPE is currently unused.

Run `window-configuration-change-hook' for FRAME.

Get width of marginal areas of window WINDOW. If WINDOW is omitted or nil, it defaults to the selected window. Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH). If a marginal area does not exist, its width will be returned as nil.

Make WINDOW fill its frame. Only the frame WINDOW is on is affected. WINDOW may be any window and defaults to the selected one.

Optional argument ROOT, if non-nil, must specify an internal window such that WINDOW is in its window subtree. If this is the case, replace ROOT by WINDOW and leave alone any windows not part of ROOT's subtree.

When WINDOW is live try to reduce display jumps by keeping the text previously visible in WINDOW in the same place on the frame. Doing this depends on the value of (window-start WINDOW), so if calling this function in a program gives strange scrolling, make sure the window-start value is reasonable when this function is called.

Return a list of the edge pixel coordinates of WINDOW's text area. The list has the form (LEFT TOP RIGHT BOTTOM), all relative to (0,0) at the top left corner of the frame's window area.

RIGHT is one more than the rightmost x position of WINDOW's text area. BOTTOM is one more than the bottommost y position of WINDOW's text area. The inside edges do not include the space used by WINDOW's scroll bar, display margins, fringes, header line, and/or mode line.

Return the use time of window WINDOW. If WINDOW is omitted or nil, it defaults to the selected window. The window with the highest use time is the most recently selected one. The window with the lowest use time is the least recently selected one.

Split window OLD. Second argument TOTAL-SIZE specifies the number of lines or columns of the new window. In any case TOTAL-SIZE must be a positive integer.

Third argument SIDE nil (or `below') specifies that the new window shall be located below WINDOW. SIDE `above' means the new window shall be located above WINDOW. In both cases TOTAL-SIZE specifies the number of lines of the new window including space reserved for the mode and/or header line.

SIDE t (or `right') specifies that the new window shall be located on the right side of WINDOW. SIDE `left' means the new window shall be located on the left of WINDOW. In both cases TOTAL-SIZE specifies the number of columns of the new window including space reserved for fringes and the scrollbar or a divider column.

Fourth argument NORMAL-SIZE specifies the normal size of the new window according to the SIDE argument.

The new total and normal sizes of all involved windows must have been set correctly. See the code of `split-window' for how this is done.

Return the frame that CONFIG, a window-configuration object, is about.

Set new total size of WINDOW to SIZE. Return SIZE.

Optional argument ADD non-nil means add SIZE to the new total size of WINDOW and return the sum.

Note: This function does not operate on any child windows of WINDOW.

Return position at which display currently starts in WINDOW. WINDOW must be a live window and defaults to the selected one. This is updated by redisplay or by calling `set-window-start'.

Make WINDOW display BUFFER-OR-NAME as its contents. WINDOW has to be a live window and defaults to the selected one. BUFFER-OR-NAME must be a buffer or the name of an existing buffer.

Optional third argument KEEP-MARGINS non-nil means that WINDOW's current display margins, fringe widths, and scroll bar settings are preserved; the default is to reset these from the local settings for BUFFER-OR-NAME or the frame defaults. Return nil.

This function throws an error when WINDOW is strongly dedicated to its buffer (that is `window-dedicated-p' returns t for WINDOW) and does not already display BUFFER-OR-NAME.

This function runs `window-scroll-functions' before running `window-configuration-change-hook'.

Return WINDOW's value for PARAMETER. WINDOW defaults to the selected window.

This function is obsolete since 23.1.

Return WINDOW's redisplay end trigger value. WINDOW defaults to the selected window. See `set-window-redisplay-end-trigger' for more information.

Select WINDOW. Most editing will apply to WINDOW's buffer. Also make WINDOW's buffer current and make WINDOW the frame's selected window. Return WINDOW.

Optional second arg NORECORD non-nil means do not put this buffer at the front of the buffer list and do not make this window the most recently selected one.

Note that the main editor command loop sets the current buffer to the buffer of the selected window before each command.

Return a list of the edge pixel coordinates of WINDOW. The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at the top left corner of the display.

RIGHT is one more than the rightmost x position occupied by WINDOW. BOTTOM is one more than the bottommost y position occupied by WINDOW. The pixel edges include the space used by WINDOW's scroll bar, display margins, fringes, header line, and/or mode line. For the pixel edges of just the text area, use `window-inside-absolute-pixel-edges'.

Return the total height, in lines, of window WINDOW. If WINDOW is omitted or nil, it defaults to the selected window.

The return value includes the mode line and header line, if any. If WINDOW is an internal window, the total height is the height of the screen areas spanned by its children.

On a graphical display, this total height is reported as an integer multiple of the default character height.

Return live window after WINDOW in the cyclic ordering of windows. WINDOW must be a live window and defaults to the selected one. The optional arguments MINIBUF and ALL-FRAMES specify the set of windows to consider.

MINIBUF nil or omitted means consider the minibuffer window only if the minibuffer is active. MINIBUF t means consider the minibuffer window even if the minibuffer is not active. Any other value means do not consider the minibuffer window even if the minibuffer is active.

ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame, plus the minibuffer window if specified by the MINIBUF argument. If the minibuffer counts, consider all windows on all frames that share that minibuffer too. The following non-nil values of ALL-FRAMES have special meanings:

• t means consider all windows on all existing frames.

• `visible' means consider all windows on all visible frames.

• 0 (the number zero) means consider all windows on all visible and iconified frames.

• A frame means consider all windows on that frame only.

  Anything else means consider all windows on WINDOW's frame and no others.

  If you use consistent values for MINIBUF and ALL-FRAMES, you can use `next-window' to iterate through the entire cycle of acceptable windows, eventually ending up back at the window you started with. `previous-window' traverses the same cycle, in the reverse order.

Return non-nil if WINDOW is a minibuffer window. If WINDOW is omitted or nil, it defaults to the selected window.

Return the topmost, leftmost live window on FRAME-OR-WINDOW. If omitted, FRAME-OR-WINDOW defaults to the currently selected frame. Else if FRAME-OR-WINDOW denotes any window, return the first window of that window's frame. If FRAME-OR-WINDOW denotes a live frame, return the first window of that frame.

Get width and type of scroll bars of window WINDOW. If WINDOW is omitted or nil, it defaults to the selected window. Value is a list of the form (WIDTH COLS VERTICAL-TYPE HORIZONTAL-TYPE). If WIDTH is nil or TYPE is t, the window is using the frame's corresponding value.

Return non-nil when WINDOW is dedicated to its buffer. More precisely, return the value assigned by the last call of `set-window-dedicated-p' for WINDOW. Return nil if that function was never called with WINDOW as its argument, or the value set by that function was internally reset since its last call. WINDOW defaults to the selected window.

When a window is dedicated to its buffer, `display-buffer' will refrain from displaying another buffer in it. `get-lru-window' and `get-largest-window' treat dedicated windows specially. delete-windows-on',replace-buffer-in-windows', `quit-window' and `kill-buffer' can delete a dedicated window and the containing frame.

Functions like `set-window-buffer' may change the buffer displayed by a window, unless that window is "strongly" dedicated to its buffer, that is the value returned by `window-dedicated-p' is t.

Return the selected window. The selected window is the window in which the standard cursor for selected windows appears and to which many commands apply.

Position point relative to window. ARG nil means position point at center of window. Else, ARG specifies vertical position within the window; zero means top of window, negative means relative to bottom of window.

Set amount by which WINDOW should be scrolled vertically to VSCROLL. WINDOW nil means use the selected window. Normally, VSCROLL is a non-negative multiple of the canonical character height of WINDOW; optional third arg PIXELS-P non-nil means that VSCROLL is in pixels. If PIXELS-P is nil, VSCROLL may have to be rounded so that it corresponds to an integral number of pixels. The return value is the result of this rounding. If PIXELS-P is non-nil, the return value is VSCROLL.

Return new normal size of window WINDOW. If WINDOW is omitted or nil, it defaults to the selected window.

Return the amount by which WINDOW is scrolled vertically. If WINDOW is omitted or nil, it defaults to the selected window. Normally, value is a multiple of the canonical character height of WINDOW; optional second arg PIXELS-P means value is measured in pixels.

Return a window currently displaying BUFFER-OR-NAME, or nil if none. BUFFER-OR-NAME may be a buffer or a buffer name and defaults to the current buffer.

The optional argument ALL-FRAMES specifies the frames to consider:

• t means consider all windows on all existing frames.

• `visible' means consider all windows on all visible frames.

• 0 (the number zero) means consider all windows on all visible and iconified frames.

• A frame means consider all windows on that frame only.

  Any other value of ALL-FRAMES means consider all windows on the selected frame and no others.

Return the display-table that WINDOW is using. WINDOW defaults to the selected window.

Return a list of windows on FRAME, starting with WINDOW. FRAME nil or omitted means use the selected frame. WINDOW nil or omitted means use the window selected within FRAME. MINIBUF t means include the minibuffer window, even if it isn't active. MINIBUF nil or omitted means include the minibuffer window only if it's active. MINIBUF neither nil nor t means never include the minibuffer window.

Return the root window of FRAME-OR-WINDOW. If omitted, FRAME-OR-WINDOW defaults to the currently selected frame. With a frame argument, return that frame's root window. With a window argument, return the root window of that window's frame.

Get width of fringes of window WINDOW. If WINDOW is omitted or nil, it defaults to the selected window. Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS).

Return the parameters of WINDOW and their values. WINDOW defaults to the selected window. The return value is a list of elements of the form (PARAMETER . VALUE).

Return window containing coordinates X and Y on FRAME. FRAME must be a live frame and defaults to the selected one. The top left corner of the frame is considered to be row 0, column 0.

Return the buffer displayed in window WINDOW. If WINDOW is omitted or nil, it defaults to the selected window. Return nil for an internal window or a deleted window.

Set the configuration of windows and buffers as specified by CONFIGURATION. CONFIGURATION must be a value previously returned by `current-window-configuration' (which see). If CONFIGURATION was made from a frame that is now deleted, only frame-independent values can be restored. In this case, the return value is nil. Otherwise the value is t.

Force all windows to be updated on next redisplay. If optional arg OBJECT is a window, force redisplay of that window only. If OBJECT is a buffer or buffer name, force redisplay of all windows displaying that buffer.

Return a list of all live windows. WINDOW specifies the first window to list and defaults to the selected window.

Optional argument MINIBUF nil or omitted means consider the minibuffer window only if the minibuffer is active. MINIBUF t means consider the minibuffer window even if the minibuffer is not active. Any other value means do not consider the minibuffer window even if the minibuffer is active.

Optional argument ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame, plus the minibuffer window if specified by the MINIBUF argument. If the minibuffer counts, consider all windows on all frames that share that minibuffer too. The following non-nil values of ALL-FRAMES have special meanings:

• t means consider all windows on all existing frames.

• `visible' means consider all windows on all visible frames.

• 0 (the number zero) means consider all windows on all visible and iconified frames.

• A frame means consider all windows on that frame only.

  Anything else means consider all windows on WINDOW's frame and no others.

  If WINDOW is not on the list of windows returned, some other window will be listed first but no error is signaled.

Set the fringe widths of window WINDOW. If WINDOW is nil, set the fringe widths of the currently selected window. Second arg LEFT-WIDTH specifies the number of pixels to reserve for the left fringe. Optional third arg RIGHT-WIDTH specifies the right fringe width. If a fringe width arg is nil, that means to use the frame's default fringe width. Default fringe widths can be set with the command `set-fringe-style'. If optional fourth arg OUTSIDE-MARGINS is non-nil, draw the fringes outside of the display margins. By default, fringes are drawn between display marginal areas and the text area.

Remove WINDOW from its frame. WINDOW defaults to the selected window. Return nil. Signal an error when WINDOW is the only window on its frame.

Return the number of columns by which WINDOW is scrolled from left margin. WINDOW must be a live window and defaults to the selected one.

Return the previous sibling window of window WINDOW. If WINDOW is omitted or nil, it defaults to the selected window. Return nil if WINDOW has no previous sibling.

Return the width, in columns, of WINDOW's text area. If WINDOW is omitted or nil, it defaults to the selected window. Signal an error if the window is not live.

The return value does not include any vertical dividers, fringe or marginal areas, or scroll bars. On a graphical display, the width is expressed as an integer multiple of the default character width.

Set WINDOW's previous buffers to PREV-BUFFERS. WINDOW must be a live window and defaults to the selected one.

PREV-BUFFERS should be a list of elements (BUFFER WINDOW-START POS), where BUFFER is a buffer, WINDOW-START is the start position of the window for that buffer, and POS is a window-specific point value.

Return buffers previously shown in WINDOW. WINDOW must be a live window and defaults to the selected one.

The return value is a list of elements (BUFFER WINDOW-START POS), where BUFFER is a buffer, WINDOW-START is the start position of the window for that buffer, and POS is a window-specific point value.

Return the window which was selected when entering the minibuffer. Returns nil, if selected window is not a minibuffer window.

Return t if OBJECT is a window and nil otherwise.

Mark WINDOW as dedicated according to FLAG. WINDOW must be a live window and defaults to the selected one. FLAG non-nil means mark WINDOW as dedicated to its buffer. FLAG nil means mark WINDOW as non-dedicated. Return FLAG.

When a window is dedicated to its buffer, `display-buffer' will refrain from displaying another buffer in it. `get-lru-window' and `get-largest-window' treat dedicated windows specially. delete-windows-on',replace-buffer-in-windows', `quit-window', quit-restore-window' andkill-buffer' can delete a dedicated window and the containing frame.

As a special case, if FLAG is t, mark WINDOW as "strongly" dedicated to its buffer. Functions like `set-window-buffer' may change the buffer displayed by a window, unless that window is strongly dedicated to its buffer. If and when `set-window-buffer' displays another buffer in a window, it also makes sure that the window is no more dedicated.

Return the height in lines of the text display area of WINDOW. If WINDOW is omitted or nil, it defaults to the selected window.

The returned height does not include the mode line, any header line, nor any partial-height lines at the bottom of the text area.

Set selected window of FRAME to WINDOW. FRAME must be a live frame and defaults to the selected one. If FRAME is the selected frame, this makes WINDOW the selected window. Optional argument NORECORD non-nil means to neither change the order of recently selected windows nor the buffer list. WINDOW must denote a live window. Return WINDOW.

Return a list of the edge coordinates of WINDOW. The list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM count by lines, and LEFT and RIGHT count by columns, all relative to 0, 0 at top left corner of frame.

RIGHT is one more than the rightmost column of WINDOW's text area. BOTTOM is one more than the bottommost row of WINDOW's text area. The inside edges do not include the space used by the WINDOW's scroll bar, display margins, fringes, header line, and/or mode line.

Return the selected window of FRAME-OR-WINDOW. If omitted, FRAME-OR-WINDOW defaults to the currently selected frame. Else if FRAME-OR-WINDOW denotes any window, return the selected window of that window's frame. If FRAME-OR-WINDOW denotes a live frame, return the selected window of that frame.

Return the height, in lines, of WINDOW's text area. If WINDOW is omitted or nil, it defaults to the selected window. Signal an error if the window is not live.

The returned height does not include the mode line or header line. On a graphical display, the height is expressed as an integer multiple of the default character height. If a line at the bottom of the text area is only partially visible, that counts as a whole line; to exclude partially-visible lines, use `window-text-height'.

Return live window before WINDOW in the cyclic ordering of windows. WINDOW must be a live window and defaults to the selected one. The optional arguments MINIBUF and ALL-FRAMES specify the set of windows to consider.

MINIBUF nil or omitted means consider the minibuffer window only if the minibuffer is active. MINIBUF t means consider the minibuffer window even if the minibuffer is not active. Any other value means do not consider the minibuffer window even if the minibuffer is active.

ALL-FRAMES nil or omitted means consider all windows on WINDOW's frame, plus the minibuffer window if specified by the MINIBUF argument. If the minibuffer counts, consider all windows on all frames that share that minibuffer too. The following non-nil values of ALL-FRAMES have special meanings:

• t means consider all windows on all existing frames.

• `visible' means consider all windows on all visible frames.

• 0 (the number zero) means consider all windows on all visible and iconified frames.

• A frame means consider all windows on that frame only.

  Anything else means consider all windows on WINDOW's frame and no others.

  If you use consistent values for MINIBUF and ALL-FRAMES, you can use `previous-window' to iterate through the entire cycle of acceptable windows, eventually ending up back at the window you started with. `next-window' traverses the same cycle, in the reverse order.

Set new normal size of WINDOW to SIZE. Return SIZE.

Note: This function does not operate on any child windows of WINDOW.

Scroll selected window display ARG columns right. Default for ARG is window width minus 2. Value is the total amount of leftward horizontal scrolling in effect after the change. If SET-MINIMUM is non-nil, the new scroll amount becomes the lower bound for automatic scrolling, i.e. automatic scrolling will not scroll a window to a column less than the value returned by this function. This happens in an interactive call.

Make display in WINDOW start at position POS in WINDOW's buffer. If WINDOW is nil, the selected window is used. Return POS. Optional third arg NOFORCE non-nil inhibits next redisplay from overriding motion of point in order to display at this exact start.

Return the topmost child window of window WINDOW. Return nil if WINDOW is a live window (live windows have no children). Return nil if WINDOW is an internal window whose children form a horizontal combination.

Return the new total size of window WINDOW. If WINDOW is omitted or nil, it defaults to the selected window.

Return the frame that window WINDOW is on. If WINDOW is omitted or nil, it defaults to the selected window.

Scroll selected window display ARG columns left. Default for ARG is window width minus 2. Value is the total amount of leftward horizontal scrolling in effect after the change. If SET-MINIMUM is non-nil, the new scroll amount becomes the lower bound for automatic scrolling, i.e. automatic scrolling will not scroll a window to a column less than the value returned by this function. This happens in an interactive call.

Return the leftmost child window of window WINDOW. Return nil if WINDOW is a live window (live windows have no children). Return nil if WINDOW is an internal window whose children form a vertical combination.

Return a list of the edge coordinates of WINDOW. The list has the form (LEFT TOP RIGHT BOTTOM). TOP and BOTTOM count by lines, and LEFT and RIGHT count by columns, all relative to 0, 0 at top left corner of frame.

RIGHT is one more than the rightmost column occupied by WINDOW. BOTTOM is one more than the bottommost row occupied by WINDOW. The edges include the space used by WINDOW's scroll bar, display margins, fringes, header line, and/or mode line. For the edges of just the text area, use `window-inside-edges'.

Apply requested size values for window-tree of FRAME. Optional argument HORIZONTAL omitted or nil means apply requested height values. HORIZONTAL non-nil means apply requested width values.

This function checks whether the requested values sum up to a valid window layout, recursively assigns the new sizes of all child windows and calculates and assigns the new start positions of these windows.

Note: This function does not check any of `window-fixed-size-p', window-min-height' orwindow-min-width'. All these checks have to be applied on the Elisp level.

Compare two window configurations as regards the structure of windows. This function ignores details such as the values of point and mark and scrolling positions.

Internal function for `with-output-to-temp-buffer'.

*Non-nil means mouse commands use dialog boxes to ask questions. This applies to y-or-n-p' andyes-or-no-p' questions asked by commands invoked by mouse clicks and mouse menu items.

On some platforms, file selection dialogs are also enabled if this is non-nil.

You can customize this variable.

*Non-nil means mouse commands use a file dialog to ask for files. This applies to commands from menus and tool bar buttons even when they are initiated from the keyboard. If `use-dialog-box' is nil, that disables the use of a file dialog, regardless of the value of this variable.

You can customize this variable.

A list of symbols which are the features of the executing Emacs. Used by featurep' andrequire', and altered by `provide'.

Announce that FEATURE is a feature of the current Emacs. The optional argument SUBFEATURES should be a list of symbols listing particular subfeatures supported in this version of FEATURE.

In WIDGET, get the value of PROPERTY. The value could either be specified when the widget was created, or later with `widget-put'.

Return a multibyte string with the same individual bytes as STRING. If STRING is multibyte, the result is STRING itself. Otherwise it is a newly created string, with no text properties.

If STRING is unibyte and contains an individual 8-bit byte (i.e. not part of a correct utf-8 sequence), it is converted to the corresponding multibyte character of charset `eight-bit'. See also `string-to-multibyte'.

Beware, this often doesn't really do what you think it does. It is similar to (decode-coding-string STRING 'utf-8-emacs). If you're not sure, whether to use `string-as-multibyte' or string-to-multibyte', usestring-to-multibyte'.

Change value in PLIST of PROP to VAL, comparing with `equal'. PLIST is a property list, which is a list of the form (PROP1 VALUE1 PROP2 VALUE2 ...). PROP and VAL are any objects. If PROP is already a property on the list, its value is set to VAL, otherwise the new PROP VAL pair is added. The new plist is returned; use `(setq x (lax-plist-put x prop val))' to be sure to use the new value. The PLIST is modified by side effects.

Return the length of a list, but avoid error or infinite loop. This function never gets an error. If LIST is not really a list, it returns 0. If LIST is circular, it returns a finite value which is at least the number of distinct elements.

Return non-nil if ELT is an element of LIST. Comparison done with `equal'. The value is actually the tail of LIST whose car is ELT.

Return a copy of hash table TABLE.

Concatenate all the arguments and make the result a list. The result is a list whose elements are the elements of all the arguments. Each argument xmay be a list, vector or string. The last argument is not copied, just used as the tail of the new list.

Apply FUNCTION to each element of SEQUENCE, and concat the results as strings. In between each pair of results, stick in SEPARATOR. Thus, " " as SEPARATOR results in spaces between the values returned by FUNCTION. SEQUENCE may be a list, a vector, a bool-vector, or a string.

Compare the contents of two strings, converting to multibyte if needed. In string STR1, skip the first START1 characters and stop at END1. In string STR2, skip the first START2 characters and stop at END2. END1 and END2 default to the full lengths of the respective strings.

Case is significant in this comparison if IGNORE-CASE is nil. Unibyte strings are converted to multibyte for comparison.

The value is t if the strings (or specified portions) match. If string STR1 is less, the value is a negative number N; - 1 - N is the number of characters that match at the beginning. If string STR1 is greater, the value is a positive number N; N - 1 is the number of characters that match at the beginning.

Return a copy of ALIST. This is an alist which represents the same mapping from objects to objects, but does not share the alist structure with ALIST. The objects mapped (cars and cdrs of elements of the alist) are shared, however. Elements of ALIST that are not conses are also shared.

Return the secure hash of OBJECT, a buffer or string. ALGORITHM is a symbol specifying the hash to use: md5, sha1, sha224, sha256, sha384 or sha512.

The two optional arguments START and END are positions specifying for which part of OBJECT to compute the hash. If nil or omitted, uses the whole OBJECT.

If BINARY is non-nil, returns a string in binary form.

Return a copy of a list, vector, string or char-table. The elements of a list or vector are not copied; they are shared with the original.

Return a unibyte string with the same individual bytes as STRING. If STRING is unibyte, the result is STRING itself. Otherwise it is a newly created string, with no text properties. If STRING is multibyte and contains a character of charset `eight-bit', it is converted to the corresponding single byte.

Compute a hash code for OBJ and return it as integer.

Return MD5 message digest of OBJECT, a buffer or string.

A message digest is a cryptographic checksum of a document, and the algorithm to calculate it is defined in RFC 1321.

The two optional arguments START and END are character positions specifying for which part of OBJECT the message digest should be computed. If nil or omitted, the digest is computed for the whole OBJECT.

The MD5 message digest is computed from the result of encoding the text in a coding system, not directly from the internal Emacs form of the text. The optional fourth argument CODING-SYSTEM specifies which coding system to encode the text with. It should be the same coding system that you used or will use when actually writing the text into a file.

If CODING-SYSTEM is nil or omitted, the default depends on OBJECT. If OBJECT is a buffer, the default for CODING-SYSTEM is whatever coding system would be chosen by default for writing this text into a file.

If OBJECT is a string, the most preferred coding system (see the command `prefer-coding-system') is used.

If NOERROR is non-nil, silently assume the `raw-text' coding if the guesswork fails. Normally, an error is signaled in such case.

Apply the value of WIDGET's PROPERTY to the widget itself. ARGS are passed as extra arguments to the function.

Return t if OBJ is a Lisp hash table object.

Delete by side effect any occurrences of ELT as a member of SEQ. SEQ must be a list, a vector, or a string. The modified SEQ is returned. Comparison is done with `equal'. If SEQ is not a list, or the first member of SEQ is ELT, deleting it is not a side effect; it is simply using a different sequence. Therefore, write `(setq foo (delete element foo))' to be sure of changing the value of `foo'.

Access locale data ITEM for the current C locale, if available. ITEM should be one of the following:

`codeset', returning the character set as a string (locale item CODESET);

`days', returning a 7-element vector of day names (locale items DAY_n);

`months', returning a 12-element vector of month names (locale items MON_n);

`paper', returning a list (WIDTH HEIGHT) for the default paper size, both measured in millimeters (locale items PAPERWIDTH, PAPERHEIGHT).

If the system can't provide such information through a call to `nl_langinfo', or if ITEM isn't from the list above, return nil.

See also Info node `(libc)Locales'.

The data read from the system are decoded using `locale-coding-system'.

Return a multibyte string with the same individual chars as STRING. If STRING is multibyte, the result is STRING itself. Otherwise it is a newly created string, with no text properties.

If STRING is unibyte and contains an 8-bit byte, it is converted to the corresponding multibyte character of charset `eight-bit'.

This differs from `string-as-multibyte' by converting each byte of a correct utf-8 sequence to an eight-bit character, not just bytes that don't form a correct sequence.

Return t if the two args are the same Lisp object. Floating-point numbers of equal value are eql', but they may not beeq'.

Extract a value from a property list. PLIST is a property list, which is a list of the form (PROP1 VALUE1 PROP2 VALUE2...). This function returns the value corresponding to the given PROP, or nil if PROP is not one of the properties on the list. This function never signals an error.

Return element of SEQUENCE at index N.

Base64-encode STRING and return the result. Optional second argument NO-LINE-BREAK means do not break long lines into shorter lines.

Return t if two Lisp objects have similar structure and contents. This is like `equal' except that it compares the text properties of strings. (`equal' ignores text properties.)

Return a substring of STRING, without text properties. It starts at index FROM and ends before TO. TO may be nil or omitted; then the substring runs to the end of STRING. If FROM is nil or omitted, the substring starts at the beginning of STRING. If FROM or TO is negative, it counts from the end.

With one argument, just copy STRING without its properties.

Return a pseudo-random number. All integers representable in Lisp are equally likely. On most systems, this is 29 bits' worth. With positive integer LIMIT, return random number in interval [0,LIMIT). With argument t, set the random number seed from the current time and pid. Other values of LIMIT are ignored.

Concatenate all the arguments and make the result a string. The result is a string whose elements are the elements of all the arguments. Each argument may be a string or a list or vector of characters (integers).

Return the number of bytes in STRING. If STRING is multibyte, this may be greater than the length of STRING.

Return non-nil if KEY is `equal' to the car of an element of LIST. The value is actually the first element of LIST whose car equals KEY.

Remove KEY from TABLE.

Ask user a yes-or-no question. Return t if answer is yes. PROMPT is the string to display to ask the question. It should end in a space; `yes-or-no-p' adds "(yes or no) " to it.

The user must confirm the answer with RET, and can edit it until it has been confirmed.

Under a windowing system a dialog box will be used if `last-nonmenu-event' is nil, and `use-dialog-box' is non-nil.

Return the number of elements in TABLE.

Clear the contents of STRING. This makes STRING unibyte and may change its length.

Not tail recursive

Delete by side effect any occurrences of ELT as a member of LIST. The modified LIST is returned. Comparison is done with `eq'. If the first member of LIST is ELT, there is no way to remove it by side effect; therefore, write `(setq foo (delq element foo))' to be sure of changing the value of `foo'.

Return non-nil if KEY is `eq' to the car of an element of LIST. The value is actually the first element of LIST whose car is KEY. Elements of LIST that are not conses are ignored.

Return the multibyte equivalent of STRING. If STRING is unibyte and contains non-ASCII characters, the function `unibyte-char-to-multibyte' is used to convert each unibyte character to a multibyte character. In this case, the returned string is a newly created string with no text properties. If STRING is multibyte or entirely ASCII, it is returned unchanged. In particular, when STRING is unibyte and entirely ASCII, the returned string is unibyte. (When the characters are all ASCII, Emacs primitives will treat the string the same way whether it is unibyte or multibyte.)

Return t if two strings have identical contents. Case is significant, but text properties are ignored. Symbols are also allowed; their print names are used instead.

Apply FUNCTION to each element of SEQUENCE, and make a list of the results. The result is a list just as long as SEQUENCE. SEQUENCE may be a list, a vector, a bool-vector, or a string.

Store each element of ARRAY with ITEM. ARRAY is a vector, string, char-table, or bool-vector.

Return list of 1 minute, 5 minute and 15 minute load averages.

Each of the three load averages is multiplied by 100, then converted to integer.

When USE-FLOATS is non-nil, floats will be used instead of integers. These floats are not multiplied by 100.

If the 5-minute or 15-minute load averages are not available, return a shortened list, containing only those averages which are available.

An error is thrown if the load average can't be obtained. In some cases making it work would require Emacs being installed setuid or setgid so that it can read kernel information, and that usually isn't advisable.

Base64-encode the region between BEG and END. Return the length of the encoded text. Optional third argument NO-LINE-BREAK means do not break long lines into shorter lines.

Return the weakness of TABLE.

Clear hash table TABLE and return it.

Concatenate all the arguments and make the result a vector. The result is a vector whose elements are the elements of all the arguments. Each argument may be a list, vector or string.

Create and return a new hash table.

Arguments are specified as keyword/argument pairs. The following arguments are defined:

:test TEST -- TEST must be a symbol that specifies how to compare keys. Default is eql'. Predefined are the testseq', `eql', and `equal'. User-supplied test and hash functions can be specified via `define-hash-table-test'.

:size SIZE -- A hint as to how many elements will be put in the table. Default is 65.

:rehash-size REHASH-SIZE - Indicates how to expand the table when it fills up. If REHASH-SIZE is an integer, increase the size by that amount. If it is a float, it must be > 1.0, and the new size is the old size multiplied by that factor. Default is 1.5.

:rehash-threshold THRESHOLD -- THRESHOLD must a float > 0, and <= 1.0. Resize the hash table when the ratio (number of entries / table size) is greater than or equal to THRESHOLD. Default is 0.8.

:weakness WEAK -- WEAK must be one of nil, t, key',value', key-or-value', orkey-and-value'. If WEAK is not nil, the table returned is a weak table. Key/value pairs are removed from a weak hash table when there are no non-weak references pointing to their key, value, one of key or value, or both key and value, depending on WEAK. WEAK t is equivalent to `key-and-value'. Default value of WEAK is nil.

Return non-nil if KEY is `equal' to the cdr of an element of LIST. The value is actually the first element of LIST whose cdr equals KEY.

Return t if two Lisp objects have similar structure and contents. They must have the same data type. Conses are compared by comparing the cars and the cdrs. Vectors and strings are compared element by element. Numbers are compared by value, but integers cannot equal floats. (Use `=' if you want integers and floats to be able to be equal.) Symbols must match exactly.

Reverse LIST by modifying cdr pointers. Return the reversed list.

Reverse LIST, copying. Return the reversed list. See also the function `nreverse', which is used more often.

Take cdr N times on LIST, return the result.

Return the current rehash size of TABLE.

Store SYMBOL's PROPNAME property with value VALUE. It can be retrieved with `(get SYMBOL PROPNAME)'.

Base64-decode the region between BEG and END. Return the length of the decoded text. If the region can't be decoded, signal an error and don't modify the buffer.

Return the Nth element of LIST. N counts from zero. If LIST is not that long, nil is returned.

Return a unibyte string with the same individual chars as STRING. If STRING is unibyte, the result is STRING itself. Otherwise it is a newly created string, with no text properties, where each `eight-bit' character is converted to the corresponding byte. If STRING contains a non-ASCII, non-`eight-bit' character, an error is signaled.

Concatenate any number of lists by altering them. Only the last argument is not altered, and need not be a list.

Return the length of vector, list or string SEQUENCE. A byte-code function object is also allowed. If the string contains multibyte characters, this is not necessarily the number of bytes in the string; it is the number of characters. To get the number of bytes, use `string-bytes'.

Return non-nil if ELT is an element of LIST. Comparison done with `eq'. The value is actually the tail of LIST whose car is ELT.

Return non-nil if ELT is an element of LIST. Comparison done with `eql'. The value is actually the tail of LIST whose car is ELT.

Look up KEY in TABLE and return its associated value. If KEY is not found, return DFLT which defaults to nil.

Return the argument unchanged.

Define a new hash table test with name NAME, a symbol.

In hash tables created with NAME specified as test, use TEST to compare keys, and HASH for computing hash codes of keys.

TEST must be a function taking two arguments and returning non-nil if both arguments are the same. HASH must be a function taking one argument and return an integer that is the hash code of the argument. Hash code computation should use the whole value range of integers, including negative integers.

Return the size of TABLE. The size can be used as an argument to `make-hash-table' to create a hash table than can hold as many elements as TABLE holds without need for resizing.

If feature FEATURE is not loaded, load it from FILENAME. If FEATURE is not a member of the list `features', then the feature is not loaded; so load the file FILENAME. If FILENAME is omitted, the printname of FEATURE is used as the file name, and load' will try to load this name appended with the suffix.elc' or `.el', in that order. The name without appended suffix will not be used. See `get-load-suffixes' for the complete list of suffixes. If the optional third argument NOERROR is non-nil, then return nil if the file is not found instead of signaling an error. Normally the return value is FEATURE. The normal messages at start and end of loading FILENAME are suppressed.

Return the value of SYMBOL's PROPNAME property. This is the last value stored with `(put SYMBOL PROPNAME VALUE)'.

Extract a value from a property list, comparing with `equal'. PLIST is a property list, which is a list of the form (PROP1 VALUE1 PROP2 VALUE2...). This function returns the value corresponding to the given PROP, or nil if PROP is not one of the properties on the list.

Call FUNCTION for all entries in hash table TABLE. FUNCTION is called with two arguments, KEY and VALUE.

Return non-nil if KEY is `eq' to the cdr of an element of LIST. The value is actually the first element of LIST whose cdr is KEY.

Return the unibyte equivalent of STRING. Multibyte character codes are converted to unibyte according to nonascii-translation-table' or, if that is nil,nonascii-insert-offset'. If the lookup in the translation table fails, this function takes just the low 8 bits of each character.

Return t if first arg string is less than second in lexicographic order. Case is significant. Symbols are also allowed; their print names are used instead.

In WIDGET, set PROPERTY to VALUE. The value can later be retrieved with `widget-get'.

Return a new string whose contents are a substring of STRING. The returned string consists of the characters between index FROM (inclusive) and index TO (exclusive) of STRING. FROM and TO are zero-indexed: 0 means the first character of STRING. Negative values are counted from the end of STRING. If TO is nil, the substring runs to the end of STRING.

The STRING argument may also be a vector. In that case, the return value is a new vector that contains the elements between index FROM (inclusive) and index TO (exclusive) of that vector argument.

Return t if FEATURE is present in this Emacs.

Use this to conditionalize execution of lisp code based on the presence or absence of Emacs or environment extensions. Use `provide' to declare that a feature is available. This function looks at the value of the variable `features'. The optional argument SUBFEATURE can be used to check a specific subfeature of FEATURE.

Return the current rehash threshold of TABLE.

Change value in PLIST of PROP to VAL. PLIST is a property list, which is a list of the form (PROP1 VALUE1 PROP2 VALUE2 ...). PROP is a symbol and VAL is any object. If PROP is already a property on the list, its value is set to VAL, otherwise the new PROP VAL pair is added. The new plist is returned; use `(setq x (plist-put x prop val))' to be sure to use the new value. The PLIST is modified by side effects.

Associate KEY with VALUE in hash table TABLE. If KEY is already present in table, replace its current value with VALUE. In any case, return VALUE.

Return the test TABLE uses.

Apply FUNCTION to each element of SEQUENCE for side effects only. Unlike `mapcar', don't accumulate the results. Return SEQUENCE. SEQUENCE may be a list, a vector, a bool-vector, or a string.

Return non-nil if PLIST has the property PROP. PLIST is a property list, which is a list of the form (PROP1 VALUE1 PROP2 VALUE2 ...). PROP is a symbol. Unlike `plist-get', this allows you to distinguish between a missing property and a property with the value nil. The value is actually the tail of PLIST whose car is PROP.

Sort LIST, stably, comparing elements using PREDICATE. Returns the sorted list. LIST is modified by side effects. PREDICATE is called with two elements of LIST, and should return non-nil if the first element should sort before the second.

Base64-decode STRING and return the result.

The largest value that is representable in a Lisp integer.

The smallest value that is representable in a Lisp integer.

struct buffer_text in buffer.h. Contains many other low level fields we hopefully won't need.

struct buffer in buffer.h. Pretty large, so won't move it all over at once. The buffer locals are specified with DEFVARPERBUFFER, and their defaults with DEFVARBUFFERDEFAULTS Thet're all already defined as globals in buffer.clj. We need to put them (with default value at create) on this guy somehow.

struct in buffer.h. Has many other fields, its also a linked list above. Attempting to use as a value object

Return t if OBJECT is a nonnegative integer.

Return t if OBJECT is a marker (editor pointer).

Return VALUE with its bits shifted left by COUNT. If COUNT is negative, shifting is actually to the right. In this case, the sign bit is duplicated.

Return a symbol representing the type of OBJECT. The symbol returned names the object's basic type; for example, (type-of 1) returns `integer'.

Navgeet's additions, not sure they've been tested against real world scenarios.

Return the function at the end of OBJECT's function chain. If OBJECT is not a symbol, just return it. Otherwise, follow all function indirections to find the final function binding and return it. If the final symbol in the chain is unbound, signal a void-function error. Optional arg NOERROR non-nil means to return nil instead of signaling. Signal a cyclic-function-indirection error if there is a loop in the function chain of symbols.

Return SYMBOL's name, a string.

Make SYMBOL's value be void. Return SYMBOL.

Return the interactive form of CMD or nil if none. If CMD is not a command, the return value is nil. Value, if non-nil, is a list (interactive SPEC).

Return bitwise-or of all the arguments. Arguments may be integers, or markers converted to integers.

Return t if OBJECT is a sequence (list or array).

Return t if NUMBER is zero.

Return the variable at the end of OBJECT's variable chain. If OBJECT is a symbol, follow all variable indirections and return the final variable. If OBJECT is not a symbol, just return it. Signal a cyclic-variable-indirection error if there is a loop in the variable chain of symbols.

Return SYMBOL's value. Error if that is void.

Return t if OBJECT is a keyword. This means that it is a symbol with a print name beginning with `:' interned in the initial obarray.

Return NUMBER plus one. NUMBER may be a number or a marker. Markers are converted to integers.

Return t if OBJECT is a built-in function.

Return SYMBOL's property list.

Return t if OBJECT is a string.

Return t if OBJECT is an integer.

Return t if SYMBOL's function definition is not void.

Return remainder of X divided by Y. Both must be integers or markers.

Return sum of any number of arguments, which are numbers or markers.

Return VALUE with its bits shifted left by COUNT. If COUNT is negative, shifting is actually to the right. In this case, zeros are shifted in on the left.

Return t if the two args are the same Lisp object.

Return product of any number of arguments, which are numbers or markers.

Negate number or subtract numbers or markers and return the result. With one arg, negates it. With more than one arg, subtracts all but the first from the first.

Return t if OBJECT is a multibyte string.

Return bitwise-exclusive-or of all the arguments. Arguments may be integers, or markers converted to integers.

Return t if OBJECT is a floating point number.

Return t if OBJECT is a number or a marker.

Return the cdr of OBJECT if it is a cons cell, or else nil.

Return first argument divided by all the remaining arguments. The arguments must be numbers or markers.

Return the byteorder for the machine. Returns 66 (ASCII uppercase B) for big endian machines or 108 (ASCII lowercase l) for small endian machines.

Return name of subroutine SUBR. SUBR must be a built-in function.

Make VARIABLE have a separate value in the current buffer. Other buffers will continue to share a common default value. (The buffer-local value of VARIABLE starts out as the same value VARIABLE previously had. If VARIABLE was void, it remains void.) Return VARIABLE.

If the variable is already arranged to become local when set, this function causes a local value to exist for this buffer, just as setting the variable would do.

This function returns VARIABLE, and therefore (set (make-local-variable 'VARIABLE) VALUE-EXP) works.

See also `make-variable-buffer-local'.

Do not use `make-local-variable' to make a hook variable buffer-local. Instead, use `add-hook' and specify t for the LOCAL argument.

Return t if OBJECT is a number (floating point or integer).

Return bitwise-and of all the arguments. Arguments may be integers, or markers converted to integers.

Return t if OBJECT is a cons cell.

Return t if OBJECT is a list, that is, a cons cell or nil. Otherwise, return nil.

Return the element of ARRAY at index IDX. ARRAY may be a vector, a string, a char-table, a bool-vector, or a byte-code object. IDX starts at 0.

Return t if OBJECT is a nonnegative integer.

We probably don't want to do this due to interned strings.

Store into the element of ARRAY at index IDX the value NEWELT. Return NEWELT. ARRAY may be a vector, a string, a char-table or a bool-vector. IDX starts at 0.

Return t if OBJECT is an array (string or vector).

Return t if OBJECT is a vector.

Make SYMBOL's function definition be void. Return SYMBOL.

Return the bitwise complement of NUMBER. NUMBER must be an integer.

Set the cdr of CELL to be NEWCDR. Returns NEWCDR.

Set SYMBOL's value to NEWVAL, and return NEWVAL.

Return t if first arg is less than second arg. Both must be numbers or markers.

Return the car of OBJECT if it is a cons cell, or else nil.

Set SYMBOL's function definition to DEFINITION, and return DEFINITION.

Return the cdr of LIST. If arg is nil, return nil. Error if arg is not nil and not a cons cell. See also `cdr-safe'.

See Info node `(elisp)Cons Cells' for a discussion of related basic Lisp concepts such as cdr, car, cons cell and list.

Return t if two args, both numbers or markers, are equal.

Make VARIABLE become buffer-local whenever it is set. At any time, the value for the current buffer is in effect, unless the variable has never been set in this buffer, in which case the default value is in effect. Note that binding the variable with `let', or setting it while a `let'-style binding made in this buffer is in effect, does not make the variable buffer-local. Return VARIABLE.

In most cases it is better to use `make-local-variable', which makes a variable local in just one buffer.

The function default-value' gets the default value andset-default' sets it.

Return t if OBJECT is a character or a string.

Return t if OBJECT is a char-table or vector.

Return t if OBJECT is an editor buffer.

Return t if first arg is greater than second arg. Both must be numbers or markers.

Return largest of all the arguments (which must be numbers or markers). The value is always a number; markers are converted to numbers.

Non-nil if VARIABLE will be local in buffer BUFFER when set there. More precisely, this means that setting the variable (with set' orsetq'), while it does not have a `let'-style binding that was made in BUFFER, will produce a buffer local binding. See Info node `(elisp)Creating Buffer-Local'. BUFFER defaults to the current buffer.

Return t if SYMBOL has a non-void default value. This is the value that is seen in buffers that do not have their own values for this variable.

Return t if OBJECT is not a list. Lists include nil.

Return t if first arg is greater than or equal to second arg. Both must be numbers or markers.

Return t if SYMBOL's value is not void.

Return SYMBOL's default value. This is the value that is seen in buffers that do not have their own values for this variable. The default value is meaningful for variables with local bindings in certain buffers.

Set the car of CELL to be NEWCAR. Returns NEWCAR.

Return t if OBJECT is a symbol.

Return t if first arg is less than or equal to second arg. Both must be numbers or markers.

Non-nil if VARIABLE has a local binding in buffer BUFFER. BUFFER defaults to the current buffer.

Return t if OBJECT is a byte-compiled function object.

Set SYMBOL's function definition to DEFINITION, and return DEFINITION. Associates the function with the current load file, if any. The optional third argument DOCSTRING specifies the documentation string for SYMBOL; if it is omitted or nil, SYMBOL uses the documentation string determined by DEFINITION.

Set SYMBOL's property list to NEWPLIST, and return NEWPLIST.

Set SYMBOL's default value to VALUE. SYMBOL and VALUE are evaluated. The default value is seen in buffers that do not have their own values for this variable.

Return SYMBOL's function definition. Error if that is void.

Make VARIABLE no longer have a separate value in the current buffer. From now on the default value will apply in this buffer. Return VARIABLE.

Return the car of LIST. If arg is nil, return nil. Error if arg is not nil and not a cons cell. See also `car-safe'.

See Info node `(elisp)Cons Cells' for a discussion of related basic Lisp concepts such as car, cdr, cons cell and list.

Return t if OBJECT is a bool-vector.

Return minimum and maximum number of args allowed for SUBR. SUBR must be a built-in function. The returned value is a pair (MIN . MAX). MIN is the minimum number of args. MAX is the maximum number or the symbol `many', for a function with &rest' args, orunevalled' for a special form.

Return X modulo Y. The result falls between zero (inclusive) and Y (exclusive). Both X and Y must be numbers or markers.

Return NUMBER minus one. NUMBER may be a number or a marker. Markers are converted to integers.

Return t if OBJECT is not a cons cell. This includes nil.

Return t if OBJECT is nil.

Return t if OBJECT is a char-table.

This function is obsolete since 22.2; explicitly check for a frame-parameter instead.

Enable VARIABLE to have frame-local bindings. This does not create any frame-local bindings for VARIABLE, it just makes them possible.

A frame-local binding is actually a frame parameter value. If a frame F has a value for the frame parameter named VARIABLE, that also acts as a frame-local binding for VARIABLE in F-- provided this function has been called to enable VARIABLE to have frame-local bindings at all.

The only way to create a frame-local binding for VARIABLE in a frame is to set the VARIABLE frame parameter of that frame. See `modify-frame-parameters' for how to set frame parameters.

Note that since Emacs 23.1, variables cannot be both buffer-local and frame-local any more (buffer-local bindings used to take precedence over frame-local bindings).

Return the decimal representation of NUMBER as a string. Uses a minus sign if negative. NUMBER may be an integer or a floating point number.

Return t if OBJECT is an integer or a marker (editor pointer).

Return smallest of all the arguments (which must be numbers or markers). The value is always a number; markers are converted to numbers.

Parse STRING as a decimal number and return the number. This parses both integers and floating point numbers. It ignores leading spaces and tabs, and all trailing chars.

If BASE, interpret STRING as a number in that base. If BASE isn't present, base 10 is used. BASE must be between 2 and 16 (inclusive). If the base used is not 10, STRING is always parsed as integer.

Return a value indicating where VARIABLE's current binding comes from. If the current binding is buffer-local, the value is the current buffer. If the current binding is frame-local, the value is the selected frame. If the current binding is global (the default), the value is nil.

Directory containing the DOC file that comes with GNU Emacs. This is usually the same as `data-directory'.

Directory of score files for games which come with GNU Emacs. If this variable is nil, then Emacs is unable to use a shared directory.

*List of suffixes to try to find executable file names. Each element is a string.

*File name to load inferior shells from. Initialized from the SHELL environment variable, or to a system-dependent default if SHELL is not set.

You can customize this variable.

*List of directories to search programs to run in subprocesses. Each element is a string (directory name) or nil (try default directory).

You can customize this variable.

List of environment variables inherited from the parent process. Each element should be a string of the form ENVVARNAME=VALUE. The elements must normally be decoded (using `locale-coding-system') for use.

Directory of machine-independent files that come with GNU Emacs. These are files intended for Emacs to use while it runs.

List of overridden environment variables for subprocesses to inherit. Each element should be a string of the form ENVVARNAME=VALUE.

Entries in this list take precedence to those in the frame-local environments. Therefore, let-binding `process-environment' is an easy way to temporarily change the value of an environment variable, irrespective of where it comes from. To use `process-environment' to remove an environment variable, include only its name in the list, without "=VALUE".

This variable is set to nil when Emacs starts.

If multiple entries define the same variable, the first one always takes precedence.

Non-ASCII characters are encoded according to the initial value of `locale-coding-system', i.e. the elements must normally be decoded for use.

See setenv' andgetenv'.

Directory for executables for Emacs to invoke. More generally, this includes any architecture-dependent files that are built and installed from the Emacs distribution.

For internal use by the build procedure only. This is the name of the directory in which the build procedure installed Emacs's info files; the default value for `Info-default-directory-list' includes this.

Get the value of environment variable VARIABLE. VARIABLE should be a string. Value is nil if VARIABLE is undefined in the environment. Otherwise, value is a string.

This function searches `process-environment' for VARIABLE.

If optional parameter ENV is a list, then search this list instead of `process-environment', and return t when encountering a negative entry (an entry for a variable with no value).

Send text from START to END to a synchronous process running PROGRAM. The remaining arguments are optional. Delete the text if fourth arg DELETE is non-nil.

Insert output in BUFFER before point; t means current buffer; nil for BUFFER means discard it; 0 means discard and don't wait; and `(:file FILE)', where FILE is a file name string, means that it should be written to that file (if the file already exists it is overwritten). BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case, REAL-BUFFER says what to do with standard output, as above, while STDERR-FILE says what to do with standard error in the child. STDERR-FILE may be nil (discard standard error output), t (mix it with ordinary output), or a file name string.

Sixth arg DISPLAY non-nil means redisplay buffer as output is inserted. Remaining args are passed to PROGRAM at startup as command args.

If BUFFER is 0, `call-process-region' returns immediately with value nil. Otherwise it waits for PROGRAM to terminate and returns a numeric exit status or a signal description string. If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.

Call PROGRAM synchronously in separate process. The remaining arguments are optional. The program's input comes from file INFILE (nil means `/dev/null'). Insert output in BUFFER before point; t means current buffer; nil for BUFFER means discard it; 0 means discard and don't wait; and `(:file FILE)', where FILE is a file name string, means that it should be written to that file (if the file already exists it is overwritten). BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case, REAL-BUFFER says what to do with standard output, as above, while STDERR-FILE says what to do with standard error in the child. STDERR-FILE may be nil (discard standard error output), t (mix it with ordinary output), or a file name string.

Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted. Remaining arguments are strings passed as command arguments to PROGRAM.

If executable PROGRAM can't be found as an executable, `call-process' signals a Lisp error. `call-process' reports errors in execution of the program only through its return and output.

If BUFFER is 0, `call-process' returns immediately with value nil. Otherwise it waits for PROGRAM to terminate and returns a numeric exit status or a signal description string. If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.

Function used internally in byte-compiled code. The first argument, BYTESTR, is a string of byte code; the second, VECTOR, a vector of constants; the third, MAXDEPTH, the maximum stack depth used in this function. If the third argument is incorrect, Emacs may crash.

Vector of code conversion maps.

Alist of fontname patterns vs corresponding CCL program. Each element looks like (REGEXP . CCL-CODE), where CCL-CODE is a compiled CCL program. When a font whose name matches REGEXP is used for displaying a character, CCL-CODE is executed to calculate the code point in the font from the charset number and position code(s) of the character which are set in CCL registers R0, R1, and R2 before the execution. The code point in the font is set in CCL registers R1 and R2 when the execution terminated. If the font is single-byte font, the register R2 is not used.

Vector containing all translation hash tables ever defined. Comprises pairs (SYMBOL . TABLE) where SYMBOL and TABLE were set up by calls to `define-translation-hash-table'. The vector is indexed by the table id used by CCL.

Register CCL program CCL-PROG as NAME in `ccl-program-table'. CCL-PROG should be a compiled CCL program (vector), or nil. If it is nil, just reserve NAME as a CCL program name. Return index number of the registered CCL program.

Execute CCL-PROGRAM with registers initialized by REGISTERS.

CCL-PROGRAM is a CCL program name (symbol) or compiled code generated by `ccl-compile' (for backward compatibility. In the latter case, the execution overhead is bigger than in the former). No I/O commands should appear in CCL-PROGRAM.

REGISTERS is a vector of [R0 R1 ... R7] where RN is an initial value for the Nth register.

As side effect, each element of REGISTERS holds the value of the corresponding register after the execution.

See the documentation of `define-ccl-program' for a definition of CCL programs.

Return t if OBJECT is a CCL program name or a compiled CCL program code. See the documentation of `define-ccl-program' for the detail of CCL program.

Register SYMBOL as code conversion map MAP. Return index number of the registered map.

Execute CCL-PROGRAM with initial STATUS on STRING.

CCL-PROGRAM is a symbol registered by `register-ccl-program', or a compiled code generated by `ccl-compile' (for backward compatibility, in this case, the execution is slower).

Read buffer is set to STRING, and write buffer is allocated automatically.

STATUS is a vector of [R0 R1 ... R7 IC], where R0..R7 are initial values of corresponding registers, IC is the instruction counter specifying from where to start the program. If R0..R7 are nil, they are initialized to 0. If IC is nil, it is initialized to head of the CCL program.

If optional 4th arg CONTINUE is non-nil, keep IC on read operation when read buffer is exhausted, else, IC is always set to the end of CCL-PROGRAM on exit.

It returns the contents of write buffer as a string, and as side effect, STATUS is updated. If the optional 5th arg UNIBYTE-P is non-nil, the returned string is a unibyte string. By default it is a multibyte string.

See the documentation of `define-ccl-program' for the detail of CCL program.

List of functions to call before each text change. Two arguments are passed to each function: the positions of the beginning and end of the range of old text to be changed. (For an insertion, the beginning and end are at the same place.) No information is given about the length of the text after the change.

Buffer changes made while executing the `before-change-functions' don't call any before-change or after-change functions. That's because `inhibit-modification-hooks' is temporarily set non-nil.

If an unhandled error happens in running these functions, the variable's value remains nil. That prevents the error from happening repeatedly and making Emacs nonfunctional.

Default value of `ctl-arrow' for buffers that do not override it. This is the same as (default-value 'ctl-arrow).

Hook to be run (by `run-hooks', which see) when a buffer is killed. The buffer being killed will be current while the hook is running. See `kill-buffer'.

Default value of `line-spacing' for buffers that don't override it. This is the same as (default-value 'line-spacing).

Non-nil if Transient Mark mode is enabled. See the command `transient-mark-mode' for a description of this minor mode.

Non-nil also enables highlighting of the region whenever the mark is active. The variable `highlight-nonselected-windows' controls whether to highlight all windows or just the selected window.

Lisp programs may give this variable certain special values:

• A value of `lambda' enables Transient Mark mode temporarily. It is disabled again after any subsequent action that would normally deactivate the mark (e.g. buffer modification).

• A value of (only . OLDVAL) enables Transient Mark mode temporarily. After any subsequent point motion command that is not shift-translated, or any other action that would normally deactivate the mark (e.g. buffer modification), the value of `transient-mark-mode' is set to OLDVAL.

  You can customize this variable.

A number incremented each time this buffer is displayed in a window. The function `set-window-buffer' increments it.

*Position of this buffer's vertical scroll bar. The value takes effect whenever you tell a window to display this buffer; for instance, with set-window-buffer' or whendisplay-buffer' displays it.

A value of left' orright' means put the vertical scroll bar at that side of the window; a value of nil means don't show any vertical scroll bars. A value of t (the default) means do whatever the window's frame specifies.

Default value of `indicate-empty-lines' for buffers that don't override it. This is the same as (default-value 'indicate-empty-lines).

Non-nil means that Emacs should use caches to handle long lines more quickly.

Normally, the line-motion functions work by scanning the buffer for newlines. Columnar operations (like `move-to-column' and `compute-motion') also work by scanning the buffer, summing character widths as they go. This works well for ordinary text, but if the buffer's lines are very long (say, more than 500 characters), these motion functions will take longer to execute. Emacs may also take longer to update the display.

If `cache-long-line-scans' is non-nil, these motion functions cache the results of their scans, and consult the cache to avoid rescanning regions of the buffer until the text is modified. The caches are most beneficial when they prevent the most searching---that is, when the buffer contains long lines and large regions of characters with the same, fixed screen width.

When `cache-long-line-scans' is non-nil, processing short lines will become slightly slower (because of the overhead of consulting the cache), and the caches will use memory roughly proportional to the number of newlines and characters whose screen width varies.

The caches require no explicit maintenance; their accuracy is maintained internally by the Emacs primitives. Enabling or disabling the cache should not affect the behavior of any of the motion functions; it should only affect their performance.

*Default value of `enable-multibyte-characters' for buffers not overriding it. This is the same as (default-value 'enable-multibyte-characters).

Default value of `fringes-outside-margins' for buffers that don't override it. This is the same as (default-value 'fringes-outside-margins).

Pretty name of current buffer's major mode. Usually a string, but can use any of the constructs for `mode-line-format', which see. Format with `format-mode-line' to produce a string value.

List of undo entries in current buffer. Recent changes come first; older changes follow newer.

An entry (BEG . END) represents an insertion which begins at position BEG and ends at position END.

An entry (TEXT . POSITION) represents the deletion of the string TEXT from (abs POSITION). If POSITION is positive, point was at the front of the text being deleted; if negative, point was at the end.

An entry (t HIGH . LOW) indicates that the buffer previously had "unmodified" status. HIGH and LOW are the high and low 16-bit portions of the visited file's modification time, as of that time. If the modification time of the most recent save is different, this entry is obsolete.

An entry (nil PROPERTY VALUE BEG . END) indicates that a text property was modified between BEG and END. PROPERTY is the property name, and VALUE is the old value.

An entry (apply FUN-NAME . ARGS) means undo the change with (apply FUN-NAME ARGS).

An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo in the active region. BEG and END is the range affected by this entry and DELTA is the number of bytes added or deleted in that range by this change.

An entry (MARKER . DISTANCE) indicates that the marker MARKER was adjusted in position by the offset DISTANCE (an integer).

An entry of the form POSITION indicates that point was at the buffer location given by the integer. Undoing an entry of this form places point at POSITION.

Entries with value `nil' mark undo boundaries. The undo command treats the changes between two undo boundaries as a single step to be undone.

If the value of the variable is t, undo information is not recorded.

Abbreviated truename of file visited in current buffer, or nil if none. The truename of a file is calculated by `file-truename' and then abbreviated with `abbreviate-file-name'.

*Width of this buffer's right fringe (in pixels). A value of 0 means no right fringe is shown in this buffer's window. A value of nil means to use the right fringe width from the window's frame.

Default value of `scroll-bar-width' for buffers that don't override it. This is the same as (default-value 'scroll-bar-width).

List of functions called with no args to query before killing a buffer. The buffer being killed will be current while the functions are running. If any of them returns nil, the buffer is not killed.

Non-nil if self-insertion should replace existing text. The value should be one of `overwrite-mode-textual', `overwrite-mode-binary', or nil. If it is `overwrite-mode-textual', self-insertion still inserts at the end of a line, and inserts when point is before a tab, until the tab is filled in. If `overwrite-mode-binary', self-insertion replaces newlines and tabs too.

Default value of `right-fringe-width' for buffers that don't override it. This is the same as (default-value 'right-fringe-width).

*Non-nil means to use word-wrapping for continuation lines. When word-wrapping is on, continuation lines are wrapped at the space or tab character nearest to the right window edge. If nil, continuation lines are wrapped at the right screen edge.

This variable has no effect if long lines are truncated (see truncate-lines' andtruncate-partial-width-windows'). If you use word-wrapping, you might want to reduce the value of `truncate-partial-width-windows', since wrapping can make text readable in narrower windows.

You can customize this variable.

*Format in which to write auto-save files. Should be a list of symbols naming formats that are defined in `format-alist'. If it is t, which is the default, auto-save files are written in the same format as a regular save would use.

*Value of `major-mode' for new buffers.

Default value of `left-margin' for buffers that do not override it. This is the same as (default-value 'left-margin).

Template for displaying mode line for current buffer. Each buffer has its own value of this variable. Value may be nil, a string, a symbol or a list or cons cell. A value of nil means don't display a mode line. For a symbol, its value is used (but it is ignored if t or nil). A string appearing directly as the value of a symbol is processed verbatim in that the %-constructs below are not recognized. Note that unless the symbol is marked as a `risky-local-variable', all properties in any strings, as well as all :eval and :propertize forms in the value of that symbol will be ignored. For a list of the form `(:eval FORM)', FORM is evaluated and the result is used as a mode line element. Be careful--FORM should not load any files, because that can cause an infinite recursion. For a list of the form `(:propertize ELT PROPS...)', ELT is displayed with the specified properties PROPS applied. For a list whose car is a symbol, the symbol's value is taken, and if that is non-nil, the cadr of the list is processed recursively. Otherwise, the caddr of the list (if there is one) is processed. For a list whose car is a string or list, each element is processed recursively and the results are effectively concatenated. For a list whose car is an integer, the cdr of the list is processed and padded (if the number is positive) or truncated (if negative) to the width specified by that number. A string is printed verbatim in the mode line except for %-constructs: (%-constructs are allowed when the string is the entire mode-line-format or when it is found in a cons-cell or a list) %b -- print buffer name. %f -- print visited file name. %F -- print frame name. %* -- print %, * or hyphen. %+ -- print *, % or hyphen. %& is like %*, but ignore read-only-ness. % means buffer is read-only and * means it is modified. For a modified read-only buffer, %* gives % and %+ gives *. %s -- print process status. %l -- print the current line number. %c -- print the current column number (this makes editing slower). To make the column number update correctly in all cases, `column-number-mode' must be non-nil. %i -- print the size of the buffer. %I -- like %i, but use k, M, G, etc., to abbreviate. %p -- print percent of buffer above top of window, or Top, Bot or All. %P -- print percent of buffer above bottom of window, perhaps plus Top, or print Bottom or All. %n -- print Narrow if appropriate. %t -- visited file is text or binary (if OS supports this distinction). %z -- print mnemonics of keyboard, terminal, and buffer coding systems. %Z -- like %z, but including the end-of-line format. %e -- print error message about full memory. %@ -- print @ or hyphen. @ means that default-directory is on a remote machine. %[ -- print one [ for each recursive editing level. %] similar. %% -- print %. %- -- print infinitely many dashes. Decimal digits after the % specify field width to which to pad.

You can customize this variable.

Normal hook run before changing the major mode of a buffer. The function `kill-all-local-variables' runs this before doing anything else.

How far to scroll windows downward. If you move point off the top, the window scrolls automatically. This variable controls how far it scrolls. The value nil, the default, means scroll to center point. A fraction means scroll to put point that fraction of the window's height from the top of the window. When the value is 0.0, point goes at the top line, which in the simple case that you moved off with C-b means scrolling just one line. 1.0 means point goes at the bottom, so that in that simple case, the window scrolls by a full window height. Meaningful values are between 0.0 and 1.0, inclusive.

You can customize this variable.

*Mapping from logical to physical fringe cursor bitmaps. The value is an alist where each element (CURSOR . BITMAP) specifies the fringe bitmaps used to display a specific logical cursor type in the fringe.

CURSOR specifies the logical cursor type which is one of the following symbols: box' ,hollow', bar',hbar', or `hollow-small'. The last one is used to show a hollow cursor on narrow lines display lines where the normal hollow cursor will not fit.

BITMAP is the corresponding fringe bitmap shown for the logical cursor type.

Function called (if non-nil) to perform auto-fill. It is called after self-inserting any character specified in the `auto-fill-chars' table. NOTE: This variable is not a hook; its value may not be a list of functions.

Value of point before the last series of scroll operations, or nil.

*Width of right marginal area for display of a buffer. A value of nil means no marginal area.

Default value of `cursor-type' for buffers that don't override it. This is the same as (default-value 'cursor-type).

*Width of this buffer's scroll bars in pixels. A value of nil means to use the scroll bar width from the window's frame.

Display table that controls display of the contents of current buffer.

If this variable is nil, the value of `standard-display-table' is used. Each window can have its own, overriding display table, see set-window-display-table' andwindow-display-table'.

The display table is a char-table created with `make-display-table'. A char-table is an array indexed by character codes. Normal array primitives aref' andaset' can be used to access elements of a char-table.

Each of the char-table elements control how to display the corresponding text character: the element at index C in the table says how to display the character whose code is C. Each element should be a vector of characters or nil. The value nil means display the character in the default fashion; otherwise, the characters from the vector are delivered to the screen instead of the original character.

For example, (aset buffer-display-table ?X [?Y]) tells Emacs to display a capital Y instead of each X character.

In addition, a char-table has six extra slots to control the display of:

the end of a truncated screen line (extra-slot 0, a single character);
the end of a continued line (extra-slot 1, a single character);
the escape character used to display character codes in octal
  (extra-slot 2, a single character);
the character used as an arrow for control characters (extra-slot 3,
  a single character);
the decoration indicating the presence of invisible lines (extra-slot 4,
  a vector of characters);
the character used to draw the border between side-by-side windows
  (extra-slot 5, a single character).

See also the functions display-table-slot' andset-display-table-slot'.

*Visually indicate buffer boundaries and scrolling. If non-nil, the first and last line of the buffer are marked in the fringe of a window on window-systems with angle bitmaps, or if the window can be scrolled, the top and bottom line of the window are marked with up and down arrow bitmaps.

If value is a symbol left' orright', both angle and arrow bitmaps are displayed in the left or right fringe, resp. Any other value that doesn't look like an alist means display the angle bitmaps in the left fringe but no arrows.

You can exercise more precise control by using an alist as the value. Each alist element (INDICATOR . POSITION) specifies where to show one of the indicators. INDICATOR is one of `top', bottom',up', `down', or t, which specifies the default position, and POSITION is one of left',right', or nil, meaning do not show this indicator.

For example, ((top . left) (t . right)) places the top angle bitmap in left fringe, the bottom angle bitmap in right fringe, and both arrow bitmaps in right fringe. To show just the angle bitmaps in the left fringe, but no arrow bitmaps, use ((top . left) (bottom . left)).

You can customize this variable.

Default value of `left-margin-width' for buffers that don't override it. This is the same as (default-value 'left-margin-width).

Name of default directory of current buffer. Should end with slash. To interactively change the default directory, use command `cd'.

Non-nil if this buffer is read-only.

Symbol for current buffer's major mode. The default value (normally `fundamental-mode') affects new buffers. A value of nil means to use the current buffer's major mode, provided it is not marked as "special".

When a mode is used by default, `find-file' switches to it before it reads the contents into the buffer and before it finishes setting up the buffer. Thus, the mode and its hooks should not expect certain variables such as buffer-read-only' andbuffer-file-coding-system' to be set up.

You can customize this variable.

*Column beyond which automatic line-wrapping should happen. Interactively, you can set the buffer local value using C-x f.

You can customize this variable.

*Distance between tab stops (for display of tab characters), in columns. This should be an integer greater than zero.

You can customize this variable.

Default value of `cursor-in-non-selected-windows'. This is the same as (default-value 'cursor-in-non-selected-windows).

Default value of `case-fold-search' for buffers that don't override it. This is the same as (default-value 'case-fold-search).

Length of current buffer when last read in, saved or auto-saved. 0 initially. -1 means auto-saving turned off until next real save.

If you set this to -2, that means don't turn off auto-saving in this buffer if its text size shrinks. If you use `buffer-swap-text' on a buffer, you probably should set this to -2 in that buffer.

*Width of this buffer's left fringe (in pixels). A value of 0 means no left fringe is shown in this buffer's window. A value of nil means to use the left fringe width from the window's frame.

Coding system to be used for encoding the buffer contents on saving. This variable applies to saving the buffer, and also to `write-region' and other functions that use `write-region'. It does not apply to sending output to subprocesses, however.

If this is nil, the buffer is saved without any code conversion unless some coding system is specified in `file-coding-system-alist' for the buffer file.

If the text to be saved cannot be encoded as specified by this variable, an alternative encoding is selected by `select-safe-coding-system', which see.

The variable `coding-system-for-write', if non-nil, overrides this variable.

This variable is never applied to a way of decoding a file while reading it.

*Column for the default `indent-line-function' to indent to. Linefeed indents to this column in Fundamental mode.

You can customize this variable.

Default value of `scroll-up-aggressively'. This value applies in buffers that don't have their own local values. This is the same as (default-value 'scroll-up-aggressively).

Default value of `abbrev-mode' for buffers that do not override it. This is the same as (default-value 'abbrev-mode).

Non-nil if this buffer's file has been backed up. Backing up is done before the first time the file is saved.

List of functions to call after each text change. Three arguments are passed to each function: the positions of the beginning and end of the range of changed text, and the length in bytes of the pre-change text replaced by that range. (For an insertion, the pre-change length is zero; for a deletion, that length is the number of bytes deleted, and the post-change beginning and end are at the same place.)

Buffer changes made while executing the `after-change-functions' don't call any before-change or after-change functions. That's because `inhibit-modification-hooks' is temporarily set non-nil.

If an unhandled error happens in running these functions, the variable's value remains nil. That prevents the error from happening repeatedly and making Emacs nonfunctional.

Default value of `fringe-indicator-alist' for buffers that don't override it. This is the same as (default-value 'fringe-indicator-alist').

Default value of `header-line-format' for buffers that don't override it. This is the same as (default-value 'header-line-format).

List of formats to use when saving this buffer. Formats are defined by `format-alist'. This variable is set when a file is visited.

Analogous to `mode-line-format', but controls the header line. The header line appears, optionally, at the top of a window; the mode line appears at the bottom.

Name of file for auto-saving current buffer. If it is nil, that means don't auto-save this buffer.

Default value of `truncate-lines' for buffers that do not override it. This is the same as (default-value 'truncate-lines).

Default value of `vertical-scroll-bar' for buffers that don't override it. This is the same as (default-value 'vertical-scroll-bar).

Hook run when the buffer list changes. Functions running this hook are `get-buffer-create', make-indirect-buffer',rename-buffer', `kill-buffer', and `bury-buffer-internal'.

*Non-nil means do not display continuation lines. Instead, give each line of text just one screen line.

Note that this is overridden by the variable `truncate-partial-width-windows' if that variable is non-nil and this buffer is not full-frame width.

Minibuffers set this variable to nil.

You can customize this variable.

Time stamp updated each time this buffer is displayed in a window. The function `set-window-buffer' updates this variable to the value obtained by calling `current-time'. If the buffer has never been shown in a window, the value is nil.

*Visually indicate empty lines after the buffer end. If non-nil, a bitmap is displayed in the left fringe of a window on window-systems.

You can customize this variable.

*Non-nil means display control chars with uparrow. A value of nil means use backslash and octal digits. This variable does not apply to characters whose display is specified in the current display table (if there is one).

You can customize this variable.

*Non-nil if searches and matches should ignore case.

You can customize this variable.

Default value of `indicate-buffer-boundaries' for buffers that don't override it. This is the same as (default-value 'indicate-buffer-boundaries).

Additional space to put between lines when displaying a buffer. The space is measured in pixels, and put below lines on graphic displays, see `display-graphic-p'. If value is a floating point number, it specifies the spacing relative to the default frame line height. A value of nil means add no extra space.

You can customize this variable.

Non-nil means the buffer contents are regarded as multi-byte characters. Otherwise they are regarded as unibyte. This affects the display, file I/O and the behavior of various editing commands.

This variable is buffer-local but you cannot set it directly; use the function `set-buffer-multibyte' to change a buffer's representation. See also Info node `(elisp)Text Representations'.

*Width of left marginal area for display of a buffer. A value of nil means no marginal area.

A list of functions to call before changing a buffer which is unmodified. The functions are run using the `run-hooks' function.

*Non-nil means to display fringes outside display margins. A value of nil means to display fringes between margins and buffer text.

Non-nil if Abbrev mode is enabled. Use the command `abbrev-mode' to change this variable.

How far to scroll windows upward. If you move point off the bottom, the window scrolls automatically. This variable controls how far it scrolls. The value nil, the default, means scroll to center point. A fraction means scroll to put point that fraction of the window's height from the bottom of the window. When the value is 0.0, point goes at the bottom line, which in the simple case that you moved off with C-f means scrolling just one line. 1.0 means point goes at the top, so that in that simple case, the window scrolls by a full window height. Meaningful values are between 0.0 and 1.0, inclusive.

You can customize this variable.

Default value of `fill-column' for buffers that do not override it. This is the same as (default-value 'fill-column).

*Mapping from logical to physical fringe indicator bitmaps. The value is an alist where each element (INDICATOR . BITMAPS) specifies the fringe bitmaps used to display a specific logical fringe indicator.

INDICATOR specifies the logical indicator type which is one of the following symbols: truncation' ,continuation', `overlay-arrow', top',bottom', top-bottom',up', down', empty-line', orunknown'.

BITMAPS is a list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies the actual bitmap shown in the left or right fringe for the logical indicator. LEFT and RIGHT are the bitmaps shown in the left and/or right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps are used only for the bottom' andtop-bottom' indicators when the last (only) line has no final newline. BITMAPS may also be a single symbol which is used in both left and right fringes.

Default value of `scroll-down-aggressively'. This value applies in buffers that don't have their own local values. This is the same as (default-value 'scroll-down-aggressively).

Default value of `tab-width' for buffers that do not override it. This is the same as (default-value 'tab-width).

Default value of `left-fringe-width' for buffers that don't override it. This is the same as (default-value 'left-fringe-width).

Name of file visited in current buffer, or nil if not visiting a file.

Default value of `buffer-file-coding-system' for buffers not overriding it. This is the same as (default-value 'buffer-file-coding-system).

*Non-nil means show a cursor in non-selected windows. If nil, only shows a cursor in the selected window. If t, displays a cursor related to the usual cursor type (a solid box becomes hollow, a bar becomes a narrower bar). You can also specify the cursor type as in the `cursor-type' variable. Use Custom to set this variable and update the display."

You can customize this variable.

Non-nil enables selective display. An integer N as value means display only lines that start with less than N columns of space. A value of t means that the character ^M makes itself and all the rest of the line invisible; also, when saving the buffer in a file, save the ^M as a newline.

Non-nil means display ... on previous line when a line is invisible.

You can customize this variable.

Cursor to use when this buffer is in the selected window. Values are interpreted as follows:

t         use the cursor specified for the frame
nil       don't display a cursor
box       display a filled box cursor
hollow    display a hollow box cursor
bar       display a vertical bar cursor with default width
(bar . WIDTH)     display a vertical bar cursor with width WIDTH
hbar          display a horizontal bar cursor with default height
(hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
ANYTHING ELSE     display a hollow box cursor

When the buffer is displayed in a non-selected window, the cursor's appearance is instead controlled by the variable `cursor-in-non-selected-windows'.

Non-nil means the mark and region are currently active in this buffer.

Default value of `fringe-cursor-alist' for buffers that don't override it. This is the same as (default-value 'fringe-cursor-alist').

*Non-nil means disregard read-only status of buffers or characters. If the value is t, disregard buffer-read-only' and allread-only' text properties. If the value is a list, disregard `buffer-read-only' and disregard a `read-only' text property if the property value is a member of the list.

Invisibility spec of this buffer. The default is t, which means that text is invisible if it has a non-nil `invisible' property. If the value is a list, a text character is invisible if its `invisible' property is an element in that list (or is a list with members in common). If an element is a cons cell of the form (PROP . ELLIPSIS), then characters with property value PROP are invisible, and they have an ellipsis as well if ELLIPSIS is non-nil.

Non-nil means reorder bidirectional text for display in the visual order.

Default value of `right-margin-width' for buffers that don't override it. This is the same as (default-value 'right-margin-width).

Local (mode-specific) abbrev table of current buffer.

Default value of `mode-line-format' for buffers that don't override it. This is the same as (default-value 'mode-line-format).

*If non-nil, forces directionality of text paragraphs in the buffer.

If this is nil (the default), the direction of each paragraph is determined by the first strong directional character of its text. The values of right-to-left' andleft-to-right' override that. Any other value is treated as nil.

This variable has no effect unless the buffer's value of `bidi-display-reordering' is non-nil.

You can customize this variable.

Signal a `buffer-read-only' error if the current buffer is read-only.

Return t if OBJECT is an overlay.

Create a new overlay with range BEG to END in BUFFER. If omitted, BUFFER defaults to the current buffer. BEG and END may be integers or markers. The fourth arg FRONT-ADVANCE, if non-nil, makes the marker for the front of the overlay advance when text is inserted there (which means the text is not included in the overlay). The fifth arg REAR-ADVANCE, if non-nil, makes the marker for the rear of the overlay advance when text is inserted there (which means the text is included in the overlay).

Return non-nil if OBJECT is a buffer which has not been killed. Value is nil if OBJECT is not a buffer or if it has been killed.

Like `set-buffer-modified-p', with a difference concerning redisplay. It is not ensured that mode lines will be updated to show the modified state of the current buffer. Use with care.

Return t if BUFFER was modified since its file was last read or saved. No argument or nil as argument means use current buffer as BUFFER.

Return BUFFER's character-change tick counter. Each buffer has a character-change tick counter, which is set to the value of the buffer's tick counter (see `buffer-modified-tick'), each time text in that buffer is inserted or deleted. By comparing the values returned by two individual calls of `buffer-chars-modified-tick', you can tell whether a character change occurred in that buffer in between these calls. No argument or nil as argument means use current buffer as BUFFER.

Return a string that is the name of no existing buffer based on NAME. If there is no live buffer named NAME, then return NAME. Otherwise modify name by appending `<NUMBER>', incrementing NUMBER (starting at 2) until an unused name is found, and then return that name. Optional second argument IGNORE specifies a name that is okay to use (if it is in the sequence to be tried) even if a buffer with that name exists.

Set the multibyte flag of the current buffer to FLAG. If FLAG is t, this makes the buffer a multibyte buffer. If FLAG is nil, this makes the buffer a single-byte buffer. In these cases, the buffer contents remain unchanged as a sequence of bytes but the contents viewed as characters do change. If FLAG is `to', this makes the buffer a multibyte buffer by changing all eight-bit bytes to eight-bit characters. If the multibyte flag was really changed, undo information of the current buffer is cleared.

Recenter the overlays of the current buffer around position POS. That makes overlay lookup faster for positions near POS (but perhaps slower for positions far away from POS).

The eternal battle of how to represent mutable data like pt and name, nested atoms or updates via root buffer-alist? The latter doesn't work properly, save-current-buffer for example allows destructive updates to the current buffer it restores.

Return the buffer specified by BUFFER-OR-NAME, creating a new one if needed. If BUFFER-OR-NAME is a string and a live buffer with that name exists, return that buffer. If no such buffer exists, create a new buffer with that name and return it. If BUFFER-OR-NAME starts with a space, the new buffer does not keep undo information.

If BUFFER-OR-NAME is a buffer instead of a string, return it as given, even if it is dead. The return value is never nil.

Return the position at which OVERLAY starts.

Return the buffer named BUFFER-OR-NAME. BUFFER-OR-NAME must be either a string or a buffer. If BUFFER-OR-NAME is a string and there is no buffer with that name, return nil. If BUFFER-OR-NAME is a buffer, return it as given.

Create and return an indirect buffer for buffer BASE-BUFFER, named NAME. BASE-BUFFER should be a live buffer, or the name of an existing buffer. NAME should be a string which is not the name of an existing buffer. Optional argument CLONE non-nil means preserve BASE-BUFFER's state, such as major and minor modes, in the indirect buffer. CLONE nil means the indirect buffer's state is reset to default values.

Return the current buffer as a Lisp object.

Delete the overlay OVERLAY from its buffer.

Return the base buffer of indirect buffer BUFFER. If BUFFER is not indirect, return nil. BUFFER defaults to the current buffer.

Change current buffer's name to NEWNAME (a string). If second arg UNIQUE is nil or omitted, it is an error if a buffer named NEWNAME already exists. If UNIQUE is non-nil, come up with a new name using `generate-new-buffer-name'. Interactively, you can set UNIQUE with a prefix argument. We return the name we actually gave the buffer. This does not change the name of the visited file (if any).

Return the buffer OVERLAY belongs to. Return nil if OVERLAY has been deleted.

Delete the entire contents of the current buffer. Any narrowing restriction in effect (see `narrow-to-region') is removed, so the buffer is truly empty after this.

Switch to Fundamental mode by killing current buffer's local variables. Most local variable bindings are eliminated so that the default values become effective once more. Also, the syntax table is set from `standard-syntax-table', the local keymap is set to nil, and the abbrev table from `fundamental-mode-abbrev-table'. This function also forces redisplay of the mode line.

Every function to select a new major mode starts by calling this function.

As a special exception, local variables whose names have a non-nil `permanent-local' property are not eliminated by this function.

The first thing this function does is run the normal hook `change-major-mode-hook'.

Return the position at which OVERLAY ends.

Return the name of BUFFER, as a string. BUFFER defaults to the current buffer. Return nil if BUFFER has been killed.

Set one property of overlay OVERLAY: give property PROP value VALUE. VALUE will be returned.

Make buffer BUFFER-OR-NAME current for editing operations. BUFFER-OR-NAME may be a buffer or the name of an existing buffer. See also `save-excursion' when you want to make a buffer current temporarily. This function does not display the buffer, so its effect ends when the current command terminates. Use `switch-to-buffer' or `pop-to-buffer' to switch buffers permanently.

Start keeping undo information for buffer BUFFER. No argument or nil as argument means do this for the current buffer.

Return a list of all existing live buffers. If the optional arg FRAME is a frame, we return the buffer list in the proper order for that frame: the buffers show in FRAME come first, followed by the rest of the buffers.

Move BUFFER to the end of the buffer list.

Return the previous position before POS where an overlay starts or ends. If there are no overlay boundaries from (point-min) to POS, the value is (point-min).

Return an alist of variables that are buffer-local in BUFFER. Most elements look like (SYMBOL . VALUE), describing one variable. For a symbol that is locally unbound, just the symbol appears in the value. Note that storing new VALUEs in these elements doesn't change the variables. No argument or nil as argument means use current buffer as BUFFER.

Kill buffer BUFFER-OR-NAME. The argument may be a buffer or the name of an existing buffer. Argument nil or omitted means kill the current buffer. Return t if the buffer is actually killed, nil otherwise.

This function calls `replace-buffer-in-windows' for cleaning up all windows currently displaying the buffer to be killed. The functions in `kill-buffer-query-functions' are called with the buffer to be killed as the current buffer. If any of them returns nil, the buffer is not killed. The hook `kill-buffer-hook' is run before the buffer is actually killed. The buffer being killed will be current while the hook is running.

Any processes that have this buffer as the `process-buffer' are killed with SIGHUP.

Return a list of the overlays that overlap the region BEG ... END. Overlap means that at least one character is contained within the overlay and also contained within the specified region. Empty overlays are included in the result if they are located at BEG, between BEG and END, or at END provided END denotes the position at the end of the buffer.

Return the next position after POS where an overlay starts or ends. If there are no overlay boundaries from POS to (point-max), the value is (point-max).

Swap the text between current buffer and BUFFER.

Get the property of overlay OVERLAY with property name PROP.

Return a pair of lists giving all the overlays of the current buffer. The car has all the overlays before the overlay center; the cdr has all the overlays after the overlay center. Recentering overlays moves overlays between these lists. The lists you get are copies, so that changing them has no effect. However, the overlays you get are the real objects that the buffer uses.

Mark current buffer as modified or unmodified according to FLAG. A non-nil FLAG means mark the buffer modified.

Set the endpoints of OVERLAY to BEG and END in BUFFER. If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now. If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current buffer.

Return BUFFER's tick counter, incremented for each change in text. Each buffer has a tick counter which is incremented each time the text in that buffer is changed. It wraps around occasionally. No argument or nil as argument means use current buffer as BUFFER.

Return name of file BUFFER is visiting, or nil if none. No argument or nil as argument means use the current buffer.

Return the value of VARIABLE in BUFFER. If VARIABLE does not have a buffer-local binding in BUFFER, the value is the default binding of the variable.

Return the buffer visiting file FILENAME (a string). The buffer's `buffer-file-name' must match exactly the expansion of FILENAME. If there is no such live buffer, return nil. See also `find-buffer-visiting'.

Return a list of the properties on OVERLAY. This is a copy of OVERLAY's plist; modifying its conses has no effect on OVERLAY.

Return most recently selected buffer other than BUFFER. Buffers not visible in windows are preferred to visible buffers, unless optional second argument VISIBLE-OK is non-nil. Ignore the argument BUFFER unless it denotes a live buffer. If the optional third argument FRAME is non-nil, use that frame's buffer list instead of the selected frame's buffer list.

The buffer is found by scanning the selected or specified frame's buffer list first, followed by the list of all buffers. If no other buffer exists, return the buffer `scratch' (creating it if necessary).

Return a list of the overlays that contain the character at POS.

Set an appropriate major mode for BUFFER. For the scratch buffer, use `initial-major-mode', otherwise choose a mode according to `default-major-mode'. Use this function before selecting the buffer, since it may need to inspect the current buffer's major mode.

Alist of character property name vs char-table containing property values. Internal use only.

Return the parent char-table of CHAR-TABLE. The value is either nil or another char-table. If CHAR-TABLE holds nil for a given character, then the actual applicable value is inherited from the parent char-table (or from its parents, if necessary).

Set the parent char-table of CHAR-TABLE to PARENT. Return PARENT. PARENT must be either nil or another char-table.

Call FUNCTION for each character in CHAR-TABLE that has non-nil value. FUNCTION is called with two arguments--a key and a value. The key is a character code or a cons of character codes specifying a range of characters that have the same value.

Return the value of CHAR-TABLE's extra-slot number N.

Return the subtype of char-table CHAR-TABLE. The value is a symbol.

Set the value in CHAR-TABLE for a range of characters RANGE to VALUE. RANGE should be t (for all characters), nil (for the default value), a cons of character codes (for characters in the range), or a character code. Return VALUE.

Return an element of CHAR-TABLE for character CH. CHAR-TABLE must be what returned by `unicode-property-table-internal'.

Set CHAR-TABLE's extra-slot number N to VALUE.

Return a char-table for Unicode character property PROP. Use `get-unicode-property-internal' and put-unicode-property-internal' instead ofaref' and `aset' to get and put an element value.

Return a newly created char-table, with purpose PURPOSE. Each element is initialized to INIT, which defaults to nil.

PURPOSE should be a symbol. If it has a `char-table-extra-slots' property, the property's value should be an integer between 0 and 10 that specifies how many extra slots the char-table has. Otherwise, the char-table has no extra slot.

This function is obsolete since 23.1; generic characters no longer exist.

This function is obsolete and has no effect.

Return the value in CHAR-TABLE for a range of characters RANGE. RANGE should be nil (for the default value), a cons of character codes (for characters in the range), or a character code.

Optimize CHAR-TABLE. TEST is the comparison function used to decide whether two entries are equivalent and can be merged. It defaults to `equal'.

Set an element of CHAR-TABLE for character CH to VALUE. CHAR-TABLE must be what returned by `unicode-property-table-internal'.

The directory for writing temporary files.

You can customize this variable.

Lock FILE, if current buffer is modified. FILE defaults to current buffer's visited file, or else nothing is done if current buffer isn't visiting a file.

Unlock the file visited in the current buffer. If the buffer is not modified, this does nothing because the file should not be locked in that case.

Return a value indicating whether FILENAME is locked. The value is nil if the FILENAME is not locked, t if it is locked by you, else a string saying which user has locked it.

Select a new standard case table for new buffers. See `set-case-table' for more info on case tables.

Return t if OBJECT is a case table. See `set-case-table' for more information on these data structures.

Return the case table of the current buffer.

Select a new case table for the current buffer. A case table is a char-table which maps characters to their lower-case equivalents. It also has three "extra" slots which may be additional char-tables or nil. These slots are called UPCASE, CANONICALIZE and EQUIVALENCES. UPCASE maps each non-upper-case character to its upper-case equivalent. (The value in UPCASE for an upper-case character is never used.) If lower and upper case characters are in 1-1 correspondence, you may use nil and the upcase table will be deduced from DOWNCASE. CANONICALIZE maps each character to a canonical equivalent; any two characters that are related by case-conversion have the same canonical equivalent character; it may be nil, in which case it is deduced from DOWNCASE and UPCASE. EQUIVALENCES is a map that cyclically permutes each equivalence class (of characters with the same canonical equivalent); it may be nil, in which case it is deduced from CANONICALIZE.

Return the standard case table. This is the one used for new buffers.

If non-nil, Emacs ignores null bytes on code detection. By default, Emacs treats it as binary data, and does not attempt to decode it. The effect is as if you specified `no-conversion' for reading that text.

Set this to non-nil when a regular text happens to include null bytes. Examples are Index nodes of Info files and null-byte delimited output from GNU Find and GNU Grep. Emacs will then ignore the null bytes and decode text as usual.

*String displayed in mode line when end-of-line format is not yet determined.

You can customize this variable.

Table of extra Latin codes in the range 128..159 (inclusive). This is a vector of length 256. If Nth element is non-nil, the existence of code N in a file (or output of subprocess) doesn't prevent it to be detected as a coding system of ISO 2022 variant which has a flag `accept-latin-extra-code' t (e.g. iso-latin-1) on reading a file or reading output of a subprocess. Only 128th through 159th elements have a meaning.

Coding system used in the latest file or process I/O.

Alist of charsets vs revision numbers. While encoding, if a charset (car part of an element) is found, designate it with the escape sequence identifying revision (cdr part of the element).

Table for translating characters while decoding.

If non-nil, Emacs ignores ISO-2022 escape sequences during code detection.

When Emacs reads text, it tries to detect how the text is encoded. This code detection is sensitive to escape sequences. If Emacs sees a valid ISO-2022 escape sequence, it assumes the text is encoded in one of the ISO2022 encodings, and decodes text by the corresponding coding system (e.g. `iso-2022-7bit').

However, there may be a case that you want to read escape sequences in a file as is. In such a case, you can set this variable to non-nil. Then the code detection will ignore any escape sequences, and no text is detected as encoded in some ISO-2022 encoding. The result is that all escape sequences become visible in a buffer.

The default value is nil, and it is strongly recommended not to change it. That is because many Emacs Lisp source files that contain non-ASCII characters are encoded by the coding system `iso-2022-7bit' in Emacs's distribution, and they won't be decoded correctly on reading if you suppress escape sequence detection.

The other way to read escape sequences in a file without decoding is to explicitly specify some coding system that doesn't use ISO-2022 escape sequence (e.g `latin-1') on reading by C-x RET c.

List of coding systems.

Do not alter the value of this variable manually. This variable should be updated by the functions `define-coding-system' and `define-coding-system-alias'.

Table for translating characters while encoding.

Specify the coding system for write operations. Programs bind this variable with `let', but you should not set it globally. If the value is a coding system, it is used for encoding of output, when writing it to a file and when sending it to a file or subprocess.

If this does not specify a coding system, an appropriate element is used from one of the coding system alists. There are three such tables: `file-coding-system-alist', process-coding-system-alist', andnetwork-coding-system-alist'. For output to files, if the above procedure does not specify a coding system, the value of `buffer-file-coding-system' is used.

*Non-nil enables character translation while encoding and decoding.

*String displayed in mode line for UNIX-like (LF) end-of-line format.

You can customize this variable.

Specify the coding system for read operations. It is useful to bind this variable with `let', but do not set it globally. If the value is a coding system, it is used for decoding on read operation. If not, an appropriate element is used from one of the coding system alists. There are three such tables: `file-coding-system-alist', process-coding-system-alist', andnetwork-coding-system-alist'.

*String displayed in mode line for MAC-like (CR) end-of-line format.

You can customize this variable.

Non-nil means process buffer inherits coding system of process output. Bind it to t if the process output is to be treated as if it were a file read from some filesystem.

Function to call to select safe coding system for encoding a text.

If set, this function is called to force a user to select a proper coding system which can encode the text in the case that a default coding system used in each operation can't encode the text. The function should take care that the buffer is not modified while the coding system is being selected.

The default value is `select-safe-coding-system' (which see).

*String displayed in mode line for DOS-like (CRLF) end-of-line format.

You can customize this variable.

Error status of the last code conversion.

When an error was detected in the last code conversion, this variable is set to one of the following symbols. `insufficient-source' `inconsistent-eol' `invalid-source' `interrupted' `insufficient-memory' When no error was detected, the value doesn't change. So, to check the error status of a code conversion by this variable, you must explicitly set this variable to nil before performing code conversion.

Alist to decide a coding system to use for a file I/O operation. The format is ((PATTERN . VAL) ...), where PATTERN is a regular expression matching a file name, VAL is a coding system, a cons of coding systems, or a function symbol. If VAL is a coding system, it is used for both decoding and encoding the file contents. If VAL is a cons of coding systems, the car part is used for decoding, and the cdr part is used for encoding. If VAL is a function symbol, the function must return a coding system or a cons of coding systems which are used as above. The function is called with an argument that is a list of the arguments with which `find-operation-coding-system' was called. If the function can't decide a coding system, it can return `undecided' so that the normal code-detection is performed.

See also the function `find-operation-coding-system' and the variable `auto-coding-alist'.

You can customize this variable.

Alist to decide a coding system to use for a network I/O operation. The format is ((PATTERN . VAL) ...), where PATTERN is a regular expression matching a network service name or is a port number to connect to, VAL is a coding system, a cons of coding systems, or a function symbol. If VAL is a coding system, it is used for both decoding what received from the network stream and encoding what sent to the network stream. If VAL is a cons of coding systems, the car part is used for decoding, and the cdr part is used for encoding. If VAL is a function symbol, the function must return a coding system or a cons of coding systems which are used as above.

See also the function `find-operation-coding-system'.

Cons of coding systems used for process I/O by default. The car part is used for decoding a process output, the cdr part is used for encoding a text to be sent to a process.

*Non-nil means always inhibit code conversion of end-of-line format. See info node Coding Systems' and info nodeText and Binary' concerning such conversion.

You can customize this variable.

Alist of coding system names. Each element is one element list of coding system name. This variable is given to `completing-read' as COLLECTION argument.

Do not alter the value of this variable manually. This variable should be updated by the functions `make-coding-system' and `define-coding-system-alias'.

Internal use only. If non-nil, on writing a file, `select-safe-coding-system-function' is called even if `coding-system-for-write' is non-nil. The command `universal-coding-system-argument' binds this variable to t temporarily.

Coding system to use with system messages. Also used for decoding keyboard input on X Window system.

Char table for translating self-inserting characters. This is applied to the result of input methods, not their input. See also `keyboard-translate-table'.

Use of this variable for character code unification was rendered obsolete in Emacs 23.1 and later, since Unicode is now the basis of internal character representation.

List of coding-categories (symbols) ordered by priority.

On detecting a coding system, Emacs tries code detection algorithms associated with each coding-category one by one in this order. When one algorithm agrees with a byte sequence of source text, the coding system bound to the corresponding coding-category is selected.

Don't modify this variable directly, but use `set-coding-system-priority'.

Alist to decide a coding system to use for a process I/O operation. The format is ((PATTERN . VAL) ...), where PATTERN is a regular expression matching a program name, VAL is a coding system, a cons of coding systems, or a function symbol. If VAL is a coding system, it is used for both decoding what received from the program and encoding what sent to the program. If VAL is a cons of coding systems, the car part is used for decoding, and the cdr part is used for encoding. If VAL is a function symbol, the function must return a coding system or a cons of coding systems which are used as above.

See also the function `find-operation-coding-system'.

Return the base of CODING-SYSTEM. Any alias or subsidiary coding system is not a base coding system.

Encode the Big5 character CH to BIG5 coding system. Return the corresponding character code in Big5.

Return eol-type of CODING-SYSTEM. An eol-type is an integer 0, 1, 2, or a vector of coding systems.

Integer values 0, 1, and 2 indicate a format of end-of-line; LF, CRLF, and CR respectively.

A vector value indicates that a format of end-of-line should be detected automatically. Nth element of the vector is the subsidiary coding system whose eol-type is N.

Return the list of aliases of CODING-SYSTEM.

Internal use only.

Define ALIAS as an alias for CODING-SYSTEM.

Decode a Big5 character which has CODE in BIG5 coding system. Return the corresponding character.

Internal use only.

Return the property list of CODING-SYSTEM.

Internal use only.

Decode the current region from the specified coding system. When called from a program, takes four arguments: START, END, CODING-SYSTEM, and DESTINATION. START and END are buffer positions.

Optional 4th arguments DESTINATION specifies where the decoded text goes. If nil, the region between START and END is replaced by the decoded text. If buffer, the decoded text is inserted in that buffer after point (point does not move). In those cases, the length of the decoded text is returned. If DESTINATION is t, the decoded text is returned.

This function sets `last-coding-system-used' to the precise coding system used (which may be different from CODING-SYSTEM if CODING-SYSTEM is not fully specified.)

Detect coding system of the text in STRING. Return a list of possible coding systems ordered by priority. The coding systems to try and their priorities follows what the function `coding-system-priority-list' (which see) returns.

If only ASCII characters are found (except for such ISO-2022 control characters as ESC), it returns a list of single element `undecided' or its subsidiary coding system according to a detected end-of-line format.

If optional argument HIGHEST is non-nil, return the coding system of highest priority.

Encode the current region by specified coding system. When called from a program, takes four arguments: START, END, CODING-SYSTEM and DESTINATION. START and END are buffer positions.

Optional 4th arguments DESTINATION specifies where the encoded text goes. If nil, the region between START and END is replace by the encoded text. If buffer, the encoded text is inserted in that buffer after point (point does not move). In those cases, the length of the encoded text is returned. If DESTINATION is t, the encoded text is returned.

This function sets `last-coding-system-used' to the precise coding system used (which may be different from CODING-SYSTEM if CODING-SYSTEM is not fully specified.)

Decode a Japanese character which has CODE in shift_jis encoding. Return the corresponding character.

Return position of first un-encodable character in a region. START and END specify the region and CODING-SYSTEM specifies the encoding to check. Return nil if CODING-SYSTEM does encode the region.

If optional 4th argument COUNT is non-nil, it specifies at most how many un-encodable characters to search. In this case, the value is a list of positions.

If optional 5th argument STRING is non-nil, it is a string to search for un-encodable characters. In that case, START and END are indexes to the string.

Read a coding system from the minibuffer, prompting with string PROMPT. If the user enters null input, return second argument DEFAULT-CODING-SYSTEM. Ignores case when completing coding systems (all Emacs coding systems are lower-case).

Check if the region is encodable by coding systems.

START and END are buffer positions specifying the region. CODING-SYSTEM-LIST is a list of coding systems to check.

The value is an alist ((CODING-SYSTEM POS0 POS1 ...) ...), where CODING-SYSTEM is a member of CODING-SYSTEM-LIST and can't encode the whole region, POS0, POS1, ... are buffer positions where non-encodable characters are found.

If all coding systems in CODING-SYSTEM-LIST can encode the region, the value is nil.

START may be a string. In that case, check if the string is encodable, and the value contains indices to the string instead of buffer positions. END is ignored.

If the current buffer (or START if it is a string) is unibyte, the value is nil.

Encode STRING to CODING-SYSTEM, and return the result.

Optional third arg NOCOPY non-nil means it is OK to return STRING itself if the encoding operation is trivial.

Optional fourth arg BUFFER non-nil means that the encoded text is inserted in that buffer after point (point does not move). In this case, the return value is the length of the encoded text.

This function sets `last-coding-system-used' to the precise coding system used (which may be different from CODING-SYSTEM if CODING-SYSTEM is not fully specified.)

Choose a coding system for an operation based on the target name. The value names a pair of coding systems: (DECODING-SYSTEM . ENCODING-SYSTEM). DECODING-SYSTEM is the coding system to use for decoding (in case OPERATION does decoding), and ENCODING-SYSTEM is the coding system for encoding (in case OPERATION does encoding).

The first argument OPERATION specifies an I/O primitive: For file I/O, insert-file-contents' orwrite-region'. For process I/O, call-process',call-process-region', or `start-process'. For network I/O, `open-network-stream'.

The remaining arguments should be the same arguments that were passed to the primitive. Depending on which primitive, one of those arguments is selected as the TARGET. For example, if OPERATION does file I/O, whichever argument specifies the file name is TARGET.

TARGET has a meaning which depends on OPERATION: For file I/O, TARGET is a file name (except for the special case below). For process I/O, TARGET is a process name. For network I/O, TARGET is a service name or a port number.

This function looks up what is specified for TARGET in file-coding-system-alist',process-coding-system-alist', or `network-coding-system-alist' depending on OPERATION. They may specify a coding system, a cons of coding systems, or a function symbol to call. In the last case, we call the function with one argument, which is a list of all the arguments given to this function. If the function can't decide a coding system, it can return `undecided' so that the normal code-detection is performed.

If OPERATION is `insert-file-contents', the argument corresponding to TARGET may be a cons (FILENAME . BUFFER). In that case, FILENAME is a file name to look up, and BUFFER is a buffer that contains the file's contents (not yet decoded). If `file-coding-system-alist' specifies a function to call for FILENAME, that function should examine the contents of BUFFER instead of reading the file.

Return coding system specified for terminal output on the given terminal. TERMINAL may be a terminal object, a frame, or nil for the selected frame's terminal device.

Return a list of coding systems ordered by their priorities. The list contains a subset of coding systems; i.e. coding systems assigned to each coding category (see `coding-category-list').

HIGHESTP non-nil means just return the highest priority one.

Return coding system specified for decoding keyboard input.

Detect coding system of the text in the region between START and END. Return a list of possible coding systems ordered by priority. The coding systems to try and their priorities follows what the function `coding-system-priority-list' (which see) returns.

If only ASCII characters are found (except for such ISO-2022 control characters as ESC), it returns a list of single element `undecided' or its subsidiary coding system according to a detected end-of-line format.

If optional argument HIGHEST is non-nil, return the coding system of highest priority.

For internal use only.

Change value in CODING-SYSTEM's property list PROP to VAL.

Decode STRING which is encoded in CODING-SYSTEM, and return the result.

Optional third arg NOCOPY non-nil means it is OK to return STRING itself if the decoding operation is trivial.

Optional fourth arg BUFFER non-nil means that the decoded text is inserted in that buffer after point (point does not move). In this case, the return value is the length of the decoded text.

This function sets `last-coding-system-used' to the precise coding system used (which may be different from CODING-SYSTEM if CODING-SYSTEM is not fully specified.)

Internal use only.

Read a coding system from the minibuffer, prompting with string PROMPT.

Encode a Japanese character CH to shift_jis encoding. Return the corresponding code in SJIS.

Assign higher priority to the coding systems given as arguments. If multiple coding systems belong to the same category, all but the first one are ignored.

Check validity of CODING-SYSTEM. If valid, return CODING-SYSTEM, else signal a `coding-system-error' error. It is valid if it is nil or a symbol defined as a coding system by the function `define-coding-system'.

Return t if OBJECT is nil or a coding-system. See the documentation of `define-coding-system' for information about coding-system objects.

Non-nil enables debugging checks in byte/char position conversions.

Return the position MARKER points at, as a character number. Returns nil if MARKER points nowhere.

Return t if there are markers pointing at POSITION in the current buffer.

Return a new marker pointing at the same place as MARKER. If argument is a number, makes a new marker pointing at that position in the current buffer. If MARKER is not specified, the new marker does not point anywhere. The optional argument TYPE specifies the insertion type of the new marker; see `marker-insertion-type'.

Return insertion type of MARKER: t if it stays after inserted text. The value nil means the marker stays before text inserted there.

Set the insertion-type of MARKER to TYPE. If TYPE is t, it means the marker advances when you insert text at it. If TYPE is nil, it means the marker stays behind when you insert text at it.

Return the buffer that MARKER points into, or nil if none. Returns nil if MARKER points into a dead buffer.

Position MARKER before character number POSITION in BUFFER. BUFFER defaults to the current buffer. If POSITION is nil, makes marker point nowhere. Then it no longer slows down editing in any buffer. Returns MARKER.

List of pair (cons) of categories to determine word boundary. See the documentation of the variable `word-combining-categories'.

List of pair (cons) of categories to determine word boundary.

Emacs treats a sequence of word constituent characters as a single word (i.e. finds no word boundary between them) only if they belong to the same script. But, exceptions are allowed in the following cases.

(1) The case that characters are in different scripts is controlled by the variable `word-combining-categories'.

Emacs finds no word boundary between characters of different scripts if they have categories matching some element of this list.

More precisely, if an element of this list is a cons of category CAT1 and CAT2, and a multibyte character C1 which has CAT1 is followed by C2 which has CAT2, there's no word boundary between C1 and C2.

For instance, to tell that Han characters followed by Hiragana characters can form a single word, the element `(?C . ?H)' should be in this list.

(2) The case that character are in the same script is controlled by the variable `word-separating-categories'.

Emacs finds a word boundary between characters of the same script if they have categories matching some element of this list.

More precisely, if an element of this list is a cons of category CAT1 and CAT2, and a multibyte character C1 which has CAT1 but not CAT2 is followed by C2 which has CAT2 but not CAT1, there's a word boundary between C1 and C2.

For instance, to tell that there's a word boundary between Hiragana and Katakana (both are in the same script `kana'), the element `(?H . ?K) should be in this list.

Return the standard category table. This is the one used for new buffers.

Construct a new and empty category table and return it.

Construct a new category table and return it. It is a copy of the TABLE, which defaults to the standard category table.

Return the category set of CHAR.

Return a newly created category-set which contains CATEGORIES. CATEGORIES is a string of category mnemonics. The value is a bool-vector which has t at the indices corresponding to those categories.

Return a string containing mnemonics of the categories in CATEGORY-SET. CATEGORY-SET is a bool-vector, and the categories "in" it are those that are indexes where t occurs in the bool-vector. The return value is a string containing those same categories.

Specify TABLE as the category table for the current buffer. Return TABLE.

Return t if ARG is a category table.

Return the current category table. This is the one specified by the current buffer.

Modify the category set of CHARACTER by adding CATEGORY to it. The category is changed only for table TABLE, which defaults to the current buffer's category table. CHARACTER can be either a single character or a cons representing the lower and upper ends of an inclusive character range to modify. If optional fourth argument RESET is non-nil, then delete CATEGORY from the category set instead of adding it.

Return the documentation string of CATEGORY, as defined in TABLE. TABLE should be a category table and defaults to the current buffer's category table.

Define CATEGORY as a category which is described by DOCSTRING. CATEGORY should be an ASCII printing character in the range ' to~'. DOCSTRING is the documentation string of the category. The first line should be a terse text (preferably less than 16 characters), and the rest lines should be the full description. The category is defined only in category table TABLE, which defaults to the current buffer's category table.

Return a category which is not yet defined in TABLE. If no category remains available, return nil. The optional argument TABLE specifies which category table to modify; it defaults to the current buffer's category table.

*Non-nil means print recursive structures using #N= and #N# syntax. If nil, printing proceeds recursively and may lead to `max-lisp-eval-depth' being exceeded or an error may occur: "Apparently circular structure being printed." Also see print-length' andprint-level'. If non-nil, shared substructures anywhere in the structure are printed with `#N=' before the first occurrence (in the order of the print representation) and `#N#' in place of each subsequent occurrence, where N is a positive decimal integer.

Non-nil means print uninterned symbols so they will read as uninterned. I.e., the value of (make-symbol "foobar") prints as #:foobar. When the uninterned symbol appears within a recursive data structure, and the symbol appears more than once, in addition use the #N# and #N= constructs as needed, so that multiple references to the same symbol are shared once again when the text is read back.

A flag to control printing of `charset' text property on printing a string. The value must be nil, t, or `default'.

If the value is nil, don't print the text property `charset'.

If the value is t, always print the text property `charset'.

If the value is default', print the text propertycharset' only when the value is different from what is guessed in the current charset priorities.

Non-nil means print multibyte characters in strings as \xXXXX. (XXXX is the hex representation of the character code.) This affects only `prin1'.

Output stream `print' uses by default for outputting a character. This may be any function of one argument. It may also be a buffer (output is inserted before point) or a marker (output is inserted and the marker is advanced) or the symbol t (output appears in the echo area).

The format descriptor string used to print floats. This is a %-spec like those accepted by `printf' in C, but with some restrictions. It must start with the two characters `%.'. After that comes an integer precision specification, and then a letter which controls the format. The letters allowed are e',f' and `g'. Use `e' for exponential notation "DIG.DIGITSeEXPT" Use `f' for decimal point notation "DIGITS.DIGITS". Use `g' to choose the shorter of those two formats for the number at hand. The precision in any of these cases is the number of digits following the decimal point. With `f', a precision of 0 means to omit the decimal point. 0 is not allowed with e' org'.

A value of nil means to use the shortest notation that represents the number without losing information.

Non-nil means print newlines in strings as `\n'. Also print formfeeds as `\f'.

Non-nil means print quoted forms with reader syntax. I.e., (quote foo) prints as 'foo, (function foo) as #'foo.

*Non-nil means number continuously across print calls. This affects the numbers printed for #N= labels and #M# references. See also print-circle',print-gensym', and `print-number-table'. This variable should not be set with setq'; bind it with alet' instead.

Maximum depth of list nesting to print before abbreviating. A value of nil means no limit. See also `eval-expression-print-level'.

A vector used internally to produce #N=' labels and#N#' references. The Lisp printer uses this vector to detect Lisp objects referenced more than once.

When you bind `print-continuous-numbering' to t, you should probably also bind `print-number-table' to nil. This ensures that the value of `print-number-table' can be garbage-collected once the printing is done. If all elements of `print-number-table' are nil, it means that the printing done so far has not found any shared structure or objects that need to be recorded in the table.

Maximum length of list to print before abbreviating. A value of nil means no limit. See also `eval-expression-print-length'.

Non-nil means print unibyte non-ASCII chars in strings as \OOO. (OOO is the octal representation of the character code.) Only single-byte characters are affected, and only in `prin1'. When the output goes in a multibyte buffer, this feature is enabled regardless of the value of the variable.

Convert an error value (ERROR-SYMBOL . DATA) to an error message. See Info anchor `(elisp)Definition of signal' for some details on how this error message is constructed.

Output the printed representation of OBJECT, with newlines around it. Quoting characters are printed when needed to make output that `read' can handle, whenever this is possible. For complex objects, the behavior is controlled by print-level' andprint-length', which see.

OBJECT is any of the Lisp data types: a number, a string, a symbol, a list, a buffer, a window, a frame, etc.

A printed representation of an object is text which describes that object.

Optional argument PRINTCHARFUN is the output stream, which can be one of these:

 - a buffer, in which case output is inserted into that buffer at point;
 - a marker, in which case output is inserted at marker's position;
 - a function, in which case that function is called once for each
   character of OBJECT's printed representation;
 - a symbol, in which case that symbol's function definition is called; or
 - t, in which case the output is displayed in the echo area.

If PRINTCHARFUN is omitted, the value of `standard-output' (which see) is used instead.

Redirect debugging output (stderr stream) to file FILE. If FILE is nil, reset target to the initial stderr stream. Optional arg APPEND non-nil (interactively, with prefix arg) means append to existing target file.

Output a newline to stream PRINTCHARFUN. If PRINTCHARFUN is omitted or nil, the value of `standard-output' is used.

Return a string containing the printed representation of OBJECT. OBJECT can be any Lisp object. This function outputs quoting characters when necessary to make output that `read' can handle, whenever possible, unless the optional second argument NOESCAPE is non-nil. For complex objects, the behavior is controlled by print-level' andprint-length', which see.

OBJECT is any of the Lisp data types: a number, a string, a symbol, a list, a buffer, a window, a frame, etc.

A pqrinted representation of an object is text which describes that object.

Output the printed representation of OBJECT, any Lisp object. Quoting characters are printed when needed to make output that `read' can handle, whenever this is possible. For complex objects, the behavior is controlled by print-level' andprint-length', which see.

OBJECT is any of the Lisp data types: a number, a string, a symbol, a list, a buffer, a window, a frame, etc.

A printed representation of an object is text which describes that object.

Optional argument PRINTCHARFUN is the output stream, which can be one of these:

 - a buffer, in which case output is inserted into that buffer at point;
 - a marker, in which case output is inserted at marker's position;
 - a function, in which case that function is called once for each
   character of OBJECT's printed representation;
 - a symbol, in which case that symbol's function definition is called; or
 - t, in which case the output is displayed in the echo area.

If PRINTCHARFUN is omitted, the value of `standard-output' (which see) is used instead.

Write CHARACTER to stderr. You can call print while debugging emacs, and pass it this function to make it write to the debugging output.

Output the printed representation of OBJECT, any Lisp object. No quoting characters are used; no delimiters are printed around the contents of strings.

OBJECT is any of the Lisp data types: a number, a string, a symbol, a list, a buffer, a window, a frame, etc.

A printed representation of an object is text which describes that object.

Optional argument PRINTCHARFUN is the output stream, which can be one of these:

 - a buffer, in which case output is inserted into that buffer at point;
 - a marker, in which case output is inserted at marker's position;
 - a function, in which case that function is called once for each
   character of OBJECT's printed representation;
 - a symbol, in which case that symbol's function definition is called; or
 - t, in which case the output is displayed in the echo area.

If PRINTCHARFUN is omitted, the value of `standard-output' (which see) is used instead.

Output character CHARACTER to stream PRINTCHARFUN. PRINTCHARFUN defaults to the value of `standard-output' (which see).

Alist of fonts vs the rescaling factors. Each element is a cons (FONT-PATTERN . RESCALE-RATIO), where FONT-PATTERN is a font-spec or a regular expression matching a font name, and RESCALE-RATIO is a floating point number to specify how much larger (or smaller) font we should use. For instance, if a face requests a font of 10 point, we actually use a font of 10 * RESCALE-RATIO point.

Alist of face remappings. Each element is of the form:

 (FACE . REPLACEMENT),

which causes display of the face FACE to use REPLACEMENT instead. REPLACEMENT is a face specification, i.e. one of the following:

(1) a face name
(2) a property list of attribute/value pairs, or
(3) a list in which each element has the form of (1) or (2).

List values for REPLACEMENT are merged to form the final face specification, with earlier entries taking precedence, in the same as as in the `face' text property.

Face-name remapping cycles are suppressed; recursive references use the underlying face instead of the remapped face. So a remapping of the form:

 (FACE EXTRA-FACE... FACE)

or:

 (FACE (FACE-ATTR VAL ...) FACE)

causes EXTRA-FACE... or (FACE-ATTR VAL ...) to be merged with the existing definition of FACE. Note that this isn't necessary for the default face, since every face inherits from the default face.

If this variable is made buffer-local, the face remapping takes effect only in that buffer. For instance, the mode my-mode could define a face `my-mode-default', and then in the mode setup function, do:

 (set (make-local-variable 'face-remapping-alist)
'((default my-mode-default)))).

Because Emacs normally only redraws screen areas when the underlying buffer contents change, you may need to call `redraw-display' after changing this variable for it to take effect.

An alist of defined terminal colors and their RGB values. See the docstring of `tty-color-alist' for the details.

*Default stipple pattern used on monochrome displays. This stipple pattern is used on monochrome displays instead of shades of gray for a face background color. See `set-face-stipple' for possible values for this variable.

*Limit for font matching. If an integer > 0, font matching functions won't load more than that number of fonts when searching for a matching font.

Allowed scalable fonts. A value of nil means don't allow any scalable fonts. A value of t means allow any scalable font. Otherwise, value must be a list of regular expressions. A font may be scaled if its name matches a regular expression in the list. Note that if value is nil, a scalable font might still be used, if no other font of the appropriate family and registry is available.

You can customize this variable.

List of ignored fonts. Each element is a regular expression that matches names of fonts to ignore.

List of global face definitions (for internal use only.)

Make FACE, a symbol, a Lisp face with all attributes nil. If FACE was not known as a face before, create a new one. If optional argument FRAME is specified, make a frame-local face for that frame. Otherwise operate on the global face definition. Value is a vector of face attributes.

Return non-nil if all the face attributes in ATTRIBUTES are supported. The optional argument DISPLAY can be a display name, a frame, or nil (meaning the selected frame's display).

The definition of `supported' is somewhat heuristic, but basically means that a face containing all the attributes in ATTRIBUTES, when merged with the default face for display, can be represented in a way that's

(1) different in appearance than the default face, and (2) `close in spirit' to what the attributes specify, if not exact.

Point (2) implies that a `:weight black' attribute will be satisfied by any display that can display bold, and a `:foreground "yellow"' as long as it can display a yellowish color, but `:slant italic' will not be satisfied by the tty display code's automatic substitution of a `dim' face for italic.

Check whether a face attribute value is relative. Specifically, this function returns t if the attribute ATTRIBUTE with the value VALUE is relative.

A relative value is one that doesn't entirely override whatever is inherited from another face. For most possible attributes, the only relative value that users see is `unspecified'. However, for :height, floating point values are also relative.

Return non-nil if COLOR can be displayed on FRAME. BACKGROUND-P non-nil means COLOR is used as a background. Otherwise, this function tells whether it can be used as a foreground. If FRAME is nil or omitted, use the selected frame. COLOR must be a valid color name.

Create an alist of color entries from an external file.

The file should define one named RGB color per line like so: R G B name where R,G,B are numbers between 0 and 255 and name is an arbitrary string.

True if FACE has no attribute specified. If the optional argument FRAME is given, report on face FACE in that frame. If FRAME is t, report on the defaults for face FACE (for new frames). If FRAME is omitted or nil, use the selected frame.

Set attribute ATTR of FACE to VALUE. FRAME being a frame means change the face on that frame. FRAME nil means change the face of the selected frame. FRAME t means change the default for new frames. FRAME 0 means change the face on all frames, and change the default for new frames.

Clear face caches on all frames. Optional THOROUGHLY non-nil means try to free unused fonts, too.

Define alternative font registries to try in face font selection. ALIST is an alist of (REGISTRY ALTERNATIVE1 ALTERNATIVE2 ...) entries. Each ALTERNATIVE is tried in order if no fonts of font registry REGISTRY can be found. Value is ALIST.

Return face ATTRIBUTE VALUE1 merged with VALUE2. If VALUE1 or VALUE2 are absolute (see `face-attribute-relative-p'), then the result will be absolute, otherwise it will be relative.

Return non-nil if COLOR is a shade of gray (or white or black). FRAME specifies the frame and thus the display for interpreting COLOR. If FRAME is nil or omitted, use the selected frame.

Suppress/allow boldness of faces with inverse default colors. SUPPRESS non-nil means suppress it. This affects bold faces on TTYs whose foreground is the default background color of the display and whose background is the default foreground color. For such faces, the bold face attribute is ignored if this variable is non-nil.

Add attributes from frame-default definition of FACE to FACE on FRAME. Default face attributes override any local face attributes.

Return the font name of face FACE, or nil if it is unspecified. The font name is, by default, for ASCII characters. If the optional argument FRAME is given, report on face FACE in that frame. If FRAME is t, report on the defaults for face FACE (for new frames). The font default for a face is either nil, or a list of the form (bold), (italic) or (bold italic). If FRAME is omitted or nil, use the selected frame. And, in this case, if the optional third argument CHARACTER is given, return the font name used for CHARACTER.

Return a list of valid discrete values for face attribute ATTR. Value is nil if ATTR doesn't have a discrete set of valid values.

True if FACE1 and FACE2 are equal. If the optional argument FRAME is given, report on FACE1 and FACE2 in that frame. If FRAME is t, report on the defaults for FACE1 and FACE2 (for new frames). If FRAME is omitted or nil, use the selected frame.

Set font selection order for face font selection to ORDER. ORDER must be a list of length 4 containing the symbols `:width', :height',:weight', and `:slant'. Face attributes appearing first in ORDER are matched first, e.g. if `:height' appears before `:weight' in ORDER, font selection first tries to find a font with a suitable height, and then tries to match the font weight. Value is ORDER.

Return non-nil if FACE names a face. FACE should be a symbol or string. If optional second argument FRAME is non-nil, check for the existence of a frame-local face with name FACE on that frame. Otherwise check for the existence of a global face.

Copy face FROM to TO. If FRAME is t, copy the global face definition of FROM. Otherwise, copy the frame-local definition of FROM on FRAME. If NEW-FRAME is a frame, copy that data into the frame-local definition of TO on NEW-FRAME. If NEW-FRAME is nil, FRAME controls where the data is copied to.

The value is TO.

Return an alist of frame-local faces defined on FRAME. For internal use only.

Define alternative font families to try in face font selection. ALIST is an alist of (FAMILY ALTERNATIVE1 ALTERNATIVE2 ...) entries. Each ALTERNATIVE is tried in order if no fonts of font family FAMILY can be found. Value is ALIST.

Return a vector of face attributes corresponding to PLIST.

Return face attribute KEYWORD of face SYMBOL. If SYMBOL does not name a valid Lisp face or KEYWORD isn't a valid face attribute name, signal an error. If the optional argument FRAME is given, report on face SYMBOL in that frame. If FRAME is t, report on the defaults for face SYMBOL (for new frames). If FRAME is omitted or nil, use the selected frame.

Return an integer distance between COLOR1 and COLOR2 on FRAME. COLOR1 and COLOR2 may be either strings containing the color name, or lists of the form (RED GREEN BLUE). If FRAME is unspecified or nil, the current frame is used.

Last kbd macro defined, as a string or vector; nil if none defined.

Non-nil while a keyboard macro is being defined. Don't set this! The value is the symbol `append' while appending to the definition of an existing macro.

Normal hook run whenever a keyboard macro terminates. This is run whether the macro ends normally or prematurely due to an error.

Index in currently executing keyboard macro; undefined if none executing.

Currently executing keyboard macro (string or vector). This is nil when not executing a keyboard macro.

Record subsequent keyboard input, defining a keyboard macro. The commands are recorded even as they are executed. Use M-x end-kbd-macro to finish recording and make the macro available. Use M-x name-last-kbd-macro to give it a permanent name. Non-nil arg (prefix arg) means append to last macro defined; this begins by re-executing that macro as if you typed it again. If optional second arg, NO-EXEC, is non-nil, do not re-execute last macro before appending to it.

Record subsequent keyboard input, defining a keyboard macro. The commands are recorded even as they are executed. Use M-x end-kbd-macro to finish recording and make the macro available. Use M-x name-last-kbd-macro to give it a permanent name. Non-nil arg (prefix arg) means append to last macro defined; this begins by re-executing that macro as if you typed it again. If optional second arg, NO-EXEC, is non-nil, do not re-execute last macro before appending to it.

Execute MACRO as string of editor command characters. If MACRO is a symbol, its function definition is used. COUNT is a repeat count, or nil for once, or 0 for infinite loop.

Optional third arg LOOPFUNC may be a function that is called prior to each iteration of the macro. Iteration stops if LOOPFUNC returns nil.

Finish defining a keyboard macro. The definition was started by M-x start-kbd-macro. The macro is now available for use via M-x call-last-kbd-macro, or it can be given a name with M-x name-last-kbd-macro and then invoked under that name.

With numeric arg, repeat macro now that many times, counting the definition just completed as the first repetition. An argument of zero means repeat until error.

In Lisp, optional second arg LOOPFUNC may be a function that is called prior to each iteration of the macro. Iteration stops if LOOPFUNC returns nil.

Call the last keyboard macro that you defined with M-x start-kbd-macro.

A prefix argument serves as a repeat count. Zero means repeat until error.

To make a macro permanent so you can call it even after defining others, use M-x name-last-kbd-macro.

In Lisp, optional second arg LOOPFUNC may be a function that is called prior to each iteration of the macro. Iteration stops if LOOPFUNC returns nil.

Cancel the events added to a keyboard macro for this command.

Store EVENT into the keyboard macro being defined.

Completion ignores file names ending in any string in this list. It does not ignore them if all possible completions end in one of these strings or when displaying a list of completions. It ignores directory names if they match any string in this list which ends in a slash.

You can customize this variable.

Return a list of attributes of file FILENAME. Value is nil if specified file cannot be opened.

ID-FORMAT specifies the preferred format of attributes uid and gid (see below) - valid values are 'string and 'integer. The latter is the default, but we plan to change that, so you should specify a non-nil value for ID-FORMAT if you use the returned uid or gid.

Elements of the attribute list are: 0. t for directory, string (name linked to) for symbolic link, or nil. 1. Number of links to file. 2. File uid as a string or a number. If a string value cannot be looked up, a numeric value, either an integer or a float, is returned. 3. File gid, likewise. 4. Last access time, as a list of two integers. First integer has high-order 16 bits of time, second has low 16 bits. (See a note below about access time on FAT-based filesystems.) 5. Last modification time, likewise. This is the time of the last change to the file's contents. 6. Last status change time, likewise. This is the time of last change to the file's attributes: owner and group, access mode bits, etc. 7. Size in bytes. This is a floating point number if the size is too large for an integer. 8. File modes, as a string of ten letters or dashes as in ls -l. 9. t if file's gid would change if file were deleted and recreated. 10. inode number. If it is larger than what an Emacs integer can hold, this is of the form (HIGH . LOW): first the high bits, then the low 16 bits. If even HIGH is too large for an Emacs integer, this is instead of the form (HIGH MIDDLE . LOW): first the high bits, then the middle 24 bits, and finally the low 16 bits. 11. Filesystem device number. If it is larger than what the Emacs integer can hold, this is a cons cell, similar to the inode number.

On most filesystems, the combination of the inode and the device number uniquely identifies the file.

On MS-Windows, performance depends on `w32-get-true-file-attributes', which see.

On some FAT-based filesystems, only the date of last access is recorded, so last access time will always be midnight of that day.

Return a list of names of files in DIRECTORY. There are three optional arguments: If FULL is non-nil, return absolute file names. Otherwise return names that are relative to the specified directory. If MATCH is non-nil, mention only file names that match the regexp MATCH. If NOSORT is non-nil, the list is not sorted--its order is unpredictable. Otherwise, the list returned is sorted with `string-lessp'. NOSORT is useful if you plan to sort the result yourself.

Complete file name FILE in directory DIRECTORY. Returns the longest string common to all file names in DIRECTORY that start with FILE. If there is only one and FILE matches it exactly, returns t. Returns nil if DIRECTORY contains no name starting with FILE.

If PREDICATE is non-nil, call PREDICATE with each possible completion (in absolute form) and ignore it if PREDICATE returns nil.

This function ignores some of the possible completions as determined by the variable `completion-ignored-extensions', which see.

Return a list of all completions of file name FILE in directory DIRECTORY. These are all file names in directory DIRECTORY which begin with FILE.

Return t if first arg file attributes list is less than second. Comparison is in lexicographic order and case is significant.

Return a list of names of files and their attributes in DIRECTORY. There are four optional arguments: If FULL is non-nil, return absolute file names. Otherwise return names that are relative to the specified directory. If MATCH is non-nil, mention only file names that match the regexp MATCH. If NOSORT is non-nil, the list is not sorted--its order is unpredictable. NOSORT is useful if you plan to sort the result yourself. ID-FORMAT specifies the preferred format of attributes uid and gid, see `file-attributes' for further documentation. On MS-Windows, performance depends on `w32-get-true-file-attributes', which see.

Don't keep more than this much size of undo information. This limit is applied when garbage collection happens. When a previous command increases the total undo list size past this value, that command and the earlier commands that came before it are forgotten. However, the most recent buffer-modifying command's undo info is never discarded for this reason.

The size is counted as the number of bytes occupied, which includes both saved text and other data.

You can customize this variable.

Keep no more undo information once it exceeds this size. This limit is applied when garbage collection happens. When a previous command increases the total undo list size past this value, the earlier commands that came before it are forgotten.

The size is counted as the number of bytes occupied, which includes both saved text and other data.

You can customize this variable.

Outer limit on size of undo information for one command. At garbage collection time, if the current command has produced more than this much undo information, it discards the info and displays a warning. This is a last-ditch limit to prevent memory overflow.

The size is counted as the number of bytes occupied, which includes both saved text and other data. A value of nil means no limit. In this case, accumulating one huge undo entry could make Emacs crash as a result of memory overflow.

In fact, this calls the function which is the value of `undo-outer-limit-function' with one argument, the size. The text above describes the behavior of the function that variable usually specifies.

You can customize this variable.

Non-nil means do not record point' inbuffer-undo-list'.

Function to call when an undo list exceeds `undo-outer-limit'. This function is called with one argument, the current undo list size for the most recent command (since the last undo boundary). If the function returns t, that means truncation has been fully handled. If it returns nil, the other forms of truncation are done.

Garbage collection is inhibited around the call to this function, so it must make sure not to do a lot of consing.

Mark a boundary between units of undo. An undo command will stop at this point, but another undo command will undo to the previous boundary.

Undo N records from the front of the list LIST. Return what remains of the list.

Inhibit loading of charset maps. Used when dumping Emacs.

ISO639 language mnemonic symbol for the current language environment. If the current language environment is for multiple languages (e.g. "Latin-1"), the value may be a list of mnemonics.

List of all charsets ever defined.

*List of directories to search for charset map files.

You can customize this variable.

Sort charset list CHARSETS by a priority of each charset. Return the sorted list. CHARSETS is modified by side effects. See also charset-priority-list' andset-charset-priority'.

Return the property list of CHARSET.

Set CHARSET's property list to PLIST.

Return charset of a character in the current buffer at position POS. If POS is nil, it defaults to the current point. If POS is out of range, the value is nil.

For internal use only.

Define ALIAS as an alias for charset CHARSET.

Return non-nil if and only if OBJECT is a charset.

Encode the character CH into a code-point of CHARSET. Return nil if CHARSET doesn't include CH.

Optional argument RESTRICTION specifies a way to map CH to a code-point in CCS. Currently not supported and just ignored.

Internal use only. Return charset identification number of CHARSET.

Return list of charset and one to four position-codes of CH. The charset is decided by the current priority order of charsets. A position-code is a byte value of each dimension of the code-point of CH in the charset.

Return a list of charsets in the region between BEG and END. BEG and END are buffer positions. Optional arg TABLE if non-nil is a translation table to look up.

If the current buffer is unibyte, the returned list may contain only ascii',eight-bit-control', and `eight-bit-graphic'.

Unify characters of CHARSET with Unicode. This means reading the relevant file and installing the table defined by CHARSET's `:unify-map' property.

Optional second arg UNIFY-MAP is a file name string or a vector. It has the same meaning as the `:unify-map' attribute in the function `define-charset' (which see).

Optional third argument DEUNIFY, if non-nil, means to de-unify CHARSET.

Return a list of charsets in STR. Optional arg TABLE if non-nil is a translation table to look up.

If STR is unibyte, the returned list may contain only ascii',eight-bit-control', and `eight-bit-graphic'.

Assign higher priority to the charsets given as arguments.

Declare an equivalent charset for ISO-2022 decoding.

On decoding by an ISO-2022 base coding system, when a charset specified by DIMENSION, CHARS, and FINAL-CHAR is designated, behave as if CHARSET is designated instead.

Internal use only. Clear temporary charset mapping tables. It should be called only from temacs invoked for dumping.

Return an unused ISO final char for a charset of DIMENSION and CHARS. DIMENSION is the number of bytes to represent a character: 1 or 2. CHARS is the number of characters in a dimension: 94 or 96.

This final char is for private use, thus the range is 0' (48) ..?' (63). If there's no unused final char for the specified kind of charset, return nil.

Return the list of charsets ordered by priority. HIGHESTP non-nil means just return the highest priority one.

Call FUNCTION for all characters in CHARSET. FUNCTION is called with an argument RANGE and the optional 3rd argument ARG.

RANGE is a cons (FROM . TO), where FROM and TO indicate a range of characters contained in CHARSET.

The optional 4th and 5th arguments FROM-CODE and TO-CODE specify the range of code points (in CHARSET) of target characters.

Return a character of CHARSET whose position codes are CODEn.

CODE1 through CODE4 are optional, but if you don't supply sufficient position codes, it is assumed that the minimum code in each dimension is specified.

Return the charset of highest priority that contains CH. If optional 2nd arg RESTRICTION is non-nil, it is a list of charsets from which to find the charset. It may also be a coding system. In that case, find the charset from what supported by that coding system.

Decode the pair of CHARSET and CODE-POINT into a character. Return nil if CODE-POINT is not valid in CHARSET.

CODE-POINT may be a cons (HIGHER-16-BIT-VALUE . LOWER-16-BIT-VALUE).

Optional argument RESTRICTION specifies a way to map the pair of CCS and CODE-POINT to a character. Currently not supported and just ignored.

Return charset of ISO's specification DIMENSION, CHARS, and FINAL-CHAR.

ISO 2022's designation sequence (escape sequence) distinguishes charsets by their DIMENSION, CHARS, and FINAL-CHAR, whereas Emacs distinguishes them by charset symbol. See the documentation of the function `charset-info' for the meanings of DIMENSION, CHARS, and FINAL-CHAR.