(condition-case err
;; @r{Protected form.}
(/ dividend divisor)
+@end group
+@group
;; @r{The handler.}
(arith-error ; @r{Condition.}
;; @r{Display the usual message for this error.}
@var{default}. @var{default} should be an expression to compute the
value; be careful in writing it, because it can be evaluated on more
than one occasion.
+@end defmac
-The following additional keywords are accepted:
+ @code{defcustom} accepts the following additional keywords:
@table @code
@item :type @var{type}
@code{set-default}.
@end table
@end table
-@end defmac
The @code{:require} option is useful for an option that turns on the
operation of a certain feature. Assuming that the package is coded to
----------- Buffer: backtrace-output ------------
backtrace()
(list ...computing arguments...)
+@end group
(progn ...)
eval((progn (1+ var) (list (quote testing) (backtrace))))
(setq ...)
(with-output-to-temp-buffer ...)
eval-region(1973 2142 #<buffer *scratch*>)
byte-code("... for eval-print-last-sexp ...")
+@group
eval-print-last-sexp(nil)
* call-interactively(eval-print-last-sexp)
----------- Buffer: backtrace-output ------------
like the way successive kills in Emacs move down the kill ring.
@end defun
+@need 1500
@node Font Names
@section Looking up Font Names
@result{} 14
@end example
+@need 1500
More generally,
@example
``dotted list'' since its final @sc{cdr} is not @code{nil} as required
in a true list.
-Here is an example of using @code{append}:
+The @code{append} function also allows integers as arguments. It
+converts them to strings of digits, making up the decimal print
+representation of the integer, and then uses the strings instead of the
+original integers. @strong{Don't use this feature; we plan to eliminate
+it. If you already use this feature, change your programs now!} The
+proper way to convert an integer to a decimal number in this way is with
+@code{format} (@pxref{Formatting Strings}) or @code{number-to-string}
+(@pxref{String Conversion}).
+@end defun
+
+ Here is an example of using @code{append}:
@example
@group
@end group
@end example
-You can see how @code{append} works by looking at a box diagram. The
+ You can see how @code{append} works by looking at a box diagram. The
variable @code{trees} is set to the list @code{(pine oak)} and then the
variable @code{more-trees} is set to the list @code{(maple birch pine
oak)}. However, the variable @code{trees} continues to refer to the
@end group
@end smallexample
-An empty sequence contributes nothing to the value returned by
+ An empty sequence contributes nothing to the value returned by
@code{append}. As a consequence of this, a final @code{nil} argument
-forces a copy of the previous argument.
+forces a copy of the previous argument:
@example
@group
This once was the usual way to copy a list, before the function
@code{copy-sequence} was invented. @xref{Sequences Arrays Vectors}.
-Here we show the use of vectors and strings as arguments to @code{append}:
+ Here we show the use of vectors and strings as arguments to @code{append}:
@example
@group
@end group
@end example
-With the help of @code{apply} (@pxref{Calling Functions}), we can append
+ With the help of @code{apply} (@pxref{Calling Functions}), we can append
all the lists in a list of lists:
@example
@end group
@end example
-If no @var{sequences} are given, @code{nil} is returned:
+ If no @var{sequences} are given, @code{nil} is returned:
@example
@group
@end group
@end example
-Here are some examples where the final argument is not a list:
+ Here are some examples where the final argument is not a list:
@example
(append '(x y) 'z)
resulting list. Instead, the sequence becomes the final @sc{cdr}, like
any other non-list final argument.
-The @code{append} function also allows integers as arguments. It
-converts them to strings of digits, making up the decimal print
-representation of the integer, and then uses the strings instead of the
-original integers. @strong{Don't use this feature; we plan to eliminate
-it. If you already use this feature, change your programs now!} The
-proper way to convert an integer to a decimal number in this way is with
-@code{format} (@pxref{Formatting Strings}) or @code{number-to-string}
-(@pxref{String Conversion}).
-@end defun
-
@defun reverse list
This function creates a new list whose elements are the elements of
@var{list}, but in reverse order. The original argument @var{list} is
@table @code
@item font-lock-comment-face
@vindex font-lock-comment-face
-@kindex font-lock-comment-face @r{(face name)}
Used (typically) for comments.
@item font-lock-string-face
@vindex font-lock-string-face
-@kindex font-lock-string-face @r{(face name)}
Used (typically) for string constants.
@item font-lock-keyword-face
@vindex font-lock-keyword-face
-@kindex font-lock-keyword-face @r{(face name)}
Used (typically) for keywords---names that have special syntactic
significance, like @code{for} and @code{if} in C.
@item font-lock-builtin-face
@vindex font-lock-builtin-face
-@kindex font-lock-builtin-face @r{(face name)}
Used (typically) for built-in function names.
@item font-lock-function-name-face
@vindex font-lock-function-name-face
-@kindex font-lock-function-name-face @r{(face name)}
Used (typically) for the name of a function being defined or declared,
in a function definition or declaration.
@item font-lock-variable-name-face
@vindex font-lock-variable-name-face
-@kindex font-lock-variable-name-face @r{(face name)}
Used (typically) for the name of a variable being defined or declared,
in a variable definition or declaration.
@item font-lock-type-face
@vindex font-lock-type-face
-@kindex font-lock-type-face @r{(face name)}
Used (typically) for names of user-defined data types,
where they are defined and where they are used.
@item font-lock-constant-face
@vindex font-lock-constant-face
-@kindex font-lock-constant-face @r{(face name)}
Used (typically) for constant names.
@item font-lock-warning-face
@vindex font-lock-warning-face
-@kindex font-lock-warning-face @r{(face name)}
Used (typically) for constructs that are peculiar, or that greatly
change the meaning of other text. For example, this is used for
@samp{;;;###autoload} cookies in Emacs Lisp, and for @code{#error}
((listp x)
;; If X is a list, add its elements to LIST.
(setq list (append x list)))
-@need 3000
(t
;; We handle only symbols and lists.
(error "Invalid argument %s in add-on" x))))
@end example
@end defun
-@vindex system-name
The symbol @code{system-name} is a variable as well as a function. In
fact, the function returns whatever value the variable
@code{system-name} currently holds. Thus, you can set the variable
@example
@group
-(save-excursion
- @var{forms})
+(save-excursion @var{forms})
@equiv{}
(let ((old-buf (current-buffer))
(old-pnt (point-marker))
+@end group
(old-mark (copy-marker (mark-marker))))
(unwind-protect
(progn @var{forms})
(set-buffer old-buf)
+@group
(goto-char old-pnt)
(set-marker (mark-marker) old-mark)))
@end group
the string @samp{fo}. Still trivial. To do something more powerful, you
need to use one of the special characters. Here is a list of them:
-@need 1200
+@need 800
@table @asis
@item @samp{.}@: @r{(Period)}
@cindex @samp{.} in regexp
the handling of regexps in programs such as @code{grep}.
@item @samp{^}
-@cindex @samp{^} in regexp
@cindex beginning of line in regexp
is a special character that matches the empty string, but only at the
beginning of a line in the text being matched. Otherwise it fails to
projects / emacs.git / commitdiff