GNU Emacs Lisp Reference Manual

GNU GENERAL PUBLIC LICENSE

Version 2, June 1991

Copyright (C) 1989, 1991 Free Software Foundation, Inc.
675 Mass Ave, Cambridge, MA 02139, USA

Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.

Preamble

The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too.

When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.

To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it.

For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights.

We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software.

Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations.

Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all.

The precise terms and conditions for copying, distribution and modification follow.

TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

  1. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you".

    Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does.

  2. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program.

    You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.

  3. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:

    1. You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.

    2. You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.

    3. If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.)

    These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.

    Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program.

    In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.

  4. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following:

    1. Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,

    2. Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,

    3. Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.)

    The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.

    If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code.

  5. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.

  6. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it.

  7. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License.

  8. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program.

    If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances.

    It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.

    This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.

  9. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License.

  10. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.

    Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation.

  11. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.

    NO WARRANTY

  12. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

  13. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

END OF TERMS AND CONDITIONS

How to Apply These Terms to Your New Programs

If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.

To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.

one line to give the program's name and an idea of what it does.
Copyright (C) 19yy  name of author

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Also add information on how to contact you by electronic and paper mail.

If the program is interactive, make it output a short notice like this when it starts in an interactive mode:

Gnomovision version 69, Copyright (C) 19yy name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details
type `show w'.  This is free software, and you are welcome
to redistribute it under certain conditions; type `show c' 
for details.

The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program.

You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names:

Yoyodyne, Inc., hereby disclaims all copyright
interest in the program `Gnomovision'
(which makes passes at compilers) written 
by James Hacker.

signature of Ty Coon, 1 April 1989
Ty Coon, President of Vice

This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License.

Introduction

Most of the GNU Emacs text editor is written in the programming language called Emacs Lisp. You can write new code in Emacs Lisp and install it as an extension to the editor. However, Emacs Lisp is more than a mere "extension language"; it is a full computer programming language in its own right. You can use it as you would any other programming language.

Because Emacs Lisp is designed for use in an editor, it has special features for scanning and parsing text as well as features for handling files, buffers, displays, subprocesses, and so on. Emacs Lisp is closely integrated with the editing facilities; thus, editing commands are functions that can also conveniently be called from Lisp programs, and parameters for customization are ordinary Lisp variables.

This manual describes Emacs Lisp, presuming considerable familiarity with the use of Emacs for editing. (See The GNU Emacs Manual, for this basic information.) Generally speaking, the earlier chapters describe features of Emacs Lisp that have counterparts in many programming languages, and later chapters describe features that are peculiar to Emacs Lisp or relate specifically to editing.

This is edition 2.1.

Caveats

This manual has gone through numerous drafts. It is nearly complete but not flawless. There are a few sections which are not included, either because we consider them secondary (such as most of the individual modes) or because they are yet to be written.

Because we are not able to deal with them completely, we have left out several parts intentionally. This includes most references to VMS and all information relating Sunview. (The Free Software Foundation expends no effort on support for Sunview, since we believe users should use the free X window system rather than proprietary window systems.)

The manual should be fully correct in what it does cover, and it is therefore open to criticism on anything it says--from specific examples and descriptive text, to the ordering of chapters and sections. If something is confusing, or you find that you have to look at the sources or experiment to learn something not covered in the manual, then perhaps the manual should be fixed. Please let us know.

As you use the manual, we ask that you mark pages with corrections so you can later look them up and send them in. If you think of a simple, real life example for a function or group of functions, please make an effort to write it up and send it in. Please reference any comments to the chapter name, section name, and function name, as appropriate, since page numbers and chapter and section numbers will change. Also state the number of the edition which you are criticizing.

Please mail comments and corrections to

bug-lisp-manual@prep.ai.mit.edu

 --Bil Lewis, Dan LaLiberte, Richard Stallman

Lisp History

Lisp (LISt Processing language) was first developed in the late 1950s at the Massachusetts Institute of Technology for research in artificial intelligence. The great power of the Lisp language makes it superior for other purposes as well, such as writing editing commands.

Dozens of Lisp implementations have been built over the years, each with its own idiosyncrasies. Many of them were inspired by Maclisp, which was written in the 1960's at MIT's Project MAC. Eventually the implementors of the descendents of Maclisp came together and developed a standard for Lisp systems, called Common Lisp.

GNU Emacs Lisp is largely inspired by Maclisp, and a little by Common Lisp. If you know Common Lisp, you will notice many similarities. However, many of the features of Common Lisp have been omitted or simplified in order to reduce the memory requirements of GNU Emacs. Sometimes the simplifications are so drastic that a Common Lisp user might be very confused. We will occasionally point out how GNU Emacs Lisp differs from Common Lisp. If you don't know Common Lisp, don't worry about it; this manual is self-contained.

Conventions

This section explains the notational conventions that are used in this manual. You may want to skip this section and refer back to it later.

Some Terms

Throughout this manual, the phrases "the Lisp reader" and "the Lisp printer" are used to refer to those routines in Lisp that convert textual representations of Lisp objects into actual objects, and vice versa. See section Printed Representation and Read Syntax, for more details. You, the person reading this manual, are thought of as "the programmer" and are addressed as "you". "The user" is the person who uses Lisp programs including those you write.

Examples of Lisp code appear in this font or form: (list 1 2 3). Names that represent arguments or metasyntactic variables appear in this font or form: first-number.

nil and t

In Lisp, the symbol nil is overloaded with three meanings: it is a symbol with the name `nil'; it is the logical truth value false; and it is the empty list--the list of zero elements. When used as a variable, nil always has the value nil.

As far as the Lisp reader is concerned, `()' and `nil' are identical: they stand for the same object, the symbol nil. The different ways of writing the symbol are intended entirely for human readers. After the Lisp reader has read either `()' or `nil', there is no way to determine which representation was actually written by the programmer.

In this manual, we use () when we wish to emphasize that it means the empty list, and we use nil when we wish to emphasize that it means the truth value false. That is a good convention to use in Lisp programs also.

(cons 'foo ())                ; Emphasize the empty list
(not nil)                     ; Emphasize the truth value false

In contexts where a truth value is expected, any non-nil value is considered to be true. However, t is the preferred way to represent the truth value true. When you need to choose a value which represents true, and there is no other basis for choosing, use t. The symbol t always has value t.

In Emacs Lisp, nil and t are special symbols that always evaluate to themselves. This is so that you do not need to quote them to use them as constants in a program. An attempt to change their values results in a setting-constant error. See section Accessing Variable Values.

Evaluation Notation

A Lisp expression that you can evaluate is called a form. Evaluating a form always produces a result, which is a Lisp object. In the examples in this manual, this is indicated with `=>':

(car '(1 2))
     => 1

You can read this as "(car '(1 2)) evaluates to 1".

When a form is a macro call, it expands into a new form for Lisp to evaluate. We show the result of the expansion with `==>'. We may or may not show the actual result of the evaluation of the expanded form.

(third '(a b c))
     ==> (car (cdr (cdr '(a b c))))
     => c

Sometimes to help describe one form we show another form which produces identical results. The exact equivalence of two forms is indicated with `=='.

(make-sparse-keymap) == (list 'keymap)

Printing Notation

Many of the examples in this manual print text when they are evaluated. If you execute the code from an example in a Lisp Interaction buffer (such as the buffer `*scratch*'), the printed text is inserted into the buffer. If the example is executed by other means (such as by evaluating the function eval-region), the text printed is usually displayed in the echo area. You should be aware that text displayed in the echo area is truncated to a single line.

In examples that print text, the printed text is indicated with `-|', irrespective of how the form is executed. The value returned by evaluating the form (here bar) follows on a separate line.

(progn (print 'foo) (print 'bar))
     -| foo
     -| bar
     => bar

Error Messages

Some examples cause errors to be signaled. In them, the error message (which always appears in the echo area) is shown on a line starting with `error-->'. Note that `error-->' itself does not appear in the echo area.

(+ 23 'x)
error--> Wrong type argument: integer-or-marker-p, x

Buffer Text Notation

Some examples show modifications to text in a buffer, with "before" and "after" versions of the text. In such cases, the entire contents of the buffer in question are included between two lines of dashes containing the buffer name. In addition, the location of point is shown as `-!-'. (The symbol for point, of course, is not part of the text in the buffer; it indicates the place between two characters where point is located.)

---------- Buffer: foo ----------
This is the -!-contents of foo.
---------- Buffer: foo ----------

(insert "changed ")
     => nil
---------- Buffer: foo ----------
This is the changed -!-contents of foo.
---------- Buffer: foo ----------

Format of Descriptions

Functions, variables, macros, commands, user options, and special forms are described in this manual in a uniform format. The first line of a description contains the name of the item followed by its arguments, if any. The category--function, variable, or whatever--is printed next to the right margin. The description follows on succeeding lines, sometimes with examples.

A Sample Function Description

In a function description, the name of the function being described appears first. It is followed on the same line by a list of parameters. The names used for the parameters are also used in the body of the description.

The appearance of the keyword &optional in the parameter list indicates that the arguments for subsequent parameters may be omitted (omitted parameters default to nil). Do not write &optional when you call the function.

The keyword &rest (which will always be followed by a single parameter) indicates that any number of arguments can follow. The value of the single following parameter will be a list of all these arguments. Do not write &rest when you call the function.

Here is a description of an imaginary function foo:

Function: foo integer1 &optional integer2 &rest integers

The function foo subtracts integer1 from integer2, then adds all the rest of the arguments to the result. If integer2 is not supplied, then the number 19 is used by default.

(foo 1 5 3 9)
     => 16
(foo 5)
     => 14

More generally,

(foo w x y...)
==
(+ (- x w) y...)

Any parameter whose name contains the name of a type (e.g., integer, integer1 or buffer) is expected to be of that type. A plural of a type (such as buffers) often means a list of objects of that type. Parameters named object may be of any type. (See section Lisp Data Types, for a list of Emacs object types.) Parameters with other sorts of names (e.g., new-file) are discussed specifically in the description of the function. In some sections, features common to parameters of several functions are described at the beginning.

See section Lambda Expressions, for a more complete description of optional and rest arguments.

Command, macro, and special form descriptions have the same format, but the word `Function' is replaced by `Command', `Macro', or `Special Form', respectively. Commands are simply functions that may be called interactively; macros process their arguments differently from functions (the arguments are not evaluated), but are presented the same way.

Special form descriptions use a more complex notation to specify optional and repeated parameters because they can break the argument list down into separate arguments in more complicated ways. `[optional-arg]' means that optional-arg is optional and `repeated-args...' stands for zero or more arguments. Parentheses are used when several arguments are grouped into additional levels of list structure. Here is an example:

Special Form: count-loop (var [from to [inc]]) body...

This imaginary special form implements a loop that executes the body forms and then increments the variable var on each iteration. On the first iteration, the variable has the value from; on subsequent iterations, it is incremented by 1 (or by inc if that is given). The loop exits before executing body if var equals to. Here is an example:

(count-loop (i 0 10)
  (prin1 i) (princ " ")
  (prin1 (aref vector i)) (terpri))

If from and to are omitted, then var is bound to nil before the loop begins, and the loop exits if var is non-nil at the beginning of an iteration. Here is an example:

(count-loop (done)
  (if (pending)
      (fixit)
    (setq done t)))

In this special form, the arguments from and to are optional, but must both be present or both absent. If they are present, inc may optionally be specified as well. These arguments are grouped with the argument var into a list, to distinguish them from body, which includes all remaining elements of the form.

A Sample Variable Description

A variable is a name that can hold a value. Although any variable can be set by the user, certain variables that exist specifically so that users can change them are called user options. Ordinary variables and user options are described using a format like that for functions except that there are no arguments.

Here is a description of the imaginary electric-future-map variable.

Variable: electric-future-map

The value of this variable is a full keymap used by electric command future mode. The functions in this map will allow you to edit commands you have not yet thought about executing.

User option descriptions have the same format, but `Variable' is replaced by `User Option'.

Acknowledgements

This manual was written by Robert Krawitz, Bil Lewis, Dan LaLiberte, Richard M. Stallman and Chris Welty, the volunteers of the GNU manual group, in an effort extending over several years. Robert J. Chassell helped to review and edit the manual, with the support of the Defense Advanced Research Projects Agency, ARPA Order 6082, arranged by Warren A. Hunt, Jr. of Computational Logic, Inc.

Corrections were supplied by Karl Berry, Jim Blandy, Bard Bloom, David Boyes, Alan Carroll, David A. Duff, Beverly Erlebacher, David Eckelkamp, Eirik Fuller, Eric Hanchrow, George Hartzell, Nathan Hess, Dan Jacobson, Jak Kirman, Bob Knighten, Frederick M. Korz, Joe Lammens, K. Richard Magill, Brian Marick, Roland McGrath, Skip Montanaro, John Gardiner Myers, Arnold D. Robbins, Raul Rockwell, Shinichirou Sugou, Kimmo Suominen, Edward Tharp, Bill Trost, Jean White, Matthew Wilding, Carl Witty, Dale Worley, Rusty Wright, and David D. Zuhn.

Lisp Data Types

A Lisp object is a piece of data used and manipulated by Lisp programs. For our purposes, a type or data type is a set of possible objects.

Every object belongs to at least one type. Objects of the same type have similar structures and may usually be used in the same contexts. Types can overlap, and objects can belong to two or more types. Consequently, we can ask whether an object belongs to a particular type, but not for "the" type of an object.

A few fundamental object types are built into Emacs. These, from which all other types are constructed, are called primitive types. Each object belongs to one and only one primitive type. These types include integer, float, cons, symbol, string, vector, subr, byte-code function, and several special types, such as buffer, that are related to editing. (See section Editing Types.)

Each primitive type has a corresponding Lisp function that checks whether an object is a member of that type.

Note that Lisp is unlike many other languages in that Lisp objects are self-typing: the primitive type of the object is implicit in the object itself. For example, if an object is a vector, it cannot be treated as a number because Lisp knows it is a vector, not a number.

In most languages, the programmer must declare the data type of each variable, and the type is known by the compiler but not represented in the data. Such type declarations do not exist in Emacs Lisp. A Lisp variable can have any type of value, and remembers the type of any value you store in it.

This chapter describes the purpose, printed representation, and read syntax of each of the standard types in GNU Emacs Lisp. Details on how to use these types can be found in later chapters.

Printed Representation and Read Syntax

The printed representation of an object is the format of the output generated by the Lisp printer (the function print) for that object. The read syntax of an object is the format of the input accepted by the Lisp reader (the function read) for that object. Most objects have more than one possible read syntax. Some types of object have no read syntax; except for these cases, the printed representation of an object is also a read syntax for it.

In other languages, an expression is text; it has no other form. In Lisp, an expression is primarily a Lisp object and only secondarily the text that is the object's read syntax. Often there is no need to emphasize this distinction, but you must keep it in the back of your mind, or you will occasionally be very confused.

Every type has a printed representation. Some types have no read syntax, since it may not make sense to enter objects of these types directly in a Lisp program. For example, the buffer type does not have a read syntax. Objects of these types are printed in hash notation: the characters `#<' followed by a descriptive string (typically the type name followed by the name of the object), and closed with a matching `>'. Hash notation cannot be read at all, so the Lisp reader signals the error invalid-read-syntax whenever a `#<' is encountered.

(current-buffer)
     => #<buffer objects.texi>

When you evaluate an expression interactively, the Lisp interpreter first reads the textual representation of it, producing a Lisp object, and then evaluates that object (see section Evaluation). However, evaluation and reading are separate activities. Reading returns the Lisp object represented by the text that is read; the object may or may not be evaluated later. See section Input Functions, for a description of read, the basic function for reading objects.

Comments

A comment is text that is written in a program only for the sake of humans that read the program, and that has no effect on the meaning of the program. In Lisp, a comment starts with a semicolon (`;') if it is not within a string or character constant, and continues to the end of line. Comments are discarded by the Lisp reader, and do not become part of the Lisp objects which represent the program within the Lisp system.

See section Tips on Writing Comments, for conventions for formatting comments.

Programming Types

There are two general categories of types in Emacs Lisp: those having to do with Lisp programming, and those having to do with editing. The former are provided in many Lisp implementations, in one form or another. The latter are unique to Emacs Lisp.

Integer Type

Integers are the only kind of number in GNU Emacs Lisp, version 18. The range of values for integers is -8388608 to 8388607 (24 bits; i.e., to on most machines, but is 25 or 26 bits on some systems. It is important to note that the Emacs Lisp arithmetic functions do not check for overflow. Thus (1+ 8388607) is -8388608 on 24-bit implementations.

The read syntax for numbers is a sequence of (base ten) digits with an optional sign. The printed representation produced by the Lisp interpreter never has a leading `+'.

-1               ; The integer -1.
1                ; The integer 1.
+1               ; Also the integer 1.
16777217         ; Also the integer 1! 
                 ;   (on a 24-bit or 25-bit implementation)

See section Numbers, for more information.

Floating Point Type

Emacs version 19 supports floating point numbers, if compiled with the macro LISP_FLOAT_TYPE defined. The precise range of floating point numbers is machine-specific.

The printed representation for floating point numbers requires either a decimal point (with at least one digit following), an exponent, or both. For example, `1500.0', `15e2', `15.0e2', `1.5e3', and `.15e4' are five ways of writing a floating point number whose value is 1500. They are all equivalent.

See section Numbers, for more information.

Character Type

A character in Emacs Lisp is nothing more than an integer. In other words, characters are represented by their character codes. For example, the character A is represented as the integer 65.

Individual characters are not often used in programs. It is far more common to work with strings, which are sequences composed of characters. See section String Type.

Characters in strings, buffers, and files are currently limited to the range of 0 to 255. If an arbitrary integer is used as a character for those purposes, only the lower eight bits are significant. Characters that represent keyboard input have a much wider range.

Since characters are really integers, the printed representation of a character is a decimal number. This is also a possible read syntax for a character, but writing characters that way in Lisp programs is a very bad idea. You should always use the special read syntax formats that Emacs Lisp provides for characters. These syntax formats start with a question mark.

The usual read syntax for alphanumeric characters is a question mark followed by the character; thus, `?A' for the character A, `?B' for the character B, and `?a' for the character a.

For example:

?Q => 81

?q => 113

You can use the same syntax for punctuation characters, but it is often a good idea to add a `\' to prevent Lisp mode from getting confused. For example, `?\ ' is the way to write the space character. If the character is `\', you must use a second `\' to quote it: `?\\'.

You can express the characters control-g, backspace, tab, newline, vertical tab, formfeed, return, and escape as `?\a', `?\b', `?\t', `?\n', `?\v', `?\f', `?\r', `?\e', respectively. Those values are 7, 8, 9, 10, 11, 12, 13, and 27 in decimal. Thus,

?\a => 7                 ; C-g
?\b => 8                 ; backspace, BS, C-h
?\t => 9                 ; tab, TAB, C-i
?\n => 10                ; newline, LFD, C-j
?\v => 11                ; vertical tab, C-k
?\f => 12                ; formfeed character, C-l
?\r => 13                ; carriage return, RET, C-m
?\e => 27                ; escape character, ESC, C-[
?\\ => 92                ; backslash character, \

These sequences which start with backslash are also known as escape sequences, because backslash plays the role of an escape character, but they have nothing to do with the character ESC.

Control characters may be represented using yet another read syntax. This consists of a question mark followed by a backslash, caret, and the corresponding non-control character, in either upper or lower case. For example, either `?\^I' or `?\^i' may be used as the read syntax for the character C-i, the character whose value is 9.

Instead of the `^', you can use `C-'; thus, `?\C-i' is equivalent to `?\^I' and to `?\^i':

?\^I => 9
     
?\C-I => 9

For use in strings and buffers, you are limited to the control characters that exist in ASCII, but for keyboard input purposes, you can turn any character into a control character with `C-'. The character codes for these characters include the 2**22 bit as well as the code for the non-control character. Ordinary terminals have no way of generating non-ASCII control characters, but you can generate them straightforwardly using an X terminal.

The DEL key can be considered and written as Control-?:

?\^? => 127
     
?\C-? => 127

When you represent control characters to be found in files or strings, we recommend the `^' syntax; but when you refer to keyboard input, we prefer the `C-' syntax. This does not affect the meaning of the program, but may guide the understanding of people who read it.

A meta character is a character typed with the META key. The integer that represents such a character has the 2**23 bit set (which on most machines makes it a negative number). We use high bits for this and other modifiers to make possible a wide range of basic character codes.

In a string, the 2**7 bit indicates a meta character, so the meta characters that can fit in a string have codes in the range from 128 to 255, and are the meta versions of the ordinary ASCII characters. (In Emacs versions 18 and older, this convention was used for characters outside of strings as well.)

The read syntax for meta characters uses `\M-'. For example, `?\M-A' stands for M-A. You can use `\M-' together with octal codes, `\C-', or any other syntax for a character. Thus, you can write M-A as `?\M-A', or as `?\M-\101'. Likewise, you can write C-M-b as `?\M-\C-b', `?\C-\M-b', or `?\M-\002'.

The shift modifier is used in indicating the case of a character in special circumstances. The case of an ordinary letter is indicated by its character code as part of ASCII, but ASCII has no way to represent whether a control character is upper case or lower case. Emacs uses the 2**21 bit to indicate that the shift key was used for typing a control character. This distinction is possible only when you use X terminals or other special terminals; ordinary terminals do not indicate the distinction to the computer in any way.

The X Window system defines three other modifier bits that can be set in a character: hyper, super and alt. The syntaxes for these bits are `\H-', `\s-' and `\A-'. Thus, `?\H-\M-\A-x' represents Alt-Hyper-Meta-x. Numerically, the bit values are 2**18 for alt, 2**19 for super and 2**20 for hyper.

Finally, the most general read syntax consists of a question mark followed by a backslash and the character code in octal (up to three octal digits); thus, `?\101' for the character A, `?\001' for the character C-a, and ?\002 for the character C-b. Although this syntax can represent any ASCII character, it is preferred only when the precise octal value is more important than the ASCII representation.

?\012 => 10        ?\n => 10         ?\C-j => 10

?\101 => 65        ?A => 65           

A backslash is allowed, and harmless, preceding any character without a special escape meaning; thus, `?\A' is equivalent to `?A'. There is no reason to use a backslash before most such characters. However, any of the characters `()\|;'`"#.,' should be preceded by a backslash to avoid confusing the Emacs commands for editing Lisp code. Whitespace characters such as space, tab, newline and formfeed should also be preceded by a backslash. However, it is cleaner to use one of the easily readable escape sequences, such as `\t', instead of an actual control character such as a tab.

Sequence Types

A sequence is a Lisp object that represents an ordered set of elements. There are two kinds of sequence in Emacs Lisp, lists and arrays. Thus, an object of type list or of type array is also considered a sequence.

Arrays are further subdivided into strings and vectors. Vectors can hold elements of any type, but string elements must be characters in the range from 0 to 255. However, the characters in a string can have text properties; vectors do not support text properties even when their elements happen to be characters.

Lists, strings and vectors are different, but they have important similarities. For example, all have a length l, and all have elements which can be indexed from zero to l minus one. Also, several functions, called sequence functions, accept any kind of sequence. For example, the function elt can be used to extract an element of a sequence, given its index. See section Sequences, Arrays, and Vectors.

It is impossible to read the same sequence twice, in the sense of eq (see section Equality Predicates), since sequences are always created anew upon reading. There is one exception: the empty list () always stands for the same object, nil.

List Type

A list is a series of cons cells, linked together. A cons cell is an object comprising two pointers named the CAR and the CDR. Each of them can point to any Lisp object, but when the cons cell is part of a list, the CDR points either to another cons cell or to the empty list. See section Lists, for functions that work on lists.

The names CAR and CDR have only historical meaning now. The original Lisp implementation ran on an IBM 704 computer which divided words into two parts, called the "address" part and the "decrement"; CAR was an instruction to extract the contents of the address part of a register, and CDR an instruction to extract the contents of the decrement. By contrast, "cons cells" are named for the function cons that creates them, which in turn is named for its purpose, the construction of cells.

Because cons cells are so central to Lisp, we also have a word for "an object which is not a cons cell". These objects are called atoms.

The read syntax and printed representation for lists are identical, and consist of a left parenthesis, an arbitrary number of elements, and a right parenthesis.

Upon reading, any object inside the parentheses is made into an element of the list. That is, a cons cell is made for each element. The CAR of the cons cell points to the element, and its CDR points to the next cons cell which holds the next element in the list. The CDR of the last cons cell is set to point to nil.

A list can be illustrated by a diagram in which the cons cells are shown as pairs of boxes. (The Lisp reader cannot read such an illustration; unlike the textual notation, which can be understood both humans and computers, the box illustrations can only be understood by humans.) The following represents the three-element list (rose violet buttercup):

    ___ ___      ___ ___      ___ ___
   |___|___|--> |___|___|--> |___|___|--> nil
     |            |            |
     |            |            |
      --> rose     --> violet   --> buttercup

In the diagram, each box represents a slot that can refer to any Lisp object. Each pair of boxes represents a cons cell. Each arrow is a reference to a Lisp object, either an atom or another cons cell.

In this example, the first box, the CAR of the first cons cell, refers to or "contains" rose (a symbol). The second box, the CDR of the first cons cell, refers to the next pair of boxes, the second cons cell. The CAR of the second cons cell refers to violet and the CDR refers to the third cons cell. The CDR of the third (and last) cons cell refers to nil.

Here is another diagram of the same list, (rose violet buttercup), sketched in a different manner:

 ---------------       ----------------       -------------------
| car   | cdr   |     | car    | cdr   |     | car       | cdr   |
| rose  |   o-------->| violet |   o-------->| buttercup |  nil  |
|       |       |     |        |       |     |           |       |
 ---------------       ----------------       -------------------

A list with no elements in it is the empty list; it is identical to the symbol nil. In other words, nil is both a symbol and a list.

Here are examples of lists written in Lisp syntax:

(A 2 "A")            ; A list of three elements.
()                   ; A list of no elements (the empty list).
nil                  ; A list of no elements (the empty list).
("A ()")             ; A list of one element: the string "A ()".
(A ())               ; A list of two elements: A and the empty list.
(A nil)              ; Equivalent to the previous.
((A B C))            ; A list of one element
                     ;   (which is a list of three elements).

Here is the list (A ()), or equivalently (A nil), depicted with boxes and arrows:

    ___ ___      ___ ___
   |___|___|--> |___|___|--> nil
     |            |
     |            |
      --> A        --> nil

Dotted Pair Notation

Dotted pair notation is an alternative syntax for cons cells that represents the CAR and CDR explicitly. In this syntax, (a . b) stands for a cons cell whose CAR is the object a, and whose CDR is the object b. Dotted pair notation is therefore more general than list syntax. In the dotted pair notation, the list `(1 2 3)' is written as `(1 . (2 . (3 . nil)))'. For nil-terminated lists, the two notations produce the same result, but list notation is usually clearer and more convenient when it is applicable. When printing a list, the dotted pair notation is only used if the CDR of a cell is not a list.

Box notation can also be used to illustrate what dotted pairs look like. For example, (rose . violet) is diagrammed as follows:

    ___ ___
   |___|___|--> violet
     |
     |
      --> rose

Dotted pair notation can be combined with list notation to represent a chain of cons cells with a non-nil final CDR. For example, (rose violet . buttercup) is equivalent to (rose . (violet . buttercup)). The object looks like this:

    ___ ___      ___ ___
   |___|___|--> |___|___|--> buttercup
     |            |
     |            |
      --> rose     --> violet

These diagrams make it evident that (rose . violet . buttercup) must have an invalid syntax since it would require that a cons cell have three parts rather than two.

The list (rose violet) is equivalent to (rose . (violet)) and looks like this:

    ___ ___      ___ ___
   |___|___|--> |___|___|--> nil
     |            |
     |            |
      --> rose     --> violet

Similarly, the three-element list (rose violet buttercup) is equivalent to (rose . (violet . (buttercup))).

Association List Type

An association list or alist is a specially-constructed list whose elements are cons cells. In each element, the CAR is considered a key, and the CDR is considered an associated value. (In some cases, the associated value is stored in the CAR of the CDR.) Association lists are often used to implement stacks, since new associations may easily be added to or removed from the front of the list.

For example,

(setq alist-of-colors
      '((rose . red) (lily . white)  (buttercup . yellow)))

sets the variable alist-of-colors to an alist of three elements. In the first element, rose is the key and red is the value.

See section Association Lists, for a further explanation of alists and for functions that work on alists.

Array Type

An array is composed of an arbitrary number of other Lisp objects, arranged in a contiguous block of memory. Any element of an array may be accessed in constant time. In contrast, accessing an element of a list requires time proportional to the position of the element in the list. (Elements at the end of a list take longer to access than elements at the beginning of a list.)

Emacs defines two types of array, strings and vectors. A string is an array of characters and a vector is an array of arbitrary objects. Both are one-dimensional. (Most other programming languages support multidimensional arrays, but we don't think they are essential in Emacs Lisp.) Each type of array has its own read syntax; see section String Type, and section Vector Type.

An array may have any length up to the largest integer; but once created, it has a fixed size. The first element of an array has index zero, the second element has index 1, and so on. This is called zero-origin indexing. For example, an array of four elements has indices 0, 1, 2, and 3.

The array type is contained in the sequence type and contains both strings and vectors.

String Type

A string is an array of characters. Strings are used for many purposes in Emacs, as can be expected in a text editor; for example, as the names of Lisp symbols, as messages for the user, and to represent text extracted from buffers. Strings in Lisp are constants; evaluation of a string returns the same string.

The read syntax for strings is a double-quote, an arbitrary number of characters, and another double-quote, "like this". The Lisp reader accepts the same formats for reading the characters of a string as it does for reading single characters (without the question mark that begins a character literal). You can enter a nonprinting character such as tab, C-a or M-C-A using the convenient escape sequences, like this: "\t, \C-a, \M-\C-a". You can include a double-quote in a string by preceding it with a backslash; thus, "\"" is a string containing just a single double-quote character. (See section Character Type, for a description of the read syntax for characters.)

If you use the `\M-' syntax to indicate a meta character in a string constant, this sets the 2**7 bit of the character in the string. This is not the same representation that the meta modifier has in a character regarded as a simple integer. See section Character Type.

Strings cannot hold characters that have the hyper, super or alt modifiers; they can hold ASCII control characters, but no others. They do not distinguish case in ASCII control characters.

In contrast with the C programming language, Emacs Lisp allows newlines in string literals. But an escaped newline--one that is preceded by `\'---does not become part of the string; i.e., the Lisp reader ignores an escaped newline in a string literal.

"It is useful to include newlines
in documentation strings,
but the newline is \
ignored if escaped."
     => "It is useful to include newlines 
in documentation strings, 
but the newline is ignored if escaped."

The printed representation of a string consists of a double-quote, the characters it contains, and another double-quote. However, any backslash or double-quote characters in the string are preceded with a backslash like this: "this \" is an embedded quote".

A string can hold properties of the text it contains, in addition to the characters themselves. This enables programs that copy text between strings and buffers to preserve the properties with no special effort. See section Text Properties. Strings with text properties have a special read and print syntax:

#("characters" property-data...)

where property-data is zero or more elements in groups of three as follows:

beg end plist

The elements beg and end are integers, and together specify a portion of the string; plist is the property list for that portion.

See section Strings and Characters, for functions that work on strings.

Vector Type

A vector is a one-dimensional array of elements of any type. It takes a constant amount of time to access any element of a vector. (In a list, the access time of an element is proportional to the distance of the element from the beginning of the list.)

The printed representation of a vector consists of a left square bracket, the elements, and a right square bracket. This is also the read syntax. Like numbers and strings, vectors are considered constants for evaluation.

[1 "two" (three)]      ; A vector of three elements.
     => [1 "two" (three)]

See section Vectors, for functions that work with vectors.

Symbol Type

A symbol in GNU Emacs Lisp is an object with a name. The symbol name serves as the printed representation of the symbol. In ordinary use, the name is unique--no two symbols have the same name.

A symbol may be used in programs as a variable, as a function name, or to hold a list of properties. Or it may serve only to be distinct from all other Lisp objects, so that its presence in a data structure may be recognized reliably. In a given context, usually only one of these uses is intended.

A symbol name can contain any characters whatever. Most symbol names are written with letters, digits, and the punctuation characters `-+=*/'. Such names require no special punctuation; the characters of the name suffice as long as the name does not look like a number. (If it does, write a `\' at the beginning of the name to force interpretation as a symbol.) The characters `_~!@$%^&:<>{}' are less often used but also require no special punctuation. Any other characters may be included in a symbol's name by escaping them with a backslash. In contrast to its use in strings, however, a backslash in the name of a symbol quotes the single character that follows the backslash, without conversion. For example, in a string, `\t' represents a tab character; in the name of a symbol, however, `\t' merely quotes the letter t. To have a symbol with a tab character in its name, you must actually type an tab (preceded with a backslash). But you would hardly ever do such a thing.

Common Lisp note: in Common Lisp, lower case letters are always "folded" to upper case, unless they are explicitly escaped. This is in contrast to Emacs Lisp, in which upper case and lower case letters are distinct.

Here are several examples of symbol names. Note that the `+' in the fifth example is escaped to prevent it from being read as a number. This is not necessary in the last example because the rest of the name makes it invalid as a number.

foo                 ; A symbol named `foo'.
FOO                 ; A symbol named `FOO', different from `foo'.
char-to-string      ; A symbol named `char-to-string'.
1+                  ; A symbol named `1+'
                    ;   (not `+1', which is an integer).
\+1                 ; A symbol named `+1'
                    ;   (not a very readable name).
\(*\ 1\ 2\)         ; A symbol named `(* 1 2)' (a worse name).
+-*/_~!@$%^&=:<>{}  ; A symbol named `+-*/_~!@$%^&=:<>{}'.
                    ;   These characters need not be escaped.

Lisp Function Type

Just as functions in other programming languages are executable, Lisp function objects are pieces of executable code. However, functions in Lisp are primarily Lisp objects, and only secondarily the text which represents them. These Lisp objects are lambda expressions: lists whose first element is the symbol lambda (see section Lambda Expressions).

In most programming languages, it is impossible to have a function without a name. In Lisp, a function has no intrinsic name. A lambda expression is also called an anonymous function (see section Anonymous Functions). A named function in Lisp is actually a symbol with a valid function in its function cell (see section Defining Named Functions).

Most of the time, functions are called when their names are written in Lisp expressions in Lisp programs. However, a function object found or constructed at run time can be called and passed arguments with the primitive functions funcall and apply. See section Calling Functions.

Lisp Macro Type

A Lisp macro is a user-defined construct that extends the Lisp language. It is represented as an object much like a function, but with different parameter-passing semantics. A Lisp macro has the form of a list whose first element is the symbol macro and whose CDR is a Lisp function object, including the lambda symbol.

Lisp macro objects are usually defined with the built-in defmacro function, but any list that begins with macro is a macro as far as Emacs is concerned. See section Macros, for an explanation of how to write a macro.

Primitive Function Type

A primitive function is a function callable from Lisp but written in the C programming language. Primitive functions are also called subrs or built-in functions. (The word "subr" is derived from "subroutine".) Most primitive functions evaluate all their arguments when they are called. A primitive function that does not evaluate all its arguments is called a special form (see section Special Forms).

It does not matter to the caller of a function whether the function is primitive. However, this does matter if you are trying to substitute a function written in Lisp for a primitive of the same name. The reason is that the primitive function may be called directly from C code. When the redefined function is called from Lisp, the new definition will be used; but calls from C code may still use the old definition.

The term function is used to refer to all Emacs functions, whether written in Lisp or C. See section Lisp Function Type, for information about the functions written in Lisp.

Primitive functions have no read syntax and print in hash notation with the name of the subroutine.

(symbol-function 'car)          ; Access the function cell
                                ;   of the symbol.
     => #<subr car>
(subrp (symbol-function 'car))  ; Is this a primitive function?
     => t                       ; Yes.

Byte-Code Function Type

The byte compiler produces byte-code function objects. Internally, a byte-code function object is much like a vector; however, the evaluator handles this data type specially when it appears as a function to be called. See section Byte Compilation, for information about the byte compiler.

The printed representation for a byte-code function object is like that for a vector, with an additional `#' before the opening `['.

Autoload Type

An autoload object is a list whose first element is the symbol autoload. It is stored as the function definition of a symbol to say that a file of Lisp code should be loaded when necessary to find the true definition of that symbol. The autoload object contains the name of the file, plus some other information about the real definition.

After the file has been loaded, the symbol should have a new function definition that is not an autoload object. The new definition is then called as if it had been there to begin with. From the user's point of view, the function call works as expected, using the function definition in the loaded file.

An autoload object is usually created with the function autoload, which stores the object in the function cell of a symbol. See section Autoload, for more details.

Editing Types

The types in the previous section are common to many Lisp-like languages. But Emacs Lisp provides several additional data types for purposes connected with editing.

Buffer Type

A buffer is an object that holds text that can be edited (see section Buffers). Most buffers hold the contents of a disk file (see section Files) so they can be edited, but some are used for other purposes. Most buffers are also meant to be seen by the user, and therefore displayed, at some time, in a window (see section Windows). But a buffer need not be displayed in a window.

The contents of a buffer are much like a string, but buffers are not used like strings in Emacs Lisp, and the available operations are different. For example, text can be inserted into a buffer very quickly, while "inserting" text into a string is accomplished by concatenation and the result is an entirely new string object.

Each buffer has a designated position called point (see section Positions). And one buffer is the current buffer. Most editing commands act on the contents of the current buffer in the neighborhood of point. Many other functions manipulate or test the characters in the current buffer and much of this manual is devoted to describing these functions (see section Text).

Several other data structures are associated with each buffer:

The local keymap and variable list contain entries which individually override global bindings or values. These are used to customize the behavior of programs in different buffers, without actually changing the programs.

Buffers have no read syntax. They print in hash notation with the buffer name.

(current-buffer)
     => #<buffer objects.texi>

Window Type

A window describes the portion of the terminal screen that Emacs uses to display a buffer. Every window has one associated buffer, whose contents appear in the window. By contrast, a given buffer may appear in one window, no window, or several windows.

Though many windows may exist simultaneously, one window is designated the selected window. This is the window where the cursor is (usually) displayed when Emacs is ready for a command. The selected window usually displays the current buffer, but this is not necessarily the case.

Windows are grouped on the screen into frames; each window belongs to one and only one frame. See section Frame Type.

Windows have no read syntax. They print in hash notation, giving the window number and the name of the buffer being displayed. The window numbers exist to identify windows uniquely, since the buffer displayed in any given window can change frequently.

(selected-window)
     => #<window 1 on objects.texi>

See section Windows, for a description of the functions that work on windows.

Frame Type

A frame is a rectangle on the screen that contains one or more Emacs windows. A frame initially contains a single main window (plus perhaps a minibuffer window) which you can subdivide vertically or horizontally into smaller windows.

Frames have no read syntax. They print in hash notation, giving the frame's title, plus its address in core (useful to identify the frame uniquely).

(selected-frame)
     => #<frame xemacs@mole.gnu.ai.mit.edu 0xdac80>

See section Frames, for a description of the functions that work on frames.

Window Configuration Type

A window configuration stores information about the positions and sizes of windows at the time the window configuration is created, so that the screen layout may be recreated later.

Window configurations do not have a read syntax. They print as `#<window-configuration>'. See section Window Configurations, for a description of several functions related to window configurations.

Marker Type

A marker denotes a position in a specific buffer. Markers therefore have two components: one for the buffer, and one for the position. The position value is changed automatically as necessary as text is inserted into or deleted from the buffer. This is to ensure that the marker always points between the same two characters in the buffer.

Markers have no read syntax. They print in hash notation, giving the current character position and the name of the buffer.

(point-marker)
     => #<marker at 10779 in objects.texi>

See section Markers, for information on how to test, create, copy, and move markers.

Process Type

The word process means a running program. Emacs itself runs in a process of this sort. However, in Emacs Lisp, a process is a Lisp object that designates a subprocess created by Emacs process. External subprocesses, such as shells, GDB, ftp, and compilers, may be used to extend the processing capability of Emacs.

A process takes input from Emacs and returns output to Emacs for further manipulation. Both text and signals can be communicated between Emacs and a subprocess.

Processes have no read syntax. They print in hash notation, giving the name of the process:

(process-list)
     => (#<process shell>)

See section Processes, for information about functions that create, delete, return information about, send input or signals to, and receive output from processes.

Stream Type

A stream is an object that can be used as a source or sink for characters--either to supply characters for input or to accept them as output. Many different types can be used this way: markers, buffers, strings, and functions. Most often, input streams (character sources) obtain characters from the keyboard, a buffer, or a file, and output streams (character sinks) send characters to a buffer, such as a `*Help*' buffer, or to the echo area.

The object nil, in addition to its other meanings, may be used as a stream. It stands for the value of the variable standard-input or standard-output. Also, the object t as a stream specifies input using the minibuffer (see section Minibuffers) or output in the echo area (see section The Echo Area).

Streams have no special printed representation or read syntax, and print as whatever primitive type they are.

See section Reading and Printing Lisp Objects, for a description of various functions related to streams, including various parsing and printing functions.

Keymap Type

A keymap maps keys typed by the user to functions. This mapping controls how the user's command input is executed. A keymap is actually a list whose CAR is the symbol keymap.

See section Keymaps, for information about creating keymaps, handling prefix keys, local as well as global keymaps, and changing key bindings.

Syntax Table Type

A syntax table is a vector of 256 integers. Each element of the vector defines how one character is interpreted when it appears in a buffer. For example, in C mode (see section Major Modes), the `+' character is punctuation, but in Lisp mode it is a valid character in a symbol. These different interpretations are effected by changing the syntax table entry for `+', i.e., at index 43.

Syntax tables are only used for scanning text in buffers, not for reading Lisp expressions. The table the Lisp interpreter uses to read expressions is built into the Emacs source code and cannot be changed; thus, to change the list delimiters to be `{' and `}' instead of `(' and `)' would be impossible.

See section Syntax Tables, for details about syntax classes and how to make and modify syntax tables.

Display Table Type

A display table specifies how to display each character code. Each buffer and each window can have its own display table. A display table is actually a vector of length 261. See section Display Tables.

Overlay Type

An overlay specifies temporary alteration of the display appearance of a part of a buffer. It contains markers delimiting a range of the buffer, plus a property list (a list whose elements are alternating property names and values). Overlays are used to present parts of the buffer temporarily in a different display style.

See section Overlays, for how to create and use overlays.

Type Predicates

The Emacs Lisp interpreter itself does not perform type checking on the actual arguments passed to functions when they are called. It could not do otherwise, since variables in Lisp are not declared to be of a certain type, as they are in other programming languages. It is therefore up to the individual function to test whether each actual argument belongs to a type that can be used by the function.

All built-in functions do check the types of their actual arguments when appropriate and signal a wrong-type-argument error if an argument is of the wrong type. For example, here is what happens if you pass an argument to + which it cannot handle:

(+ 2 'a)
     error--> Wrong type argument: integer-or-marker-p, a

Many functions, called type predicates, are provided to test whether an object is a member of a given type. (Following a convention of long standing, the names of most Emacs Lisp predicates end in `p'.)

Here is a table of predefined type predicates, in alphabetical order, with references to further information.

atom
see section Predicates on Lists

arrayp
see section Functions that Operate on Arrays

bufferp
see section Buffer Basics

byte-code-function-p
see section Byte-Code Function Type

case-table-p
see section The Case Table

char-or-string-p
see section The Predicates for Strings

commandp
see section Interactive Call

consp
see section Predicates on Lists

floatp
see section Type Predicates for Numbers

frame-live-p
see section Deleting Frames

framep
see section Frames

integer-or-marker-p
see section Predicates on Markers

integerp
see section Type Predicates for Numbers

keymapp
see section Creating Keymaps

listp
see section Predicates on Lists

markerp
see section Predicates on Markers

natnump
see section Type Predicates for Numbers

nlistp
see section Predicates on Lists

numberp
see section Type Predicates for Numbers

number-or-marker-p
see section Predicates on Markers

overlayp
see section Overlays

processp
see section Processes

sequencep
see section Sequences

stringp
see section The Predicates for Strings

subrp
see section Accessing Function Cell Contents

symbolp
see section Symbols

syntax-table-p
see section Syntax Tables

user-variable-p
see section Defining Global Variables

vectorp
see section Vectors

window-configuration-p
see section Window Configurations

window-live-p
see section Deleting Windows

windowp
see section Basic Concepts of Emacs Windows

Equality Predicates

Here we describe two functions that test for equality between any two objects. Other functions test equality between objects of specific types, e.g., strings. See the appropriate chapter describing the data type for these predicates.

Function: eq object1 object2

This function returns t if object1 and object2 are the same object, nil otherwise. The "same object" means that a change in one will be reflected by the same change in the other.

eq returns t if object1 and object2 are integers with the same value. Also, since symbol names are normally unique, if the arguments are symbols with the same name, they are eq. For other types (e.g., lists, vectors, strings), two arguments with the same contents or elements are not necessarily eq to each other: they are eq only if they are the same object.

(The make-symbol function returns an uninterned symbol that is not interned in the standard obarray. When uninterned symbols are in use, symbol names are no longer unique. Distinct symbols with the same name are not eq. See section Creating and Interning Symbols.)

(eq 'foo 'foo)
     => t

(eq 456 456)
     => t

(eq "asdf" "asdf")
     => nil

(eq '(1 (2 (3))) '(1 (2 (3))))
     => nil

(eq [(1 2) 3] [(1 2) 3])
     => nil

(eq (point-marker) (point-marker))
     => nil

Function: equal object1 object2

This function returns t if object1 and object2 have equal components, nil otherwise. Whereas eq tests if its arguments are the same object, equal looks inside nonidentical arguments to see if their elements are the same. So, if two objects are eq, they are equal, but the converse is not always true.

(equal 'foo 'foo)
     => t

(equal 456 456)
     => t

(equal "asdf" "asdf")
     => t
(eq "asdf" "asdf")
     => nil

(equal '(1 (2 (3))) '(1 (2 (3))))
     => t
(eq '(1 (2 (3))) '(1 (2 (3))))
     => nil

(equal [(1 2) 3] [(1 2) 3])
     => t
(eq [(1 2) 3] [(1 2) 3])
     => nil

(equal (point-marker) (point-marker))
     => t

(eq (point-marker) (point-marker))
     => nil

Comparison of strings is case-sensitive.

(equal "asdf" "ASDF")
     => nil

The test for equality is implemented recursively, and circular lists may therefore cause infinite recursion (leading to an error).

Numbers

GNU Emacs supports two numeric data types: integers and floating point numbers. Integers are whole numbers such as -3, 0, 7, 13, and 511. Their values are exact. Floating point numbers are numbers with fractional parts, such as -4.5, 0.0, or 2.71828. They can also be expressed in an exponential notation as well: thus, 1.5e2 equals 150; in this example, `e2' stands for ten to the second power, and is multiplied by 1.5. Floating point values are not exact; they have a fixed, limited amount of precision.

Support for floating point numbers is a new feature in Emacs 19, and it is controlled by a separate compilation option, so you may encounter a site where Emacs does not support them.

Integer Basics

The range of values for an integer depends on the machine. The range is -8388608 to 8388607 (24 bits; i.e., to ) on most machines, but on others it is -16777216 to 16777215 (25 bits), or -33554432 to 33554431 (26 bits). All of the examples shown below assume an integer has 24 bits.

The Lisp reader reads numbers as a sequence of digits with an optional sign.

 1               ; The integer 1.
+1               ; Also the integer 1.
-1               ; The integer -1.
 16777217        ; Also the integer 1, due to overflow.
 0               ; The number 0.
-0               ; The number 0.
 1.              ; The integer 1.

To understand how various functions work on integers, especially the bitwise operators (see section Bitwise Operations on Integers), it is often helpful to view the numbers in their binary form.

In 24 bit binary, the decimal integer 5 looks like this:

0000 0000  0000 0000  0000 0101

(We have inserted spaces between groups of 4 bits, and two spaces between groups of 8 bits, to make the binary integer easier to read.)

The integer -1 looks like this:

1111 1111  1111 1111  1111 1111

-1 is represented as 24 ones. (This is called two's complement notation.)

The negative integer, -5, is creating by subtracting 4 from -1. In binary, the decimal integer 4 is 100. Consequently, -5 looks like this:

1111 1111  1111 1111  1111 1011

In this implementation, the largest 24 bit binary integer is the decimal integer 8,388,607. In binary, this number looks like this:

0111 1111  1111 1111  1111 1111

Since the arithmetic functions do not check whether integers go outside their range, when you add 1 to 8,388,607, the value is negative integer -8,388,608:

(+ 1 8388607)
     => -8388608
     => 1000 0000  0000 0000  0000 0000

Many of the following functions accept markers for arguments as well as integers. (See section Markers.) More precisely, the actual parameters to such functions may be either integers or markers, which is why we often give these parameters the name int-or-marker. When the actual parameter is a marker, the position value of the marker is used and the buffer of the marker is ignored.

Floating Point Basics

Emacs version 19 supports floating point numbers, if compiled with the macro LISP_FLOAT_TYPE defined. The precise range of floating point numbers is machine-specific; it is the same as the range of the C data type double on the machine in question.

The printed representation for floating point numbers requires either a decimal point (with at least one digit following), an exponent, or both. For example, `1500.0', `15e2', `15.0e2', `1.5e3', and `.15e4' are five ways of writing a floating point number whose value is 1500. They are all equivalent. You can also use a minus sign to write negative floating point numbers, as in `-1.0'.

You can use logb to extract the binary exponent of a floating point number (or estimate the logarithm of an integer):

Function: logb number

This function returns the binary exponent of number. More precisely, the value is the logarithm of number base 2, rounded down to an integer.

Type Predicates for Numbers

The functions in this section test whether the argument is a number or whether it is a certain sort of number. The functions integerp and floatp can take any type of Lisp object as argument (the predicates would not be of much use otherwise); but the zerop predicate requires a number as its argument. See also integer-or-marker-p and number-or-marker-p, in section Predicates on Markers.

Function: floatp object

This predicate tests whether its argument is a floating point number and returns t if so, nil otherwise.

floatp does not exist in Emacs versions 18 and earlier.

Function: integerp object

This predicate tests whether its argument is an integer, and returns t if so, nil otherwise.

Function: numberp object

This predicate tests whether its argument is a number (either integer or floating point), and returns t if so, nil otherwise.

Function: natnump object

The natnump predicate (whose name comes from the phrase "natural-number-p") tests to see whether its argument is a nonnegative integer, and returns t if so, nil otherwise. 0 is considered non-negative.

Markers are not converted to integers, hence natnump of a marker is always nil.

People have pointed out that this function is misnamed, because the term "natural number" is usually understood as excluding zero. We are open to suggestions for a better name to use in a future version.

Function: zerop number

This predicate tests whether its argument is zero, and returns t if so, nil otherwise. The argument must be a number.

These two forms are equivalent: (zerop x) == (= x 0).

Comparison of Numbers

Floating point numbers in Emacs Lisp actually take up storage, and there can be many distinct floating point number objects with the same numeric value. If you use eq to compare them, then you test whether two values are the same object. If you want to compare just the numeric values, use =.

If you use eq to compare two integers, it always returns t if they have the same value. This is sometimes useful, because eq accepts arguments of any type and never causes an error, whereas = signals an error if the arguments are not numbers or markers. However, it is a good idea to use = if you can, even for comparing integers, just in case we change the representation of integers in a future Emacs version.

There is another wrinkle: because floating point arithmetic is not exact, it is often a bad idea to check for equality of two floating point values. Usually it is better to test for approximate equality. Here's a function to do this:

(defvar fuzz-factor 1.0e-6)

(defun approx-equal (x y)
  (< (/ (abs (- x y))
        (max (abs x) (abs y)))
     fuzz-factor))

Common Lisp note: because of the way numbers are implemented in Common Lisp, you generally need to use `=' to test for equality between numbers of any kind.

Function: = number-or-marker1 number-or-marker2

This function tests whether its arguments are the same number, and returns t if so, nil otherwise.

Function: /= number-or-marker1 number-or-marker2

This function tests whether its arguments are not the same number, and returns t if so, nil otherwise.

Function: < number-or-marker1 number-or-marker2

This function tests whether its first argument is strictly less than its second argument. It returns t if so, nil otherwise.

Function: <= number-or-marker1 number-or-marker2

This function tests whether its first argument is less than or equal to its second argument. It returns t if so, nil otherwise.

Function: > number-or-marker1 number-or-marker2

This function tests whether its first argument is strictly greater than its second argument. It returns t if so, nil otherwise.

Function: >= number-or-marker1 number-or-marker2

This function tests whether its first argument is greater than or equal to its second argument. It returns t if so, nil otherwise.

Function: max number-or-marker &rest numbers-or-markers

This function returns the largest of its arguments.

(max 20)
     => 20
(max 1 2)
     => 2
(max 1 3 2)
     => 3

Function: min number-or-marker &rest numbers-or-markers

This function returns the smallest of its arguments.

Numeric Conversions

To convert an integer to floating point, use the function float.

Function: float number

This returns number converted to floating point. If number is already a floating point number, float returns it unchanged.

There are four functions to convert floating point numbers to integers; they differ in how they round. You can call these functions with an integer argument also; if you do, they return it without change.

Function: truncate number

This returns number, converted to an integer by rounding towards zero.

Function: floor number &optional divisor

This returns number, converted to an integer by rounding downward (towards negative infinity).

If divisor is specified, number is divided by divisor before the floor is taken; this is the division operation that corresponds to mod. An arith-error results if divisor is 0.

Function: ceiling number

This returns number, converted to an integer by rounding upward (towards positive infinity).

Function: round number

This returns number, converted to an integer by rounding towards the nearest integer.

Arithmetic Operations

Emacs Lisp provides the traditional four arithmetic operations: addition, subtraction, multiplication, and division. Remainder and modulus functions supplement the division functions. The functions to add or subtract 1 are provided because they are traditional in Lisp and commonly used.

All of these functions except % return a floating point value if any argument is floating.

It is important to note that in GNU Emacs Lisp, arithmetic functions do not check for overflow. Thus (1+ 8388607) may equal -8388608, depending on your hardware.

Function: 1+ number-or-marker

This function returns number-or-marker plus 1. For example,

(setq foo 4)
     => 4
(1+ foo)
     => 5

This function is not analogous to the C operator ++---it does not increment a variable. It just computes a sum. Thus,

foo
     => 4

If you want to increment the variable, you must use setq, like this:

(setq foo (1+ foo))
     => 5

Function: 1- number-or-marker

This function returns number-or-marker minus 1.

Function: abs number

This returns the absolute value of number.

Function: + &rest numbers-or-markers

This function adds its arguments together. When given no arguments, + returns 0. It does not check for overflow.

(+)
     => 0
(+ 1)
     => 1
(+ 1 2 3 4)
     => 10

Function: - &optional number-or-marker &rest other-numbers-or-markers

The - function serves two purposes: negation and subtraction. When - has a single argument, the value is the negative of the argument. When there are multiple arguments, each of the other-numbers-or-markers is subtracted from number-or-marker, cumulatively. If there are no arguments, the result is 0. This function does not check for overflow.

(- 10 1 2 3 4)
     => 0
(- 10)
     => -10
(-)
     => 0

Function: * &rest numbers-or-markers

This function multiplies its arguments together, and returns the product. When given no arguments, * returns 1. It does not check for overflow.

(*)
     => 1
(* 1)
     => 1
(* 1 2 3 4)
     => 24

Function: / dividend divisor &rest divisors

This function divides dividend by divisors and returns the quotient. If there are additional arguments divisors, then dividend is divided by each divisor in turn. Each argument may be a number or a marker.

If all the arguments are integers, then the result is an integer too. This means the result has to be rounded. On most machines, the result is rounded towards zero after each division, but some machines may round differently with negative arguments. This is because the Lisp function / is implemented using the C division operator, which has the same possibility for machine-dependent rounding. As a practical matter, all known machines round in the standard fashion.

If you divide by 0, an arith-error error is signaled. (See section Errors.)

(/ 6 2)
     => 3
(/ 5 2)
     => 2
(/ 25 3 2)
     => 4
(/ -17 6)
     => -2

Since the division operator in Emacs Lisp is implemented using the division operator in C, the result of dividing negative numbers may in principle vary from machine to machine, depending on how they round the result. Thus, the result of (/ -17 6) could be -3 on some machines. In practice, all known machines round the quotient towards 0.

Function: % dividend divisor

This function returns the integer remainder after division of dividend by divisor. The arguments must be integers or markers.

For negative arguments, the value is in principle machine-dependent since the quotient is; but in practice, all known machines behave alike.

An arith-error results if divisor is 0.

(% 9 4)
     => 1
(% -9 4)
     => -1
(% 9 -4)
     => 1
(% -9 -4)
     => -1

For any two integers dividend and divisor,

(+ (% dividend divisor)
   (* (/ dividend divisor) divisor))

always equals dividend.

Function: mod dividend divisor

This function returns the value of dividend modulo divisor; in other words, the remainder after division of dividend by divisor, but with the same sign as divisor. The arguments must be numbers or markers.

Unlike %, the result is well-defined for negative arguments. Also, floating point arguments are permitted.

An arith-error results if divisor is 0.

(mod 9 4)
     => 1
(mod -9 4)
     => 3
(mod 9 -4)
     => -3
(mod -9 -4)
     => -1

For any two numbers dividend and divisor,

(+ (mod dividend divisor)
   (* (floor dividend divisor) divisor))

always equals dividend, subject to rounding error if either argument is floating point.

Bitwise Operations on Integers

In a computer, an integer is represented as a binary number, a sequence of bits (digits which are either zero or one). A bitwise operation acts on the individual bits of such a sequence. For example, shifting moves the whole sequence left or right one or more places, reproducing the same pattern "moved over".

The bitwise operations in Emacs Lisp apply only to integers.

Function: lsh integer1 count

lsh, which is an abbreviation for logical shift, shifts the bits in integer1 to the left count places, or to the right if count is negative. If count is negative, lsh shifts zeros into the most-significant bit, producing a positive result even if integer1 is negative. Contrast this with ash, below.

Thus, the decimal number 5 is the binary number 00000101. Shifted once to the left, with a zero put in the one's place, the number becomes 00001010, decimal 10.

Here are two examples of shifting the pattern of bits one place to the left. Since the contents of the rightmost place has been moved one place to the left, a value has to be inserted into the rightmost place. With lsh, a zero is placed into the rightmost place. (These examples show only the low-order eight bits of the binary pattern; the rest are all zero.)

(lsh 5 1)
     => 10

;; Decimal 5 becomes decimal 10.
00000101 => 00001010

(lsh 7 1)
     => 14

;; Decimal 7 becomes decimal 14.
00000111 => 00001110

As the examples illustrate, shifting the pattern of bits one place to the left produces a number that is twice the value of the previous number.

Note, however that functions do not check for overflow, and a returned value may be negative (and in any case, no more than a 24 bit value) when an integer is sufficiently left shifted.

For example, left shifting 8,388,607 produces -2:

(lsh 8388607 1)          ; left shift
     => -2

In binary, in the 24 bit implementation, the numbers looks like this:

;; Decimal 8,388,607
0111 1111  1111 1111  1111 1111         

which becomes the following when left shifted:

;; Decimal -2
1111 1111  1111 1111  1111 1110         

Shifting the pattern of bits two places to the left produces results like this (with 8-bit binary numbers):

(lsh 3 2)
     => 12

;; Decimal 3 becomes decimal 12.
00000011 => 00001100       

On the other hand, shifting the pattern of bits one place to the right looks like this:

(lsh 6 -1)
     => 3

;; Decimal 6 becomes decimal 3.
00000110 => 00000011       

(lsh 5 -1)
     => 2

;; Decimal 5 becomes decimal 2.
00000101 => 00000010       

As the example illustrates, shifting the pattern of bits one place to the right divides the value of the binary number by two, rounding downward.

Function: ash integer1 count

ash (arithmetic shift) shifts the bits in integer1 to the left count places, or to the right if count is negative.

ash gives the same results as lsh except when integer1 and count are both negative. In that case, ash puts a one in the leftmost position, while lsh puts a zero in the leftmost position.

Thus, with ash, shifting the pattern of bits one place to the right looks like this:

(ash -6 -1)
     => -3            

;; Decimal -6
;; becomes decimal -3.

1111 1111  1111 1111  1111 1010
     => 
1111 1111  1111 1111  1111 1101

In contrast, shifting the pattern of bits one place to the right with lsh looks like this:

(lsh -6 -1)
     => 8388605       

;; Decimal -6
;; becomes decimal 8,388,605.

1111 1111  1111 1111  1111 1010
     => 
0111 1111  1111 1111  1111 1101

In this case, the 1 in the leftmost position is shifted one place to the right, and a zero is shifted into the leftmost position.

Here are other examples:

                   ;               24-bit binary values

(lsh 5 2)          ;   5  =  0000 0000  0000 0000  0000 0101
     => 20         ;  20  =  0000 0000  0000 0000  0001 0100
(ash 5 2)
     => 20
(lsh -5 2)         ;  -5  =  1111 1111  1111 1111  1111 1011
     => -20        ; -20  =  1111 1111  1111 1111  1110 1100
(ash -5 2)
     => -20
(lsh 5 -2)         ;   5  =  0000 0000  0000 0000  0000 0101
     => 1          ;   1  =  0000 0000  0000 0000  0000 0001
(ash 5 -2)
     => 1
(lsh -5 -2)        ;  -5  =  1111 1111  1111 1111  1111 1011
     => 4194302    ;         0011 1111  1111 1111  1111 1110
(ash -5 -2)        ;  -5  =  1111 1111  1111 1111  1111 1011
     => -2         ;  -2  =  1111 1111  1111 1111  1111 1110

Function: logand &rest ints-or-markers

This function returns the "logical and" of the arguments: the nth bit is set in the result if, and only if, the nth bit is set in all the arguments. ("Set" means that the value of the bit is 1 rather than 0.)

For example, using 4-bit binary numbers, the "logical and" of 13 and 12 is 12: 1101 combined with 1100 produces 1100.

In both the binary numbers, the leftmost two bits are set (i.e., they are 1's), so the leftmost two bits of the returned value are set. However, for the rightmost two bits, each is zero in at least one of the arguments, so the rightmost two bits of the returned value are 0's.

Therefore,

(logand 13 12)
     => 12

If logand is not passed any argument, it returns a value of -1. This number is an identity element for logand because its binary representation consists entirely of ones. If logand is passed just one argument, it returns that argument.

                   ;                24-bit binary values

(logand 14 13)     ; 14  =  0000 0000  0000 0000  0000 1110
                   ; 13  =  0000 0000  0000 0000  0000 1101
     => 12         ; 12  =  0000 0000  0000 0000  0000 1100

(logand 14 13 4)   ; 14  =  0000 0000  0000 0000  0000 1110
                   ; 13  =  0000 0000  0000 0000  0000 1101
                   ;  4  =  0000 0000  0000 0000  0000 0100
     => 4          ;  4  =  0000 0000  0000 0000  0000 0100

(logand)
     => -1         ; -1  =  1111 1111  1111 1111  1111 1111

Function: logior &rest ints-or-markers

This function returns the "inclusive or" of its arguments: the nth bit is set in the result if, and only if, the nth bit is set in at least one of the arguments. If there are no arguments, the result is zero, which is an identity element for this operation. If logior is passed just one argument, it returns that argument.

                   ;               24-bit binary values

(logior 12 5)      ; 12  =  0000 0000  0000 0000  0000 1100
                   ;  5  =  0000 0000  0000 0000  0000 0101
     => 13         ; 13  =  0000 0000  0000 0000  0000 1101

(logior 12 5 7)    ; 12  =  0000 0000  0000 0000  0000 1100
                   ;  5  =  0000 0000  0000 0000  0000 0101
                   ;  7  =  0000 0000  0000 0000  0000 0111
     => 15         ; 15  =  0000 0000  0000 0000  0000 1111

Function: logxor &rest ints-or-markers

This function returns the "exclusive or" of its arguments: the nth bit is set in the result if, and only if, the nth bit is set in an odd number of the arguments. If there are no arguments, the result is 0. If logxor is passed just one argument, it returns that argument.

                   ;               24-bit binary values

(logxor 12 5)      ; 12  =  0000 0000  0000 0000  0000 1100
                   ;  5  =  0000 0000  0000 0000  0000 0101
     => 9          ;  9  =  0000 0000  0000 0000  0000 1001

(logxor 12 5 7)    ; 12  =  0000 0000  0000 0000  0000 1100
                   ;  5  =  0000 0000  0000 0000  0000 0101
                   ;  7  =  0000 0000  0000 0000  0000 0111
     => 14         ; 14  =  0000 0000  0000 0000  0000 1110

Function: lognot integer

This function returns the logical complement of its argument: the nth bit is one in the result if, and only if, the nth bit is zero in integer, and vice-versa.

;;  5  =  0000 0000  0000 0000  0000 0101
;; becomes
;; -6  =  1111 1111  1111 1111  1111 1010

(lognot 5)             
     => -6

Transcendental Functions

These mathematical functions are available if floating point is supported. They allow integers as well as floating point numbers as arguments.

Function: sin arg

Function: cos arg

Function: tan arg

These are the ordinary trigonometric functions, with argument measured in radians.

Function: asin arg

The value of (asin arg) is a number between - pi / 2 and pi / 2 (inclusive) whose sine is arg; if, however, arg is out of range (outside [-1, 1]), then the result is a NaN.

Function: acos arg

The value of (acos arg) is a number between 0 and pi (inclusive) whose cosine is arg; if, however, arg is out of range (outside [-1, 1]), then the result is a NaN.

Function: atan arg

The value of (atan arg) is a number between - pi / 2 and pi / 2 (exclusive) whose tangent is arg.

Function: exp arg

This is the exponential function; it returns e to the power arg.

Function: log arg &optional base

This function returns the logarithm of arg, with base base. If you don't specify base, the base e is used. If arg is negative, the result is a NaN.

Function: log10 arg

This function returns the logarithm of arg, with base 10. If arg is negative, the result is a NaN.

Function: expt x y

This function returns x raised to power y.

Function: sqrt arg

This returns the square root of arg.

Random Numbers

In a computer, a series of pseudo-random numbers is generated in a deterministic fashion. The numbers are not truly random, but they have certain properties that mimic a random series. For example, all possible values occur equally often in a pseudo-random series.

In Emacs, pseudo-random numbers are generated from a "seed" number. Starting from any given seed, the random function always generates the same sequence of numbers. Emacs always starts with the same seed value, so the sequence of values of random is actually the same in each Emacs run! For example, in one operating system, the first call to (random) after you start Emacs always returns -1457731, and the second one always returns -7692030. This is helpful for debugging.

If you want truly unpredictable random numbers, execute (random t). This chooses a new seed based on the current time of day and on Emacs' process ID number.

Function: random &optional limit

This function returns a pseudo-random integer. When called more than once, it returns a series of pseudo-random integers.

If limit is nil, then the value may in principle be any integer. If limit is a positive integer, the value is chosen to be nonnegative and less than limit (only in Emacs 19).

If limit is t, it means to choose a new seed based on the current time of day and on Emacs's process ID number.

On some machines, any integer representable in Lisp may be the result of random. On other machines, the result can never be larger than a certain maximum or less than a certain (negative) minimum.

Strings and Characters

A string in Emacs Lisp is an array that contains an ordered sequence of characters. Strings are used as names of symbols, buffers, and files, to send messages to users, to hold text being copied between buffers, and for many other purposes. Because strings are so important, many functions are provided expressly for manipulating them. Emacs Lisp programs use strings more often than individual characters.

See section Putting Keyboard Events in Strings, for special considerations when using strings of keyboard character events.

Introduction to Strings and Characters

Strings in Emacs Lisp are arrays that contain an ordered sequence of characters. Characters are represented in Emacs Lisp as integers; whether an integer was intended as a character or not is determined only by how it is used. Thus, strings really contain integers.

The length of a string (like any array) is fixed and independent of the string contents, and cannot be altered. Strings in Lisp are not terminated by a distinguished character code. (By contrast, strings in C are terminated by a character with ASCII code 0.) This means that any character, including the null character (ASCII code 0), is a valid element of a string.

Since strings are considered arrays, you can operate on them with the general array functions. (See section Sequences, Arrays, and Vectors.) For example, you can access or change individual characters in a string using the functions aref and aset (see section Functions that Operate on Arrays).

Each character in a string is stored in a single byte. Therefore, numbers not in the range 0 to 255 are truncated when stored into a string. This means that a string takes up much less memory than a vector of the same length.

Sometimes key sequences are represented as strings. When a string is a key sequence, string elements in the range 128 to 255 represent meta characters (which are extremely large integers) rather than keyboard events in the range 128 to 255.

Strings cannot hold characters that have the hyper, super or alt modifiers; they can hold ASCII control characters, but no others. They do not distinguish case in ASCII control characters. See section Character Type, for more information about representation of meta and other modifiers for keyboard input characters.

Like a buffer, a string can contain text properties for the characters in it, as well as the characters themselves. See section Text Properties.

See section Text, for information about functions that display strings or copy them into buffers. See section Character Type, and section String Type, for information about the syntax of characters and strings.

The Predicates for Strings

For more information about general sequence and array predicates, see section Sequences, Arrays, and Vectors, and section Arrays.

Function: stringp object

This function returns t if object is a string, nil otherwise.

Function: char-or-string-p object

This function returns t if object is a string or a character (i.e., an integer), nil otherwise.

Creating Strings

The following functions create strings, either from scratch, or by putting strings together, or by taking them apart.

Function: make-string count character

This function returns a string made up of count repetitions of character. If count is negative, an error is signaled.

(make-string 5 ?x)
     => "xxxxx"
(make-string 0 ?x)
     => ""

Other functions to compare with this one include char-to-string (see section Conversion of Characters and Strings), make-vector (see section Vectors), and make-list (see section Building Cons Cells and Lists).

Function: substring string start &optional end

This function returns a new string which consists of those characters from string in the range from (and including) the character at the index start up to (but excluding) the character at the index end. The first character is at index zero.

(substring "abcdefg" 0 3)
     => "abc"

Here the index for `a' is 0, the index for `b' is 1, and the index for `c' is 2. Thus, three letters, `abc', are copied from the full string. The index 3 marks the character position up to which the substring is copied. The character whose index is 3 is actually the fourth character in the string.

A negative number counts from the end of the string, so that -1 signifies the index of the last character of the string. For example:

(substring "abcdefg" -3 -1)
     => "ef"

In this example, the index for `e' is -3, the index for `f' is -2, and the index for `g' is -1. Therefore, `e' and `f' are included, and `g' is excluded.

When nil is used as an index, it falls after the last character in the string. Thus:

(substring "abcdefg" -3 nil)
     => "efg"

Omitting the argument end is equivalent to specifying nil. It follows that (substring string 0) returns a copy of all of string.

(substring "abcdefg" 0)
     => "abcdefg"

But we recommend copy-sequence for this purpose (see section Sequences).

A wrong-type-argument error is signaled if either start or end are non-integers. An args-out-of-range error is signaled if start indicates a character following end, or if either integer is out of range for string.

Contrast this function with buffer-substring (see section Examining Buffer Contents), which returns a string containing a portion of the text in the current buffer. The beginning of a string is at index 0, but the beginning of a buffer is at index 1.

Function: concat &rest sequences

This function returns a new string consisting of the characters in the arguments passed to it. The arguments may be strings, lists of numbers, or vectors of numbers; they are not themselves changed. If no arguments are passed to concat, it returns an empty string.

(concat "abc" "-def")
     => "abc-def"
(concat "abc" (list 120 (+ 256 121)) [122])
     => "abcxyz"
(concat "The " "quick brown " "fox.")
     => "The quick brown fox."
(concat)
     => ""

The second example above shows how characters stored in strings are taken modulo 256. In other words, each character in the string is stored in one byte.

The concat function always constructs a new string that is not eq to any existing string.

When an argument is an integer (not a sequence of integers), it is converted to a string of digits making up the decimal printed representa