-This is ../info/xemacs.info, produced by makeinfo version 4.0 from
+This is ../info/xemacs.info, produced by makeinfo version 4.0b from
xemacs/xemacs.texi.
INFO-DIR-SECTION XEmacs Editor
translation approved by the author instead of in the original English.
\1f
+File: xemacs.info, Node: Change Log, Next: Tags, Prev: Documentation, Up: Programs
+
+Change Logs
+===========
+
+ The Emacs command `M-x add-change-log-entry' helps you keep a record
+of when and why you have changed a program. It assumes that you have a
+file in which you write a chronological sequence of entries describing
+individual changes. The default is to store the change entries in a
+file called `ChangeLog' in the same directory as the file you are
+editing. The same `ChangeLog' file therefore records changes for all
+the files in a directory.
+
+ A change log entry starts with a header line that contains your name
+and the current date. Except for these header lines, every line in the
+change log starts with a tab. One entry can describe several changes;
+each change starts with a line starting with a tab and a star. `M-x
+add-change-log-entry' visits the change log file and creates a new entry
+unless the most recent entry is for today's date and your name. In
+either case, it adds a new line to start the description of another
+change just after the header line of the entry. When `M-x
+add-change-log-entry' is finished, all is prepared for you to edit in
+the description of what you changed and how. You must then save the
+change log file yourself.
+
+ The change log file is always visited in Indented Text mode, which
+means that <LFD> and auto-filling indent each new line like the previous
+line. This is convenient for entering the contents of an entry, which
+must be indented. *Note Text Mode::.
+
+ Here is an example of the formatting conventions used in the change
+log for Emacs:
+
+ Wed Jun 26 19:29:32 1985 Richard M. Stallman (rms at mit-prep)
+
+ * xdisp.c (try_window_id):
+ If C-k is done at end of next-to-last line,
+ this fn updates window_end_vpos and cannot leave
+ window_end_pos nonnegative (it is zero, in fact).
+ If display is preempted before lines are output,
+ this is inconsistent. Fix by setting
+ blank_end_of_window to nonzero.
+
+ Tue Jun 25 05:25:33 1985 Richard M. Stallman (rms at mit-prep)
+
+ * cmds.c (Fnewline):
+ Call the auto fill hook if appropriate.
+
+ * xdisp.c (try_window_id):
+ If point is found by compute_motion after xp, record that
+ permanently. If display_text_line sets point position wrong
+ (case where line is killed, point is at eob and that line is
+ not displayed), set it again in final compute_motion.
+
+\1f
+File: xemacs.info, Node: Tags, Next: Fortran, Prev: Change Log, Up: Programs
+
+Tags Tables
+===========
+
+ A "tags table" is a description of how a multi-file program is
+broken up into files. It lists the names of the component files and the
+names and positions of the functions (or other named subunits) in each
+file. Grouping the related files makes it possible to search or replace
+through all the files with one command. Recording the function names
+and positions makes possible the `M-.' command which finds the
+definition of a function by looking up which of the files it is in.
+
+ Tags tables are stored in files called "tags table files". The
+conventional name for a tags table file is `TAGS'.
+
+ Each entry in the tags table records the name of one tag, the name
+of the file that the tag is defined in (implicitly), and the position
+in that file of the tag's definition.
+
+ Just what names from the described files are recorded in the tags
+table depends on the programming language of the described file. They
+normally include all functions and subroutines, and may also include
+global variables, data types, and anything else convenient. Each name
+recorded is called a "tag".
+
+ The Ebrowse is a separate facility tailored for C++, with tags and a
+class browser. *Note : (ebrowse).
+
+* Menu:
+
+* Tag Syntax:: Tag syntax for various types of code and text files.
+* Create Tags Table:: Creating a tags table with `etags'.
+* Etags Regexps:: Create arbitrary tags using regular expressions.
+* Select Tags Table:: How to visit a tags table.
+* Find Tag:: Commands to find the definition of a specific tag.
+* Tags Search:: Using a tags table for searching and replacing.
+* List Tags:: Listing and finding tags defined in a file.
+
+\1f
+File: xemacs.info, Node: Tag Syntax, Next: Create Tags Table, Up: Tags
+
+Source File Tag Syntax
+----------------------
+
+ Here is how tag syntax is defined for the most popular languages:
+
+ * In C code, any C function or typedef is a tag, and so are
+ definitions of `struct', `union' and `enum'. You can tag function
+ declarations and external variables in addition to function
+ definitions by giving the `--declarations' option to `etags'.
+ `#define' macro definitions and `enum' constants are also tags,
+ unless you specify `--no-defines' when making the tags table.
+ Similarly, global variables are tags, unless you specify
+ `--no-globals'. Use of `--no-globals' and `--no-defines' can make
+ the tags table file much smaller.
+
+ * In C++ code, in addition to all the tag constructs of C code,
+ member functions are also recognized, and optionally member
+ variables if you use the `--members' option. Tags for variables
+ and functions in classes are named `CLASS::VARIABLE' and
+ `CLASS::FUNCTION'. `operator' functions tags are named, for
+ example `operator+'.
+
+ * In Java code, tags include all the constructs recognized in C++,
+ plus the `interface', `extends' and `implements' constructs. Tags
+ for variables and functions in classes are named `CLASS.VARIABLE'
+ and `CLASS.FUNCTION'.
+
+ * In LaTeX text, the argument of any of the commands `\chapter',
+ `\section', `\subsection', `\subsubsection', `\eqno', `\label',
+ `\ref', `\cite', `\bibitem', `\part', `\appendix', `\entry', or
+ `\index', is a tag.
+
+ Other commands can make tags as well, if you specify them in the
+ environment variable `TEXTAGS' before invoking `etags'. The value
+ of this environment variable should be a colon-separated list of
+ command names. For example,
+
+ TEXTAGS="def:newcommand:newenvironment"
+ export TEXTAGS
+
+ specifies (using Bourne shell syntax) that the commands `\def',
+ `\newcommand' and `\newenvironment' also define tags.
+
+ * In Lisp code, any function defined with `defun', any variable
+ defined with `defvar' or `defconst', and in general the first
+ argument of any expression that starts with `(def' in column zero,
+ is a tag.
+
+ * In Scheme code, tags include anything defined with `def' or with a
+ construct whose name starts with `def'. They also include
+ variables set with `set!' at top level in the file.
+
+ Several other languages are also supported:
+
+ * In Ada code, functions, procedures, packages, tasks, and types are
+ tags. Use the `--packages-only' option to create tags for
+ packages only.
+
+ With Ada, it is possible to have the same name used for different
+ entity kinds (e.g. the same name for a procedure and a function).
+ Also, for things like packages, procedures and functions, there is
+ the spec (i.e. the interface) and the body (i.e. the
+ implementation). To facilitate the choice to the user, a tag
+ value is appended with a qualifier:
+
+ function
+ `/f'
+
+ procedure
+ `/p'
+
+ package spec
+ `/s'
+
+ package body
+ `/b'
+
+ type
+ `/t'
+
+ task
+ `/k'
+
+ So, as an example, `M-x find-tag bidule/b' will go directly to the
+ body of the package BIDULE while `M-x find-tag bidule' will just
+ search for any tag BIDULE.
+
+ * In assembler code, labels appearing at the beginning of a line,
+ followed by a colon, are tags.
+
+ * In Bison or Yacc input files, each rule defines as a tag the
+ nonterminal it constructs. The portions of the file that contain
+ C code are parsed as C code.
+
+ * In Cobol code, tags are paragraph names; that is, any word
+ starting in column 8 and followed by a period.
+
+ * In Erlang code, the tags are the functions, records, and macros
+ defined in the file.
+
+ * In Fortran code, functions, subroutines and blockdata are tags.
+
+ * In makefiles, targets are tags.
+
+ * In Objective C code, tags include Objective C definitions for
+ classes, class categories, methods, and protocols.
+
+ * In Pascal code, the tags are the functions and procedures defined
+ in the file.
+
+ * In Perl code, the tags are the procedures defined by the `sub',
+ `my' and `local' keywords. Use `--globals' if you want to tag
+ global variables.
+
+ * In PostScript code, the tags are the functions.
+
+ * In Prolog code, a tag name appears at the left margin.
+
+ * In Python code, `def' or `class' at the beginning of a line
+ generate a tag.
+
+ You can also generate tags based on regexp matching (*note Etags
+Regexps::) to handle other formats and languages.
+
+\1f
+File: xemacs.info, Node: Create Tags Table, Next: Etags Regexps, Prev: Tag Syntax, Up: Tags
+
+Creating Tags Tables
+--------------------
+
+ The `etags' program is used to create a tags table file. It knows
+the syntax of several languages, as described in *Note Tag Syntax::.
+Here is how to run `etags':
+
+ etags INPUTFILES...
+
+The `etags' program reads the specified files, and writes a tags table
+named `TAGS' in the current working directory. You can intermix
+compressed and plain text source file names. `etags' knows about the
+most common compression formats, and does the right thing. So you can
+compress all your source files and have `etags' look for compressed
+versions of its file name arguments, if it does not find uncompressed
+versions. Under MS-DOS, `etags' also looks for file names like
+`mycode.cgz' if it is given `mycode.c' on the command line and
+`mycode.c' does not exist.
+
+ `etags' recognizes the language used in an input file based on its
+file name and contents. You can specify the language with the
+`--language=NAME' option, described below.
+
+ If the tags table data become outdated due to changes in the files
+described in the table, the way to update the tags table is the same
+way it was made in the first place. It is not necessary to do this
+often.
+
+ If the tags table fails to record a tag, or records it for the wrong
+file, then Emacs cannot possibly find its definition. However, if the
+position recorded in the tags table becomes a little bit wrong (due to
+some editing in the file that the tag definition is in), the only
+consequence is a slight delay in finding the tag. Even if the stored
+position is very wrong, Emacs will still find the tag, but it must
+search the entire file for it.
+
+ So you should update a tags table when you define new tags that you
+want to have listed, or when you move tag definitions from one file to
+another, or when changes become substantial. Normally there is no need
+to update the tags table after each edit, or even every day.
+
+ One tags table can effectively include another. Specify the included
+tags file name with the `--include=FILE' option when creating the file
+that is to include it. The latter file then acts as if it contained
+all the files specified in the included file, as well as the files it
+directly contains.
+
+ If you specify the source files with relative file names when you run
+`etags', the tags file will contain file names relative to the
+directory where the tags file was initially written. This way, you can
+move an entire directory tree containing both the tags file and the
+source files, and the tags file will still refer correctly to the source
+files.
+
+ If you specify absolute file names as arguments to `etags', then the
+tags file will contain absolute file names. This way, the tags file
+will still refer to the same files even if you move it, as long as the
+source files remain in the same place. Absolute file names start with
+`/', or with `DEVICE:/' on MS-DOS and MS-Windows.
+
+ When you want to make a tags table from a great number of files, you
+may have problems listing them on the command line, because some systems
+have a limit on its length. The simplest way to circumvent this limit
+is to tell `etags' to read the file names from its standard input, by
+typing a dash in place of the file names, like this:
+
+ find . -name "*.[chCH]" -print | etags -
+
+ Use the option `--language=NAME' to specify the language explicitly.
+You can intermix these options with file names; each one applies to
+the file names that follow it. Specify `--language=auto' to tell
+`etags' to resume guessing the language from the file names and file
+contents. Specify `--language=none' to turn off language-specific
+processing entirely; then `etags' recognizes tags by regexp matching
+alone (*note Etags Regexps::).
+
+ `etags --help' prints the list of the languages `etags' knows, and
+the file name rules for guessing the language. It also prints a list of
+all the available `etags' options, together with a short explanation.
+
+\1f
+File: xemacs.info, Node: Etags Regexps, Next: Select Tags Table, Prev: Create Tags Table, Up: Tags
+
+Etags Regexps
+-------------
+
+ The `--regex' option provides a general way of recognizing tags
+based on regexp matching. You can freely intermix it with file names.
+Each `--regex' option adds to the preceding ones, and applies only to
+the following files. The syntax is:
+
+ --regex=/TAGREGEXP[/NAMEREGEXP]/
+
+where TAGREGEXP is used to match the lines to tag. It is always
+anchored, that is, it behaves as if preceded by `^'. If you want to
+account for indentation, just match any initial number of blanks by
+beginning your regular expression with `[ \t]*'. In the regular
+expressions, `\' quotes the next character, and `\t' stands for the tab
+character. Note that `etags' does not handle the other C escape
+sequences for special characters.
+
+ The syntax of regular expressions in `etags' is the same as in
+Emacs, augmented with the "interval operator", which works as in `grep'
+and `ed'. The syntax of an interval operator is `\{M,N\}', and its
+meaning is to match the preceding expression at least M times and up to
+N times.
+
+ You should not match more characters with TAGREGEXP than that needed
+to recognize what you want to tag. If the match is such that more
+characters than needed are unavoidably matched by TAGREGEXP (as will
+usually be the case), you should add a NAMEREGEXP, to pick out just the
+tag. This will enable Emacs to find tags more accurately and to do
+completion on tag names more reliably. You can find some examples
+below.
+
+ The option `--ignore-case-regex' (or `-c') is like `--regex', except
+that the regular expression provided will be matched without regard to
+case, which is appropriate for various programming languages.
+
+ The `-R' option deletes all the regexps defined with `--regex'
+options. It applies to the file names following it, as you can see
+from the following example:
+
+ etags --regex=/REG1/ voo.doo --regex=/REG2/ \
+ bar.ber -R --lang=lisp los.er
+
+Here `etags' chooses the parsing language for `voo.doo' and `bar.ber'
+according to their contents. `etags' also uses REG1 to recognize
+additional tags in `voo.doo', and both REG1 and REG2 to recognize
+additional tags in `bar.ber'. `etags' uses the Lisp tags rules, and no
+regexp matching, to recognize tags in `los.er'.
+
+ A regular expression can be bound to a given language, by prepending
+it with `{lang}'. When you do this, `etags' will use the regular
+expression only for files of that language. `etags --help' prints the
+list of languages recognised by `etags'. The following example tags
+the `DEFVAR' macros in the Emacs source files. `etags' applies this
+regular expression to C files only:
+
+ --regex='{c}/[ \t]*DEFVAR_[A-Z_ \t(]+"\([^"]+\)"/'
+
+This feature is particularly useful when storing a list of regular
+expressions in a file. The following option syntax instructs `etags'
+to read two files of regular expressions. The regular expressions
+contained in the second file are matched without regard to case.
+
+ --regex=@first-file --ignore-case-regex=@second-file
+
+A regex file contains one regular expressions per line. Empty lines,
+and lines beginning with space or tab are ignored. When the first
+character in a line is `@', `etags' assumes that the rest of the line
+is the name of a file of regular expressions. This means that such
+files can be nested. All the other lines are taken to be regular
+expressions. For example, one can create a file called `emacs.tags'
+with the following contents (the first line in the file is a comment):
+
+ -- This is for GNU Emacs source files
+ {c}/[ \t]*DEFVAR_[A-Z_ \t(]+"\([^"]+\)"/\1/
+
+and then use it like this:
+
+ etags --regex=@emacs.tags *.[ch] */*.[ch]
+
+ Here are some more examples. The regexps are quoted to protect them
+from shell interpretation.
+
+ * Tag Octave files:
+
+ etags --language=none \
+ --regex='/[ \t]*function.*=[ \t]*\([^ \t]*\)[ \t]*(/\1/' \
+ --regex='/###key \(.*\)/\1/' \
+ --regex='/[ \t]*global[ \t].*/' \
+ *.m
+
+ Note that tags are not generated for scripts so that you have to
+ add a line by yourself of the form `###key <script-name>' if you
+ want to jump to it.
+
+ * Tag Tcl files:
+
+ etags --language=none --regex='/proc[ \t]+\([^ \t]+\)/\1/' *.tcl
+
+ * Tag VHDL files:
+
+ --language=none \
+ --regex='/[ \t]*\(ARCHITECTURE\|CONFIGURATION\) +[^ ]* +OF/' \
+ --regex='/[ \t]*\(ATTRIBUTE\|ENTITY\|FUNCTION\|PACKAGE\
+ \( BODY\)?\|PROCEDURE\|PROCESS\|TYPE\)[ \t]+\([^ \t(]+\)/\3/'
+
+\1f
+File: xemacs.info, Node: Select Tags Table, Next: Find Tag, Prev: Etags Regexps, Up: Tags
+
+Selecting a Tags Table
+----------------------
+
+ At any time Emacs has one "selected" tags table, and all the commands
+for working with tags tables use the selected one. To select a tags
+table, use the variable `tag-table-alist'.
+
+ The value of `tag-table-alist' is a list that determines which
+`TAGS' files should be active for a given buffer. This is not really
+an association list, in that all elements are checked. The car of each
+element of this list is a pattern against which the buffers file name
+is compared; if it matches, then the cdr of the list should be the name
+of the tags table to use. If more than one element of this list
+matches the buffers file name, all of the associated tags tables are
+used. Earlier ones are searched first.
+
+ If the car of elements of this list are strings, they are treated as
+regular-expressions against which the file is compared (like the
+`auto-mode-alist'). If they are not strings, they are evaluated. If
+they evaluate to non-`nil', the current buffer is considered to match.
+
+ If the cdr of the elements of this list are strings, they are
+assumed to name a tags file. If they name a directory, the string
+`tags' is appended to them to get the file name. If they are not
+strings, they are evaluated and must return an appropriate string.
+
+ For example:
+
+ (setq tag-table-alist
+ '(("/usr/src/public/perl/" . "/usr/src/public/perl/perl-3.0/")
+ ("\\.el$" . "/usr/local/emacs/src/")
+ ("/jbw/gnu/" . "/usr15/degree/stud/jbw/gnu/")
+ ("" . "/usr/local/emacs/src/")
+ ))
+
+ The example defines the tags table alist in the following way:
+
+ * Anything in the directory `/usr/src/public/perl/' should use the
+ `TAGS' file `/usr/src/public/perl/perl-3.0/TAGS'.
+
+ * Files ending in `.el' should use the `TAGS' file
+ `/usr/local/emacs/src/TAGS'.
+
+ * Anything in or below the directory `/jbw/gnu/' should use the
+ `TAGS' file `/usr15/degree/stud/jbw/gnu/TAGS'.
+
+ If you had a file called `/usr/jbw/foo.el', it would use both `TAGS'
+files,
+`/usr/local/emacs/src/TAGS' and `/usr15/degree/stud/jbw/gnu/TAGS' (in
+that order), because it matches both patterns.
+
+ If the buffer-local variable `buffer-tag-table' is set, it names a
+tags table that is searched before all others when `find-tag' is
+executed from this buffer.
+
+ If there is a file called `TAGS' in the same directory as the file
+in question, then that tags file will always be used as well (after the
+`buffer-tag-table' but before the tables specified by this list).
+
+ If the variable `tags-file-name' is set, the `TAGS' file it names
+will apply to all buffers (for backwards compatibility.) It is searched
+first.
+
+ If the value of the variable `tags-always-build-completion-table' is
+`t', the tags file will always be added to the completion table without
+asking first, regardless of the size of the tags file.
+
+ The function `M-x visit-tags-table', is largely made obsolete by the
+variable `tag-table-alist', tells tags commands to use the tags table
+file FILE first. The FILE should be the name of a file created with
+the `etags' program. A directory name is also acceptable; it means the
+file `TAGS' in that directory. The function only stores the file name
+you provide in the variable `tags-file-name'. Emacs does not actually
+read in the tags table contents until you try to use them. You can set
+the variable explicitly instead of using `visit-tags-table'. The value
+of the variable `tags-file-name' is the name of the tags table used by
+all buffers. This is for backward compatibility, and is largely
+supplanted by the variable `tag-table-alist'.
+
+\1f
+File: xemacs.info, Node: Find Tag, Next: Tags Search, Prev: Select Tags Table, Up: Tags
+
+Finding a Tag
+-------------
+
+ The most important thing that a tags table enables you to do is to
+find the definition of a specific tag.
+
+`M-. TAG &OPTIONAL OTHER-WINDOW'
+ Find first definition of TAG (`find-tag').
+
+`C-u M-.'
+ Find next alternate definition of last tag specified.
+
+`C-x 4 . TAG'
+ Find first definition of TAG, but display it in another window
+ (`find-tag-other-window').
+
+ `M-.' (`find-tag') is the command to find the definition of a
+specified tag. It searches through the tags table for that tag, as a
+string, then uses the tags table information to determine the file in
+which the definition is used and the approximate character position of
+the definition in the file. Then `find-tag' visits the file, moves
+point to the approximate character position, and starts searching
+ever-increasing distances away for the text that should appear at the
+beginning of the definition.
+
+ If an empty argument is given (by typing <RET>), the sexp in the
+buffer before or around point is used as the name of the tag to find.
+*Note Lists::, for information on sexps.
+
+ The argument to `find-tag' need not be the whole tag name; it can be
+a substring of a tag name. However, there can be many tag names
+containing the substring you specify. Since `find-tag' works by
+searching the text of the tags table, it finds the first tag in the
+table that the specified substring appears in. To find other tags that
+match the substring, give `find-tag' a numeric argument, as in `C-u
+M-.'. This does not read a tag name, but continues searching the tag
+table's text for another tag containing the same substring last used.
+If your keyboard has a real <META> key, `M-0 M-.' is an easier
+alternative to `C-u M-.'.
+
+ If the optional second argument OTHER-WINDOW is non-`nil', it uses
+another window to display the tag. Multiple active tags tables and
+completion are supported.
+
+ Variables of note include the following:
+
+`tag-table-alist'
+ Controls which tables apply to which buffers.
+
+`tags-file-name'
+ Stores a default tags table.
+
+`tags-build-completion-table'
+ Controls completion behavior.
+
+`buffer-tag-table'
+ Specifies a buffer-local table.
+
+`make-tags-files-invisible'
+ Sets whether tags tables should be very hidden.
+
+`tag-mark-stack-max'
+ Specifies how many tags-based hops to remember.
+
+ Like most commands that can switch buffers, `find-tag' has another
+similar command that displays the new buffer in another window. `C-x 4
+.' invokes the function `find-tag-other-window'. (This key sequence
+ends with a period.)
+
+ Emacs comes with a tags table file `TAGS' (in the directory
+containing Lisp libraries) that includes all the Lisp libraries and all
+the C sources of Emacs. By specifying this file with `visit-tags-table'
+and then using `M-.' you can quickly look at the source of any Emacs
+function.
+
+\1f
File: xemacs.info, Node: Tags Search, Next: List Tags, Prev: Find Tag, Up: Tags
Searching and Replacing with Tags Tables
comments in assembler syntax.
\1f
-File: xemacs.info, Node: Running, Next: Packages, Prev: Programs, Up: Top
+File: xemacs.info, Node: Running, Next: Abbrevs, Prev: Programs, Up: Top
Compiling and Testing Programs
******************************
compilation is finished. You do not have to keep this buffer visible;
compilation continues in any case.
- To kill the compilation process, type `M-x-kill-compilation'. The
+ To kill the compilation process, type `M-x kill-compilation'. The
mode line of the `*compilation*' buffer changes to say `signal' instead
of `run'. Starting a new compilation also kills any running
compilation, as only one can occur at any time. Starting a new
The mode for an interactive session with an inferior Scheme
process.
-\1f
-File: xemacs.info, Node: Lisp Libraries, Next: Lisp Eval, Prev: Lisp Modes, Up: Running
-
-Libraries of Lisp Code for Emacs
-================================
-
- Lisp code for Emacs editing commands is stored in files whose names
-conventionally end in `.el'. This ending tells Emacs to edit them in
-Emacs-Lisp mode (*note Lisp Modes::).
-
-* Menu:
-
-* Loading:: Loading libraries of Lisp code into Emacs for use.
-* Compiling Libraries:: Compiling a library makes it load and run faster.
-* Mocklisp:: Converting Mocklisp to Lisp so XEmacs can run it.
-
-\1f
-File: xemacs.info, Node: Loading, Next: Compiling Libraries, Prev: Lisp Libraries, Up: Lisp Libraries
-
-Loading Libraries
------------------
-
-`M-x load-file FILE'
- Load the file FILE of Lisp code.
-
-`M-x load-library LIBRARY'
- Load the library named LIBRARY.
-
-`M-x locate-library LIBRARY &optional NOSUFFIX'
- Show the full path name of Emacs library LIBRARY.
-
- To execute a file of Emacs Lisp, use `M-x load-file'. This command
-reads the file name you provide in the minibuffer, then executes the
-contents of that file as Lisp code. It is not necessary to visit the
-file first; in fact, this command reads the file as found on disk, not
-the text in an Emacs buffer.
-
- Once a file of Lisp code is installed in the Emacs Lisp library
-directories, users can load it using `M-x load-library'. Programs can
-load it by calling `load-library', or with `load', a more primitive
-function that is similar but accepts some additional arguments.
-
- `M-x load-library' differs from `M-x load-file' in that it searches
-a sequence of directories and tries three file names in each directory.
-The three names are: first, the specified name with `.elc' appended;
-second, the name with `.el' appended; third, the specified name alone.
-A `.elc' file would be the result of compiling the Lisp file into byte
-code; if possible, it is loaded in preference to the Lisp file itself
-because the compiled file loads and runs faster.
-
- Because the argument to `load-library' is usually not in itself a
-valid file name, file name completion is not available. In fact, when
-using this command, you usually do not know exactly what file name will
-be used.
-
- The sequence of directories searched by `M-x load-library' is
-specified by the variable `load-path', a list of strings that are
-directory names. The elements of this list may not begin with "`~'",
-so you must call `expand-file-name' on them before adding them to the
-list. The default value of the list contains the directory where the
-Lisp code for Emacs itself is stored. If you have libraries of your
-own, put them in a single directory and add that directory to
-`load-path'. `nil' in this list stands for the current default
-directory, but it is probably not a good idea to put `nil' in the list.
-If you start wishing that `nil' were in the list, you should probably
-use `M-x load-file' for this case.
-
- The variable is initialized by the EMACSLOADPATH environment
-variable. If no value is specified, the variable takes the default value
-specified in the file `paths.h' when Emacs was built. If a path isn't
-specified in `paths.h', a default value is obtained from the file
-system, near the directory in which the Emacs executable resides.
-
- Like `M-x load-library', `M-x locate-library' searches the
-directories in `load-path' to find the file that `M-x load-library'
-would load. If the optional second argument NOSUFFIX is non-`nil', the
-suffixes `.elc' or `.el' are not added to the specified name LIBRARY
-(like calling `load' instead of `load-library').
-
- You often do not have to give any command to load a library, because
-the commands defined in the library are set up to "autoload" that
-library. Running any of those commands causes `load' to be called to
-load the library; this replaces the autoload definitions with the real
-ones from the library.
-
- If autoloading a file does not finish, either because of an error or
-because of a `C-g' quit, all function definitions made by the file are
-undone automatically. So are any calls to `provide'. As a
-consequence, the entire file is loaded a second time if you use one of
-the autoloadable commands again. This prevents problems when the
-command is no longer autoloading but is working incorrectly because the
-file was only partially loaded. Function definitions are undone only
-for autoloading; explicit calls to `load' do not undo anything if
-loading is not completed.
-
- The variable `after-load-alist' takes an alist of expressions to be
-evaluated when particular files are loaded. Each element has the form
-`(FILENAME forms...)'. When `load' is run and the filename argument is
-FILENAME, the forms in the corresponding element are executed at the
-end of loading.
-
- FILENAME must match exactly. Normally FILENAME is the name of a
-library, with no directory specified, since that is how load is
-normally called. An error in `forms' does not undo the load, but it
-does prevent execution of the rest of the `forms'.
-
-\1f
-File: xemacs.info, Node: Compiling Libraries, Next: Mocklisp, Prev: Loading, Up: Lisp Libraries
-
-Compiling Libraries
--------------------
-
- Emacs Lisp code can be compiled into byte-code which loads faster,
-takes up less space when loaded, and executes faster.
-
-`M-x batch-byte-compile'
- Run byte-compile-file on the files remaining on the command line.
-
-`M-x byte-compile-buffer &optional BUFFER'
- Byte-compile and evaluate contents of BUFFER (default is current
- buffer).
-
-`M-x byte-compile-file'
- Compile a file of Lisp code named FILENAME into a file of byte
- code.
-
-`M-x byte-compile-and-load-file FILENAME'
- Compile a file of Lisp code named FILENAME into a file of byte
- code and load it.
-
-`M-x byte-recompile-directory DIRECTORY'
- Recompile every `.el' file in DIRECTORY that needs recompilation.
-
-`M-x disassemble'
- Print disassembled code for OBJECT on (optional) STREAM.
-
-`M-x make-obsolete FUNCTION NEW'
- Make the byte-compiler warn that FUNCTION is obsolete and NEW
- should be used instead.
-
- `byte-compile-file' creates a byte-code compiled file from an
-Emacs-Lisp source file. The default argument for this function is the
-file visited in the current buffer. The function reads the specified
-file, compiles it into byte code, and writes an output file whose name
-is made by appending `c' to the input file name. Thus, the file
-`rmail.el' would be compiled into `rmail.elc'. To compile a file of
-Lisp code named FILENAME into a file of byte code and then load it, use
-`byte-compile-and-load-file'. To compile and evaluate Lisp code in a
-given buffer, use `byte-compile-buffer'.
-
- To recompile all changed Lisp files in a directory, use `M-x
-byte-recompile-directory'. Specify just the directory name as an
-argument. Each `.el' file that has been byte-compiled before is
-byte-compiled again if it has changed since the previous compilation.
-A numeric argument to this command tells it to offer to compile each
-`.el' file that has not been compiled yet. You must answer `y' or `n'
-to each offer.
-
- You can use the function `batch-byte-compile' to invoke Emacs
-non-interactively from the shell to do byte compilation. When you use
-this function, the files to be compiled are specified with command-line
-arguments. Use a shell command of the form:
-
- emacs -batch -f batch-byte-compile FILES...
-
- Directory names may also be given as arguments; in that case,
-`byte-recompile-directory' is invoked on each such directory.
-`batch-byte-compile' uses all remaining command-line arguments as file
-or directory names, then kills the Emacs process.
-
- `M-x disassemble' explains the result of byte compilation. Its
-argument is a function name. It displays the byte-compiled code in a
-help window in symbolic form, one instruction per line. If the
-instruction refers to a variable or constant, that is shown, too.
-
-\1f
-File: xemacs.info, Node: Mocklisp, Prev: Compiling Libraries, Up: Lisp Libraries
-
-Converting Mocklisp to Lisp
----------------------------
-
- XEmacs can run Mocklisp files by converting them to Emacs Lisp first.
-To convert a Mocklisp file, visit it and then type `M-x
-convert-mocklisp-buffer'. Then save the resulting buffer of Lisp file
-in a file whose name ends in `.el' and use the new file as a Lisp
-library.
-
- You cannot currently byte-compile converted Mocklisp code. The
-reason is that converted Mocklisp code uses some special Lisp features
-to deal with Mocklisp's incompatible ideas of how arguments are
-evaluated and which values signify "true" or "false".
-
-\1f
-File: xemacs.info, Node: Lisp Eval, Next: Lisp Debug, Prev: Lisp Libraries, Up: Running
-
-Evaluating Emacs-Lisp Expressions
-=================================
-
- Lisp programs intended to be run in Emacs should be edited in
-Emacs-Lisp mode; this will happen automatically for file names ending in
-`.el'. By contrast, Lisp mode itself should be used for editing Lisp
-programs intended for other Lisp systems. Emacs-Lisp mode can be
-selected with the command `M-x emacs-lisp-mode'.
-
- For testing of Lisp programs to run in Emacs, it is useful to be able
-to evaluate part of the program as it is found in the Emacs buffer. For
-example, if you change the text of a Lisp function definition and then
-evaluate the definition, Emacs installs the change for future calls to
-the function. Evaluation of Lisp expressions is also useful in any
-kind of editing task for invoking non-interactive functions (functions
-that are not commands).
-
-`M-<ESC>'
- Read a Lisp expression in the minibuffer, evaluate it, and print
- the value in the minibuffer (`eval-expression').
-
-`C-x C-e'
- Evaluate the Lisp expression before point, and print the value in
- the minibuffer (`eval-last-sexp').
-
-`C-M-x'
- Evaluate the defun containing point or after point, and print the
- value in the minibuffer (`eval-defun').
-
-`M-x eval-region'
- Evaluate all the Lisp expressions in the region.
-
-`M-x eval-current-buffer'
- Evaluate all the Lisp expressions in the buffer.
-
- `M-<ESC>' (`eval-expression') is the most basic command for
-evaluating a Lisp expression interactively. It reads the expression
-using the minibuffer, so you can execute any expression on a buffer
-regardless of what the buffer contains. When evaluation is complete,
-the current buffer is once again the buffer that was current when
-`M-<ESC>' was typed.
-
- `M-<ESC>' can easily confuse users, especially on keyboards with
-autorepeat, where it can result from holding down the <ESC> key for too
-long. Therefore, `eval-expression' is normally a disabled command.
-Attempting to use this command asks for confirmation and gives you the
-option of enabling it; once you enable the command, you are no longer
-required to confirm. *Note Disabling::.
-
- In Emacs-Lisp mode, the key `C-M-x' is bound to the function
-`eval-defun', which parses the defun containing point or following point
-as a Lisp expression and evaluates it. The value is printed in the echo
-area. This command is convenient for installing in the Lisp environment
-changes that you have just made in the text of a function definition.
-
- The command `C-x C-e' (`eval-last-sexp') performs a similar job but
-is available in all major modes, not just Emacs-Lisp mode. It finds
-the sexp before point, reads it as a Lisp expression, evaluates it, and
-prints the value in the echo area. It is sometimes useful to type in an
-expression and then, with point still after it, type `C-x C-e'.
-
- If `C-M-x' or `C-x C-e' are given a numeric argument, they print the
-value by inserting it into the current buffer at point, rather than in
-the echo area. The argument value does not matter.
-
- The most general command for evaluating Lisp expressions from a
-buffer is `eval-region'. `M-x eval-region' parses the text of the
-region as one or more Lisp expressions, evaluating them one by one.
-`M-x eval-current-buffer' is similar, but it evaluates the entire
-buffer. This is a reasonable way to install the contents of a file of
-Lisp code that you are just ready to test. After finding and fixing a
-bug, use `C-M-x' on each function that you change, to keep the Lisp
-world in step with the source file.
-
-\1f
-File: xemacs.info, Node: Lisp Debug, Next: Lisp Interaction, Prev: Lisp Eval, Up: Running
-
-The Emacs-Lisp Debugger
-=======================
-
- XEmacs contains a debugger for Lisp programs executing inside it.
-This debugger is normally not used; many commands frequently get Lisp
-errors when invoked in inappropriate contexts (such as `C-f' at the end
-of the buffer) and it would be unpleasant to enter a special debugging
-mode in this case. When you want to make Lisp errors invoke the
-debugger, you must set the variable `debug-on-error' to non-`nil'.
-Quitting with `C-g' is not considered an error, and `debug-on-error'
-has no effect on the handling of `C-g'. However, if you set
-`debug-on-quit' to be non-`nil', `C-g' will invoke the debugger. This
-can be useful for debugging an infinite loop; type `C-g' once the loop
-has had time to reach its steady state. `debug-on-quit' has no effect
-on errors.
-
- You can make Emacs enter the debugger when a specified function is
-called or at a particular place in Lisp code. Use `M-x debug-on-entry'
-with argument FUN-NAME to have Emacs enter the debugger as soon as
-FUN-NAME is called. Use `M-x cancel-debug-on-entry' to make the
-function stop entering the debugger when called. (Redefining the
-function also does this.) To enter the debugger from some other place
-in Lisp code, you must insert the expression `(debug)' there and
-install the changed code with `C-M-x'. *Note Lisp Eval::.
-
- When the debugger is entered, it displays the previously selected
-buffer in one window and a buffer named `*Backtrace*' in another
-window. The backtrace buffer contains one line for each level of Lisp
-function execution currently going on. At the beginning of the buffer
-is a message describing the reason that the debugger was invoked, for
-example, an error message if it was invoked due to an error.
-
- The backtrace buffer is read-only and is in Backtrace mode, a special
-major mode in which letters are defined as debugger commands. The
-usual Emacs editing commands are available; you can switch windows to
-examine the buffer that was being edited at the time of the error, and
-you can switch buffers, visit files, and perform any other editing
-operations. However, the debugger is a recursive editing level (*note
-Recursive Edit::); it is a good idea to return to the backtrace buffer
-and explicitly exit the debugger when you don't want to use it any
-more. Exiting the debugger kills the backtrace buffer.
-
- The contents of the backtrace buffer show you the functions that are
-executing and the arguments that were given to them. It also allows you
-to specify a stack frame by moving point to the line describing that
-frame. The frame whose line point is on is considered the "current
-frame". Some of the debugger commands operate on the current frame.
-Debugger commands are mainly used for stepping through code one
-expression at a time. Here is a list of them:
-
-`c'
- Exit the debugger and continue execution. In most cases,
- execution of the program continues as if the debugger had never
- been entered (aside from the effect of any variables or data
- structures you may have changed while inside the debugger). This
- includes entry to the debugger due to function entry or exit,
- explicit invocation, and quitting or certain errors. Most errors
- cannot be continued; trying to continue an error usually causes
- the same error to occur again.
-
-`d'
- Continue execution, but enter the debugger the next time a Lisp
- function is called. This allows you to step through the
- subexpressions of an expression, and see what the subexpressions
- do and what values they compute.
-
- When you enter the debugger this way, Emacs flags the stack frame
- for the function call from which you entered. The same function
- is then called when you exit the frame. To cancel this flag, use
- `u'.
-
-`b'
- Set up to enter the debugger when the current frame is exited.
- Frames that invoke the debugger on exit are flagged with stars.
-
-`u'
- Don't enter the debugger when the current frame is exited. This
- cancels a `b' command on a frame.
-
-`e'
- Read a Lisp expression in the minibuffer, evaluate it, and print
- the value in the echo area. This is equivalent to the command
- `M-<ESC>', except that `e' is not normally disabled like `M-<ESC>'.
-
-`q'
- Terminate the program being debugged; return to top-level Emacs
- command execution.
-
- If the debugger was entered due to a `C-g' but you really want to
- quit, not to debug, use the `q' command.
-
-`r'
- Return a value from the debugger. The value is computed by
- reading an expression with the minibuffer and evaluating it.
-
- The value returned by the debugger makes a difference when the
- debugger was invoked due to exit from a Lisp call frame (as
- requested with `b'); then the value specified in the `r' command
- is used as the value of that frame.
-
- The debugger's return value also matters with many errors. For
- example, `wrong-type-argument' errors will use the debugger's
- return value instead of the invalid argument; `no-catch' errors
- will use the debugger value as a throw tag instead of the tag that
- was not found. If an error was signaled by calling the Lisp
- function `signal', the debugger's return value is returned as the
- value of `signal'.
-
-\1f
-File: xemacs.info, Node: Lisp Interaction, Next: External Lisp, Prev: Lisp Debug, Up: Running
-
-Lisp Interaction Buffers
-========================
-
- The buffer `*scratch*', which is selected when Emacs starts up, is
-provided for evaluating Lisp expressions interactively inside Emacs.
-Both the expressions you evaluate and their output goes in the buffer.
-
- The `*scratch*' buffer's major mode is Lisp Interaction mode, which
-is the same as Emacs-Lisp mode except for one command, <LFD>. In
-Emacs-Lisp mode, <LFD> is an indentation command. In Lisp Interaction
-mode, <LFD> is bound to `eval-print-last-sexp'. This function reads
-the Lisp expression before point, evaluates it, and inserts the value
-in printed representation before point.
-
- The way to use the `*scratch*' buffer is to insert Lisp expressions
-at the end, ending each one with <LFD> so that it will be evaluated.
-The result is a complete typescript of the expressions you have
-evaluated and their values.
-
- The rationale for this feature is that Emacs must have a buffer when
-it starts up, but that buffer is not useful for editing files since a
-new buffer is made for every file that you visit. The Lisp interpreter
-typescript is the most useful thing I can think of for the initial
-buffer to do. `M-x lisp-interaction-mode' will put any buffer in Lisp
-Interaction mode.
-
-\1f
-File: xemacs.info, Node: External Lisp, Prev: Lisp Interaction, Up: Running
-
-Running an External Lisp
-========================
-
- Emacs has facilities for running programs in other Lisp systems.
-You can run a Lisp process as an inferior of Emacs, and pass
-expressions to it to be evaluated. You can also pass changed function
-definitions directly from the Emacs buffers in which you edit the Lisp
-programs to the inferior Lisp process.
-
- To run an inferior Lisp process, type `M-x run-lisp'. This runs the
-program named `lisp', the same program you would run by typing `lisp'
-as a shell command, with both input and output going through an Emacs
-buffer named `*lisp*'. In other words, any "terminal output" from Lisp
-will go into the buffer, advancing point, and any "terminal input" for
-Lisp comes from text in the buffer. To give input to Lisp, go to the
-end of the buffer and type the input, terminated by <RET>. The
-`*lisp*' buffer is in Inferior Lisp mode, which has all the special
-characteristics of Lisp mode and Shell mode (*note Shell Mode::).
-
- Use Lisp mode to run the source files of programs in external Lisps.
-You can select this mode with `M-x lisp-mode'. It is used automatically
-for files whose names end in `.l' or `.lisp', as most Lisp systems
-usually expect.
-
- When you edit a function in a Lisp program you are running, the
-easiest way to send the changed definition to the inferior Lisp process
-is the key `C-M-x'. In Lisp mode, this key runs the function
-`lisp-send-defun', which finds the defun around or following point and
-sends it as input to the Lisp process. (Emacs can send input to any
-inferior process regardless of what buffer is current.)
-
- Contrast the meanings of `C-M-x' in Lisp mode (for editing programs
-to be run in another Lisp system) and Emacs-Lisp mode (for editing Lisp
-programs to be run in Emacs): in both modes it has the effect of
-installing the function definition that point is in, but the way of
-doing so is different according to where the relevant Lisp environment
-is found. *Note Lisp Modes::.
-
-\1f
-File: xemacs.info, Node: Packages, Next: Abbrevs, Prev: Running, Up: Top
-
-Packages
-========
-
- The XEmacs 21 distribution comes only with a very basic set of
-built-in modes and packages. Most of the packages that were part of
-the distribution of earlier versions of XEmacs are now available
-separately. The installer as well as the user can choose which
-packages to install; the actual installation process is easy. This
-gives an installer the ability to tailor an XEmacs installation for
-local needs with safe removal of unnecessary code.
-
-* Menu:
-
-* Package Terminology:: Understanding different kinds of packages.
-* Using Packages:: How to install and use packages.
-* Building Packages:: Building packages from sources.
-
-\1f
-File: xemacs.info, Node: Package Terminology, Next: Using Packages, Up: Packages
-
-Package Flavors
----------------
-
- There are two main flavors of packages.
-
- * Regular Packages A regular package is one in which multiple files
- are involved and one may not in general safely remove any of them.
-
- * Single-File Packages A single-file package is an aggregate
- collection of thematically related but otherwise independent lisp
- files. These files are bundled together for download convenience
- and individual files may be deleted at will without any loss of
- functionality.
-
-Package Distributions
----------------------
-
- XEmacs Lisp packages are distributed in two ways, depending on the
-intended use. Binary Packages are for installers and end-users and may
-be installed directly into an XEmacs package directory. Source Packages
-are for developers and include all files necessary for rebuilding
-bytecompiled lisp and creating tarballs for distribution.
-
-Binary Packages
----------------
-
- Binary packages may be installed directly into an XEmacs package
-hierarchy.
-
-Source Packages
----------------
-
- Source packages contain all of the Package author's (where
-appropriate in regular packages) source code plus all of the files
-necessary to build distribution tarballs (Unix Tar format files,
-gzipped for space savings).
-
projects / chise / xemacs-chise.git- / blobdiff