Mercurial > emacs
annotate lispref/streams.texi @ 56026:bb6720f21c54
Revision: miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-396
Tweak arch tagging to make build/install-in-place less annoying
Previously, autoconf-created Makefiles and the like would contain
duplicate taglines (unfortunately, autoconf doesn't seem to have a
`strip in generated file' comment mechanism) leading to conflicts, and
installing in place would create unknown directories and copies of
source directories (leading to conflicts with the source directories).
This changeset makes all autoconf-processed files use explicit id-tags
and adds .arch-inventory entries to ignore installation directories.
author | Miles Bader <miles@gnu.org> |
---|---|
date | Fri, 11 Jun 2004 02:39:51 +0000 |
parents | 2ac351855ad7 |
children | 914a0d13f0bf 4c90ffeb71c5 |
rev | line source |
---|---|
6381 | 1 @c -*-texinfo-*- |
2 @c This is part of the GNU Emacs Lisp Reference Manual. | |
27189 | 3 @c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1998, 1999 |
49600
23a1cea22d13
Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents:
31078
diff
changeset
|
4 @c Free Software Foundation, Inc. |
6381 | 5 @c See the file elisp.texi for copying conditions. |
6 @setfilename ../info/streams | |
7115
9a9e88e65617
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6381
diff
changeset
|
7 @node Read and Print, Minibuffers, Debugging, Top |
6381 | 8 @comment node-name, next, previous, up |
9 @chapter Reading and Printing Lisp Objects | |
10 | |
11 @dfn{Printing} and @dfn{reading} are the operations of converting Lisp | |
12 objects to textual form and vice versa. They use the printed | |
7115
9a9e88e65617
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6381
diff
changeset
|
13 representations and read syntax described in @ref{Lisp Data Types}. |
6381 | 14 |
15 This chapter describes the Lisp functions for reading and printing. | |
16 It also describes @dfn{streams}, which specify where to get the text (if | |
17 reading) or where to put it (if printing). | |
18 | |
19 @menu | |
20 * Streams Intro:: Overview of streams, reading and printing. | |
21 * Input Streams:: Various data types that can be used as input streams. | |
22 * Input Functions:: Functions to read Lisp objects from text. | |
23 * Output Streams:: Various data types that can be used as output streams. | |
24 * Output Functions:: Functions to print Lisp objects as text. | |
25 * Output Variables:: Variables that control what the printing functions do. | |
26 @end menu | |
27 | |
28 @node Streams Intro | |
29 @section Introduction to Reading and Printing | |
30 @cindex Lisp reader | |
31 @cindex printing | |
32 @cindex reading | |
33 | |
34 @dfn{Reading} a Lisp object means parsing a Lisp expression in textual | |
35 form and producing a corresponding Lisp object. This is how Lisp | |
36 programs get into Lisp from files of Lisp code. We call the text the | |
37 @dfn{read syntax} of the object. For example, the text @samp{(a .@: 5)} | |
38 is the read syntax for a cons cell whose @sc{car} is @code{a} and whose | |
39 @sc{cdr} is the number 5. | |
40 | |
41 @dfn{Printing} a Lisp object means producing text that represents that | |
21007
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
42 object---converting the object to its @dfn{printed representation} |
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
43 (@pxref{Printed Representation}). Printing the cons cell described |
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
44 above produces the text @samp{(a .@: 5)}. |
6381 | 45 |
46 Reading and printing are more or less inverse operations: printing the | |
47 object that results from reading a given piece of text often produces | |
48 the same text, and reading the text that results from printing an object | |
49 usually produces a similar-looking object. For example, printing the | |
50 symbol @code{foo} produces the text @samp{foo}, and reading that text | |
51 returns the symbol @code{foo}. Printing a list whose elements are | |
52 @code{a} and @code{b} produces the text @samp{(a b)}, and reading that | |
7219 | 53 text produces a list (but not the same list) with elements @code{a} |
6381 | 54 and @code{b}. |
55 | |
25875 | 56 However, these two operations are not precisely inverse to each other. |
57 There are three kinds of exceptions: | |
6381 | 58 |
59 @itemize @bullet | |
60 @item | |
61 Printing can produce text that cannot be read. For example, buffers, | |
21007
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
62 windows, frames, subprocesses and markers print as text that starts |
6381 | 63 with @samp{#}; if you try to read this text, you get an error. There is |
64 no way to read those data types. | |
65 | |
66 @item | |
67 One object can have multiple textual representations. For example, | |
68 @samp{1} and @samp{01} represent the same integer, and @samp{(a b)} and | |
69 @samp{(a .@: (b))} represent the same list. Reading will accept any of | |
70 the alternatives, but printing must choose one of them. | |
12098 | 71 |
72 @item | |
73 Comments can appear at certain points in the middle of an object's | |
74 read sequence without affecting the result of reading it. | |
6381 | 75 @end itemize |
76 | |
77 @node Input Streams | |
78 @section Input Streams | |
79 @cindex stream (for reading) | |
80 @cindex input stream | |
81 | |
82 Most of the Lisp functions for reading text take an @dfn{input stream} | |
83 as an argument. The input stream specifies where or how to get the | |
84 characters of the text to be read. Here are the possible types of input | |
85 stream: | |
86 | |
87 @table @asis | |
88 @item @var{buffer} | |
89 @cindex buffer input stream | |
90 The input characters are read from @var{buffer}, starting with the | |
91 character directly after point. Point advances as characters are read. | |
92 | |
93 @item @var{marker} | |
94 @cindex marker input stream | |
95 The input characters are read from the buffer that @var{marker} is in, | |
96 starting with the character directly after the marker. The marker | |
97 position advances as characters are read. The value of point in the | |
98 buffer has no effect when the stream is a marker. | |
99 | |
100 @item @var{string} | |
101 @cindex string input stream | |
102 The input characters are taken from @var{string}, starting at the first | |
103 character in the string and using as many characters as required. | |
104 | |
105 @item @var{function} | |
106 @cindex function input stream | |
21682
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
107 The input characters are generated by @var{function}, which must support |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
108 two kinds of calls: |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
109 |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
110 @itemize @bullet |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
111 @item |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
112 When it is called with no arguments, it should return the next character. |
6381 | 113 |
21682
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
114 @item |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
115 When it is called with one argument (always a character), @var{function} |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
116 should save the argument and arrange to return it on the next call. |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
117 This is called @dfn{unreading} the character; it happens when the Lisp |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
118 reader reads one character too many and wants to ``put it back where it |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
119 came from''. In this case, it makes no difference what value |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
120 @var{function} returns. |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
121 @end itemize |
6381 | 122 |
123 @item @code{t} | |
124 @cindex @code{t} input stream | |
125 @code{t} used as a stream means that the input is read from the | |
126 minibuffer. In fact, the minibuffer is invoked once and the text | |
127 given by the user is made into a string that is then used as the | |
31078 | 128 input stream. If Emacs is running in batch mode, standard input is used |
129 instead of the minibuffer. For example, | |
130 @example | |
131 (message "%s" (read t)) | |
132 @end example | |
133 will read a Lisp expression from standard input and print the result | |
134 to standard output. | |
6381 | 135 |
136 @item @code{nil} | |
137 @cindex @code{nil} input stream | |
138 @code{nil} supplied as an input stream means to use the value of | |
139 @code{standard-input} instead; that value is the @dfn{default input | |
140 stream}, and must be a non-@code{nil} input stream. | |
141 | |
142 @item @var{symbol} | |
143 A symbol as input stream is equivalent to the symbol's function | |
144 definition (if any). | |
145 @end table | |
146 | |
7219 | 147 Here is an example of reading from a stream that is a buffer, showing |
6381 | 148 where point is located before and after: |
149 | |
150 @example | |
151 @group | |
152 ---------- Buffer: foo ---------- | |
153 This@point{} is the contents of foo. | |
154 ---------- Buffer: foo ---------- | |
155 @end group | |
156 | |
157 @group | |
158 (read (get-buffer "foo")) | |
159 @result{} is | |
160 @end group | |
161 @group | |
162 (read (get-buffer "foo")) | |
163 @result{} the | |
164 @end group | |
165 | |
166 @group | |
167 ---------- Buffer: foo ---------- | |
168 This is the@point{} contents of foo. | |
169 ---------- Buffer: foo ---------- | |
170 @end group | |
171 @end example | |
172 | |
173 @noindent | |
7219 | 174 Note that the first read skips a space. Reading skips any amount of |
175 whitespace preceding the significant text. | |
6381 | 176 |
177 Here is an example of reading from a stream that is a marker, | |
7219 | 178 initially positioned at the beginning of the buffer shown. The value |
6381 | 179 read is the symbol @code{This}. |
180 | |
181 @example | |
182 @group | |
183 | |
184 ---------- Buffer: foo ---------- | |
185 This is the contents of foo. | |
186 ---------- Buffer: foo ---------- | |
187 @end group | |
188 | |
189 @group | |
190 (setq m (set-marker (make-marker) 1 (get-buffer "foo"))) | |
191 @result{} #<marker at 1 in foo> | |
192 @end group | |
193 @group | |
194 (read m) | |
195 @result{} This | |
196 @end group | |
197 @group | |
198 m | |
7219 | 199 @result{} #<marker at 5 in foo> ;; @r{Before the first space.} |
6381 | 200 @end group |
201 @end example | |
202 | |
203 Here we read from the contents of a string: | |
204 | |
205 @example | |
206 @group | |
207 (read "(When in) the course") | |
208 @result{} (When in) | |
209 @end group | |
210 @end example | |
211 | |
212 The following example reads from the minibuffer. The | |
213 prompt is: @w{@samp{Lisp expression: }}. (That is always the prompt | |
214 used when you read from the stream @code{t}.) The user's input is shown | |
215 following the prompt. | |
216 | |
217 @example | |
218 @group | |
219 (read t) | |
220 @result{} 23 | |
221 ---------- Buffer: Minibuffer ---------- | |
222 Lisp expression: @kbd{23 @key{RET}} | |
223 ---------- Buffer: Minibuffer ---------- | |
224 @end group | |
225 @end example | |
226 | |
227 Finally, here is an example of a stream that is a function, named | |
228 @code{useless-stream}. Before we use the stream, we initialize the | |
229 variable @code{useless-list} to a list of characters. Then each call to | |
7219 | 230 the function @code{useless-stream} obtains the next character in the list |
6381 | 231 or unreads a character by adding it to the front of the list. |
232 | |
233 @example | |
234 @group | |
235 (setq useless-list (append "XY()" nil)) | |
236 @result{} (88 89 40 41) | |
237 @end group | |
238 | |
239 @group | |
240 (defun useless-stream (&optional unread) | |
241 (if unread | |
242 (setq useless-list (cons unread useless-list)) | |
243 (prog1 (car useless-list) | |
244 (setq useless-list (cdr useless-list))))) | |
245 @result{} useless-stream | |
246 @end group | |
247 @end example | |
248 | |
249 @noindent | |
250 Now we read using the stream thus constructed: | |
251 | |
252 @example | |
253 @group | |
254 (read 'useless-stream) | |
255 @result{} XY | |
256 @end group | |
257 | |
258 @group | |
259 useless-list | |
7219 | 260 @result{} (40 41) |
6381 | 261 @end group |
262 @end example | |
263 | |
264 @noindent | |
22138
d4ac295a98b3
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21682
diff
changeset
|
265 Note that the open and close parentheses remain in the list. The Lisp |
7219 | 266 reader encountered the open parenthesis, decided that it ended the |
267 input, and unread it. Another attempt to read from the stream at this | |
268 point would read @samp{()} and return @code{nil}. | |
6381 | 269 |
270 @defun get-file-char | |
271 This function is used internally as an input stream to read from the | |
272 input file opened by the function @code{load}. Don't use this function | |
273 yourself. | |
274 @end defun | |
275 | |
276 @node Input Functions | |
277 @section Input Functions | |
278 | |
279 This section describes the Lisp functions and variables that pertain | |
280 to reading. | |
281 | |
282 In the functions below, @var{stream} stands for an input stream (see | |
283 the previous section). If @var{stream} is @code{nil} or omitted, it | |
284 defaults to the value of @code{standard-input}. | |
285 | |
286 @kindex end-of-file | |
287 An @code{end-of-file} error is signaled if reading encounters an | |
7219 | 288 unterminated list, vector, or string. |
6381 | 289 |
290 @defun read &optional stream | |
291 This function reads one textual Lisp expression from @var{stream}, | |
292 returning it as a Lisp object. This is the basic Lisp input function. | |
293 @end defun | |
294 | |
295 @defun read-from-string string &optional start end | |
296 @cindex string to object | |
297 This function reads the first textual Lisp expression from the text in | |
298 @var{string}. It returns a cons cell whose @sc{car} is that expression, | |
299 and whose @sc{cdr} is an integer giving the position of the next | |
300 remaining character in the string (i.e., the first one not read). | |
301 | |
7219 | 302 If @var{start} is supplied, then reading begins at index @var{start} in |
21682
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
303 the string (where the first character is at index 0). If you specify |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
304 @var{end}, then reading is forced to stop just before that index, as if |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
305 the rest of the string were not there. |
6381 | 306 |
307 For example: | |
308 | |
309 @example | |
310 @group | |
311 (read-from-string "(setq x 55) (setq y 5)") | |
312 @result{} ((setq x 55) . 11) | |
313 @end group | |
314 @group | |
315 (read-from-string "\"A short string\"") | |
316 @result{} ("A short string" . 16) | |
317 @end group | |
318 | |
319 @group | |
320 ;; @r{Read starting at the first character.} | |
321 (read-from-string "(list 112)" 0) | |
322 @result{} ((list 112) . 10) | |
323 @end group | |
324 @group | |
325 ;; @r{Read starting at the second character.} | |
326 (read-from-string "(list 112)" 1) | |
7219 | 327 @result{} (list . 5) |
6381 | 328 @end group |
329 @group | |
330 ;; @r{Read starting at the seventh character,} | |
331 ;; @r{and stopping at the ninth.} | |
332 (read-from-string "(list 112)" 6 8) | |
333 @result{} (11 . 8) | |
334 @end group | |
335 @end example | |
336 @end defun | |
337 | |
338 @defvar standard-input | |
339 This variable holds the default input stream---the stream that | |
340 @code{read} uses when the @var{stream} argument is @code{nil}. | |
341 @end defvar | |
342 | |
343 @node Output Streams | |
344 @section Output Streams | |
345 @cindex stream (for printing) | |
346 @cindex output stream | |
347 | |
348 An output stream specifies what to do with the characters produced | |
349 by printing. Most print functions accept an output stream as an | |
350 optional argument. Here are the possible types of output stream: | |
351 | |
352 @table @asis | |
353 @item @var{buffer} | |
354 @cindex buffer output stream | |
355 The output characters are inserted into @var{buffer} at point. | |
356 Point advances as characters are inserted. | |
357 | |
358 @item @var{marker} | |
359 @cindex marker output stream | |
360 The output characters are inserted into the buffer that @var{marker} | |
7219 | 361 points into, at the marker position. The marker position advances as |
6381 | 362 characters are inserted. The value of point in the buffer has no effect |
22138
d4ac295a98b3
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21682
diff
changeset
|
363 on printing when the stream is a marker, and this kind of printing |
53006
36e0303c65f1
(Output Streams): Clarify behavior of point for marker output streams.
Luc Teirlinck <teirllm@auburn.edu>
parents:
52978
diff
changeset
|
364 does not move point (except that if the marker points at or before the |
36e0303c65f1
(Output Streams): Clarify behavior of point for marker output streams.
Luc Teirlinck <teirllm@auburn.edu>
parents:
52978
diff
changeset
|
365 position of point, point advances with the surrounding text, as |
36e0303c65f1
(Output Streams): Clarify behavior of point for marker output streams.
Luc Teirlinck <teirllm@auburn.edu>
parents:
52978
diff
changeset
|
366 usual). |
6381 | 367 |
368 @item @var{function} | |
369 @cindex function output stream | |
370 The output characters are passed to @var{function}, which is responsible | |
371 for storing them away. It is called with a single character as | |
22138
d4ac295a98b3
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21682
diff
changeset
|
372 argument, as many times as there are characters to be output, and |
d4ac295a98b3
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21682
diff
changeset
|
373 is responsible for storing the characters wherever you want to put them. |
6381 | 374 |
375 @item @code{t} | |
376 @cindex @code{t} output stream | |
377 The output characters are displayed in the echo area. | |
378 | |
379 @item @code{nil} | |
380 @cindex @code{nil} output stream | |
22138
d4ac295a98b3
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21682
diff
changeset
|
381 @code{nil} specified as an output stream means to use the value of |
6381 | 382 @code{standard-output} instead; that value is the @dfn{default output |
22138
d4ac295a98b3
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21682
diff
changeset
|
383 stream}, and must not be @code{nil}. |
6381 | 384 |
385 @item @var{symbol} | |
386 A symbol as output stream is equivalent to the symbol's function | |
387 definition (if any). | |
388 @end table | |
389 | |
7219 | 390 Many of the valid output streams are also valid as input streams. The |
21682
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
391 difference between input and output streams is therefore more a matter |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
392 of how you use a Lisp object, than of different types of object. |
7219 | 393 |
6381 | 394 Here is an example of a buffer used as an output stream. Point is |
395 initially located as shown immediately before the @samp{h} in | |
396 @samp{the}. At the end, point is located directly before that same | |
397 @samp{h}. | |
398 | |
399 @cindex print example | |
400 @example | |
401 @group | |
402 ---------- Buffer: foo ---------- | |
403 This is t@point{}he contents of foo. | |
404 ---------- Buffer: foo ---------- | |
405 @end group | |
406 | |
407 (print "This is the output" (get-buffer "foo")) | |
408 @result{} "This is the output" | |
409 | |
410 @group | |
411 ---------- Buffer: foo ---------- | |
412 This is t | |
413 "This is the output" | |
414 @point{}he contents of foo. | |
415 ---------- Buffer: foo ---------- | |
416 @end group | |
417 @end example | |
418 | |
419 Now we show a use of a marker as an output stream. Initially, the | |
7219 | 420 marker is in buffer @code{foo}, between the @samp{t} and the @samp{h} in |
421 the word @samp{the}. At the end, the marker has advanced over the | |
422 inserted text so that it remains positioned before the same @samp{h}. | |
423 Note that the location of point, shown in the usual fashion, has no | |
424 effect. | |
6381 | 425 |
426 @example | |
427 @group | |
428 ---------- Buffer: foo ---------- | |
22138
d4ac295a98b3
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21682
diff
changeset
|
429 This is the @point{}output |
6381 | 430 ---------- Buffer: foo ---------- |
431 @end group | |
432 | |
433 @group | |
22252
40089afa2b1d
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22138
diff
changeset
|
434 (setq m (copy-marker 10)) |
40089afa2b1d
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22138
diff
changeset
|
435 @result{} #<marker at 10 in foo> |
6381 | 436 @end group |
437 | |
438 @group | |
439 (print "More output for foo." m) | |
440 @result{} "More output for foo." | |
441 @end group | |
442 | |
443 @group | |
444 ---------- Buffer: foo ---------- | |
22138
d4ac295a98b3
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21682
diff
changeset
|
445 This is t |
6381 | 446 "More output for foo." |
22138
d4ac295a98b3
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21682
diff
changeset
|
447 he @point{}output |
6381 | 448 ---------- Buffer: foo ---------- |
449 @end group | |
450 | |
451 @group | |
452 m | |
22252
40089afa2b1d
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22138
diff
changeset
|
453 @result{} #<marker at 34 in foo> |
6381 | 454 @end group |
455 @end example | |
456 | |
457 The following example shows output to the echo area: | |
458 | |
459 @example | |
460 @group | |
461 (print "Echo Area output" t) | |
462 @result{} "Echo Area output" | |
463 ---------- Echo Area ---------- | |
464 "Echo Area output" | |
465 ---------- Echo Area ---------- | |
466 @end group | |
467 @end example | |
468 | |
469 Finally, we show the use of a function as an output stream. The | |
470 function @code{eat-output} takes each character that it is given and | |
471 conses it onto the front of the list @code{last-output} (@pxref{Building | |
472 Lists}). At the end, the list contains all the characters output, but | |
473 in reverse order. | |
474 | |
475 @example | |
476 @group | |
477 (setq last-output nil) | |
478 @result{} nil | |
479 @end group | |
480 | |
481 @group | |
482 (defun eat-output (c) | |
483 (setq last-output (cons c last-output))) | |
484 @result{} eat-output | |
485 @end group | |
486 | |
487 @group | |
488 (print "This is the output" 'eat-output) | |
489 @result{} "This is the output" | |
490 @end group | |
491 | |
492 @group | |
493 last-output | |
49600
23a1cea22d13
Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents:
31078
diff
changeset
|
494 @result{} (10 34 116 117 112 116 117 111 32 101 104 |
6381 | 495 116 32 115 105 32 115 105 104 84 34 10) |
496 @end group | |
497 @end example | |
498 | |
499 @noindent | |
500 Now we can put the output in the proper order by reversing the list: | |
501 | |
502 @example | |
503 @group | |
504 (concat (nreverse last-output)) | |
505 @result{} " | |
506 \"This is the output\" | |
507 " | |
508 @end group | |
509 @end example | |
510 | |
7219 | 511 @noindent |
512 Calling @code{concat} converts the list to a string so you can see its | |
513 contents more clearly. | |
514 | |
6381 | 515 @node Output Functions |
516 @section Output Functions | |
517 | |
21007
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
518 This section describes the Lisp functions for printing Lisp |
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
519 objects---converting objects into their printed representation. |
6381 | 520 |
521 @cindex @samp{"} in printing | |
522 @cindex @samp{\} in printing | |
523 @cindex quoting characters in printing | |
524 @cindex escape characters in printing | |
525 Some of the Emacs printing functions add quoting characters to the | |
526 output when necessary so that it can be read properly. The quoting | |
527 characters used are @samp{"} and @samp{\}; they distinguish strings from | |
528 symbols, and prevent punctuation characters in strings and symbols from | |
7219 | 529 being taken as delimiters when reading. @xref{Printed Representation}, |
530 for full details. You specify quoting or no quoting by the choice of | |
531 printing function. | |
6381 | 532 |
21682
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
533 If the text is to be read back into Lisp, then you should print with |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
534 quoting characters to avoid ambiguity. Likewise, if the purpose is to |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
535 describe a Lisp object clearly for a Lisp programmer. However, if the |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
536 purpose of the output is to look nice for humans, then it is usually |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
537 better to print without quoting. |
6381 | 538 |
22138
d4ac295a98b3
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21682
diff
changeset
|
539 Lisp objects can refer to themselves. Printing a self-referential |
d4ac295a98b3
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21682
diff
changeset
|
540 object in the normal way would require an infinite amount of text, and |
d4ac295a98b3
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21682
diff
changeset
|
541 the attempt could cause infinite recursion. Emacs detects such |
d4ac295a98b3
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21682
diff
changeset
|
542 recursion and prints @samp{#@var{level}} instead of recursively printing |
d4ac295a98b3
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21682
diff
changeset
|
543 an object already being printed. For example, here @samp{#0} indicates |
d4ac295a98b3
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21682
diff
changeset
|
544 a recursive reference to the object at level 0 of the current print |
d4ac295a98b3
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21682
diff
changeset
|
545 operation: |
6381 | 546 |
547 @example | |
548 (setq foo (list nil)) | |
549 @result{} (nil) | |
550 (setcar foo foo) | |
551 @result{} (#0) | |
552 @end example | |
553 | |
554 In the functions below, @var{stream} stands for an output stream. | |
555 (See the previous section for a description of output streams.) If | |
556 @var{stream} is @code{nil} or omitted, it defaults to the value of | |
557 @code{standard-output}. | |
558 | |
559 @defun print object &optional stream | |
560 @cindex Lisp printer | |
561 The @code{print} function is a convenient way of printing. It outputs | |
562 the printed representation of @var{object} to @var{stream}, printing in | |
563 addition one newline before @var{object} and another after it. Quoting | |
564 characters are used. @code{print} returns @var{object}. For example: | |
565 | |
566 @example | |
567 @group | |
568 (progn (print 'The\ cat\ in) | |
569 (print "the hat") | |
570 (print " came back")) | |
49600
23a1cea22d13
Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents:
31078
diff
changeset
|
571 @print{} |
6381 | 572 @print{} The\ cat\ in |
49600
23a1cea22d13
Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents:
31078
diff
changeset
|
573 @print{} |
6381 | 574 @print{} "the hat" |
49600
23a1cea22d13
Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents:
31078
diff
changeset
|
575 @print{} |
6381 | 576 @print{} " came back" |
49600
23a1cea22d13
Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents:
31078
diff
changeset
|
577 @print{} |
6381 | 578 @result{} " came back" |
579 @end group | |
580 @end example | |
581 @end defun | |
582 | |
583 @defun prin1 object &optional stream | |
584 This function outputs the printed representation of @var{object} to | |
7219 | 585 @var{stream}. It does not print newlines to separate output as |
586 @code{print} does, but it does use quoting characters just like | |
587 @code{print}. It returns @var{object}. | |
6381 | 588 |
589 @example | |
590 @group | |
49600
23a1cea22d13
Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents:
31078
diff
changeset
|
591 (progn (prin1 'The\ cat\ in) |
23a1cea22d13
Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents:
31078
diff
changeset
|
592 (prin1 "the hat") |
6381 | 593 (prin1 " came back")) |
594 @print{} The\ cat\ in"the hat"" came back" | |
595 @result{} " came back" | |
596 @end group | |
597 @end example | |
598 @end defun | |
599 | |
600 @defun princ object &optional stream | |
601 This function outputs the printed representation of @var{object} to | |
602 @var{stream}. It returns @var{object}. | |
603 | |
604 This function is intended to produce output that is readable by people, | |
605 not by @code{read}, so it doesn't insert quoting characters and doesn't | |
606 put double-quotes around the contents of strings. It does not add any | |
607 spacing between calls. | |
608 | |
609 @example | |
610 @group | |
611 (progn | |
612 (princ 'The\ cat) | |
613 (princ " in the \"hat\"")) | |
614 @print{} The cat in the "hat" | |
615 @result{} " in the \"hat\"" | |
616 @end group | |
617 @end example | |
618 @end defun | |
619 | |
620 @defun terpri &optional stream | |
621 @cindex newline in print | |
622 This function outputs a newline to @var{stream}. The name stands | |
623 for ``terminate print''. | |
624 @end defun | |
625 | |
626 @defun write-char character &optional stream | |
627 This function outputs @var{character} to @var{stream}. It returns | |
628 @var{character}. | |
629 @end defun | |
630 | |
631 @defun prin1-to-string object &optional noescape | |
632 @cindex object to string | |
633 This function returns a string containing the text that @code{prin1} | |
634 would have printed for the same argument. | |
635 | |
636 @example | |
637 @group | |
638 (prin1-to-string 'foo) | |
639 @result{} "foo" | |
640 @end group | |
641 @group | |
642 (prin1-to-string (mark-marker)) | |
643 @result{} "#<marker at 2773 in strings.texi>" | |
644 @end group | |
645 @end example | |
646 | |
647 If @var{noescape} is non-@code{nil}, that inhibits use of quoting | |
648 characters in the output. (This argument is supported in Emacs versions | |
649 19 and later.) | |
650 | |
651 @example | |
652 @group | |
653 (prin1-to-string "foo") | |
654 @result{} "\"foo\"" | |
655 @end group | |
656 @group | |
657 (prin1-to-string "foo" t) | |
658 @result{} "foo" | |
659 @end group | |
660 @end example | |
661 | |
662 See @code{format}, in @ref{String Conversion}, for other ways to obtain | |
663 the printed representation of a Lisp object as a string. | |
664 @end defun | |
665 | |
22138
d4ac295a98b3
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21682
diff
changeset
|
666 @defmac with-output-to-string body... |
d4ac295a98b3
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21682
diff
changeset
|
667 This macro executes the @var{body} forms with @code{standard-output} set |
d4ac295a98b3
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21682
diff
changeset
|
668 up to feed output into a string. Then it returns that string. |
21007
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
669 |
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
670 For example, if the current buffer name is @samp{foo}, |
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
671 |
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
672 @example |
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
673 (with-output-to-string |
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
674 (princ "The buffer is ") |
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
675 (princ (buffer-name))) |
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
676 @end example |
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
677 |
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
678 @noindent |
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
679 returns @code{"The buffer is foo"}. |
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
680 @end defmac |
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
681 |
6381 | 682 @node Output Variables |
683 @section Variables Affecting Output | |
684 | |
685 @defvar standard-output | |
686 The value of this variable is the default output stream---the stream | |
687 that print functions use when the @var{stream} argument is @code{nil}. | |
688 @end defvar | |
689 | |
54039
69b7ec693d94
(Output Variables): Add print-quoted.
Richard M. Stallman <rms@gnu.org>
parents:
53006
diff
changeset
|
690 @defvar print-quoted |
69b7ec693d94
(Output Variables): Add print-quoted.
Richard M. Stallman <rms@gnu.org>
parents:
53006
diff
changeset
|
691 If this is non-@code{nil}, that means to print quoted forms using |
69b7ec693d94
(Output Variables): Add print-quoted.
Richard M. Stallman <rms@gnu.org>
parents:
53006
diff
changeset
|
692 abbreviated reader syntax. @code{(quote foo)} prints as @code{'foo}, |
69b7ec693d94
(Output Variables): Add print-quoted.
Richard M. Stallman <rms@gnu.org>
parents:
53006
diff
changeset
|
693 @code{(function foo)} as @code{#'foo}, and backquoted forms print |
69b7ec693d94
(Output Variables): Add print-quoted.
Richard M. Stallman <rms@gnu.org>
parents:
53006
diff
changeset
|
694 using modern backquote syntax. |
69b7ec693d94
(Output Variables): Add print-quoted.
Richard M. Stallman <rms@gnu.org>
parents:
53006
diff
changeset
|
695 @end defvar |
69b7ec693d94
(Output Variables): Add print-quoted.
Richard M. Stallman <rms@gnu.org>
parents:
53006
diff
changeset
|
696 |
6381 | 697 @defvar print-escape-newlines |
698 @cindex @samp{\n} in print | |
699 @cindex escape characters | |
700 If this variable is non-@code{nil}, then newline characters in strings | |
701 are printed as @samp{\n} and formfeeds are printed as @samp{\f}. | |
702 Normally these characters are printed as actual newlines and formfeeds. | |
703 | |
21682
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
704 This variable affects the print functions @code{prin1} and @code{print} |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
705 that print with quoting. It does not affect @code{princ}. Here is an |
90da2489c498
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
21007
diff
changeset
|
706 example using @code{prin1}: |
6381 | 707 |
708 @example | |
709 @group | |
710 (prin1 "a\nb") | |
711 @print{} "a | |
712 @print{} b" | |
713 @result{} "a | |
714 b" | |
715 @end group | |
716 | |
717 @group | |
718 (let ((print-escape-newlines t)) | |
719 (prin1 "a\nb")) | |
720 @print{} "a\nb" | |
721 @result{} "a | |
722 b" | |
723 @end group | |
724 @end example | |
725 | |
726 @noindent | |
727 In the second expression, the local binding of | |
728 @code{print-escape-newlines} is in effect during the call to | |
729 @code{prin1}, but not during the printing of the result. | |
730 @end defvar | |
731 | |
22252
40089afa2b1d
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22138
diff
changeset
|
732 @defvar print-escape-nonascii |
52978
1a5c50faf357
Replace @sc{foo} with @acronym{FOO}.
Eli Zaretskii <eliz@gnu.org>
parents:
52401
diff
changeset
|
733 If this variable is non-@code{nil}, then unibyte non-@acronym{ASCII} |
22252
40089afa2b1d
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22138
diff
changeset
|
734 characters in strings are unconditionally printed as backslash sequences |
40089afa2b1d
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22138
diff
changeset
|
735 by the print functions @code{prin1} and @code{print} that print with |
40089afa2b1d
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22138
diff
changeset
|
736 quoting. |
22829
6323b7754a76
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22252
diff
changeset
|
737 |
52978
1a5c50faf357
Replace @sc{foo} with @acronym{FOO}.
Eli Zaretskii <eliz@gnu.org>
parents:
52401
diff
changeset
|
738 Those functions also use backslash sequences for unibyte non-@acronym{ASCII} |
22829
6323b7754a76
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22252
diff
changeset
|
739 characters, regardless of the value of this variable, when the output |
6323b7754a76
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22252
diff
changeset
|
740 stream is a multibyte buffer or a marker pointing into one. |
6323b7754a76
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22252
diff
changeset
|
741 @end defvar |
6323b7754a76
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22252
diff
changeset
|
742 |
6323b7754a76
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22252
diff
changeset
|
743 @defvar print-escape-multibyte |
52978
1a5c50faf357
Replace @sc{foo} with @acronym{FOO}.
Eli Zaretskii <eliz@gnu.org>
parents:
52401
diff
changeset
|
744 If this variable is non-@code{nil}, then multibyte non-@acronym{ASCII} |
22829
6323b7754a76
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22252
diff
changeset
|
745 characters in strings are unconditionally printed as backslash sequences |
6323b7754a76
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22252
diff
changeset
|
746 by the print functions @code{prin1} and @code{print} that print with |
6323b7754a76
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22252
diff
changeset
|
747 quoting. |
6323b7754a76
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22252
diff
changeset
|
748 |
6323b7754a76
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22252
diff
changeset
|
749 Those functions also use backslash sequences for multibyte |
52978
1a5c50faf357
Replace @sc{foo} with @acronym{FOO}.
Eli Zaretskii <eliz@gnu.org>
parents:
52401
diff
changeset
|
750 non-@acronym{ASCII} characters, regardless of the value of this variable, |
22829
6323b7754a76
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22252
diff
changeset
|
751 when the output stream is a unibyte buffer or a marker pointing into |
6323b7754a76
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22252
diff
changeset
|
752 one. |
22252
40089afa2b1d
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22138
diff
changeset
|
753 @end defvar |
40089afa2b1d
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22138
diff
changeset
|
754 |
6381 | 755 @defvar print-length |
756 @cindex printing limits | |
21007
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
757 The value of this variable is the maximum number of elements to print in |
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
758 any list, vector or bool-vector. If an object being printed has more |
66d807bdc5b4
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
15800
diff
changeset
|
759 than this many elements, it is abbreviated with an ellipsis. |
6381 | 760 |
761 If the value is @code{nil} (the default), then there is no limit. | |
762 | |
763 @example | |
764 @group | |
765 (setq print-length 2) | |
766 @result{} 2 | |
767 @end group | |
768 @group | |
769 (print '(1 2 3 4 5)) | |
770 @print{} (1 2 ...) | |
771 @result{} (1 2 ...) | |
772 @end group | |
773 @end example | |
774 @end defvar | |
775 | |
776 @defvar print-level | |
777 The value of this variable is the maximum depth of nesting of | |
7219 | 778 parentheses and brackets when printed. Any list or vector at a depth |
6381 | 779 exceeding this limit is abbreviated with an ellipsis. A value of |
780 @code{nil} (which is the default) means no limit. | |
781 @end defvar | |
25751
467b88fab665
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22829
diff
changeset
|
782 |
52190
f18ef41c0b41
(Output Variables): Add eval-expression-print-length
Richard M. Stallman <rms@gnu.org>
parents:
51995
diff
changeset
|
783 @defopt eval-expression-print-length |
f18ef41c0b41
(Output Variables): Add eval-expression-print-length
Richard M. Stallman <rms@gnu.org>
parents:
51995
diff
changeset
|
784 @defoptx eval-expression-print-level |
f18ef41c0b41
(Output Variables): Add eval-expression-print-length
Richard M. Stallman <rms@gnu.org>
parents:
51995
diff
changeset
|
785 These are the values for @code{print-length} and @code{print-level} |
f18ef41c0b41
(Output Variables): Add eval-expression-print-length
Richard M. Stallman <rms@gnu.org>
parents:
51995
diff
changeset
|
786 used by @code{eval-expression}, and thus, indirectly, by many |
f18ef41c0b41
(Output Variables): Add eval-expression-print-length
Richard M. Stallman <rms@gnu.org>
parents:
51995
diff
changeset
|
787 interactive evaluation commands (@pxref{Lisp Eval,, Evaluating |
f18ef41c0b41
(Output Variables): Add eval-expression-print-length
Richard M. Stallman <rms@gnu.org>
parents:
51995
diff
changeset
|
788 Emacs-Lisp Expressions, emacs, The GNU Emacs Manual}). |
f18ef41c0b41
(Output Variables): Add eval-expression-print-length
Richard M. Stallman <rms@gnu.org>
parents:
51995
diff
changeset
|
789 @end defopt |
f18ef41c0b41
(Output Variables): Add eval-expression-print-length
Richard M. Stallman <rms@gnu.org>
parents:
51995
diff
changeset
|
790 |
49600
23a1cea22d13
Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents:
31078
diff
changeset
|
791 These variables are used for detecting and reporting circular |
25751
467b88fab665
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22829
diff
changeset
|
792 and shared structure---but they are only defined in Emacs 21. |
467b88fab665
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22829
diff
changeset
|
793 |
467b88fab665
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22829
diff
changeset
|
794 @tindex print-circle |
467b88fab665
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22829
diff
changeset
|
795 @defvar print-circle |
49600
23a1cea22d13
Trailing whitespace deleted.
Juanma Barranquero <lekktu@gmail.com>
parents:
31078
diff
changeset
|
796 If non-@code{nil}, this variable enables detection of circular |
25751
467b88fab665
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22829
diff
changeset
|
797 and shared structure in printing. |
467b88fab665
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22829
diff
changeset
|
798 @end defvar |
467b88fab665
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22829
diff
changeset
|
799 |
467b88fab665
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22829
diff
changeset
|
800 @tindex print-gensym |
467b88fab665
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22829
diff
changeset
|
801 @defvar print-gensym |
467b88fab665
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22829
diff
changeset
|
802 If non-@code{nil}, this variable enables detection of uninterned symbols |
467b88fab665
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22829
diff
changeset
|
803 (@pxref{Creating Symbols}) in printing. When this is enabled, |
467b88fab665
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22829
diff
changeset
|
804 uninterned symbols print with the prefix @samp{#:}, which tells the Lisp |
467b88fab665
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22829
diff
changeset
|
805 reader to produce an uninterned symbol. |
467b88fab665
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
22829
diff
changeset
|
806 @end defvar |
51995
01229a738c6f
(Output Variables): Add print-continuous-numbering and print-number-table.
Richard M. Stallman <rms@gnu.org>
parents:
49600
diff
changeset
|
807 |
01229a738c6f
(Output Variables): Add print-continuous-numbering and print-number-table.
Richard M. Stallman <rms@gnu.org>
parents:
49600
diff
changeset
|
808 @defvar print-continuous-numbering |
01229a738c6f
(Output Variables): Add print-continuous-numbering and print-number-table.
Richard M. Stallman <rms@gnu.org>
parents:
49600
diff
changeset
|
809 If non-@code{nil}, that means number continuously across print calls. |
01229a738c6f
(Output Variables): Add print-continuous-numbering and print-number-table.
Richard M. Stallman <rms@gnu.org>
parents:
49600
diff
changeset
|
810 This affects the numbers printed for @samp{#@var{n}=} labels and |
01229a738c6f
(Output Variables): Add print-continuous-numbering and print-number-table.
Richard M. Stallman <rms@gnu.org>
parents:
49600
diff
changeset
|
811 @samp{#@var{m}#} references. |
01229a738c6f
(Output Variables): Add print-continuous-numbering and print-number-table.
Richard M. Stallman <rms@gnu.org>
parents:
49600
diff
changeset
|
812 |
01229a738c6f
(Output Variables): Add print-continuous-numbering and print-number-table.
Richard M. Stallman <rms@gnu.org>
parents:
49600
diff
changeset
|
813 Don't set this variable with @code{setq}; you should only bind it |
01229a738c6f
(Output Variables): Add print-continuous-numbering and print-number-table.
Richard M. Stallman <rms@gnu.org>
parents:
49600
diff
changeset
|
814 temporarily to @code{t} with @code{let}. When you do that, you should |
01229a738c6f
(Output Variables): Add print-continuous-numbering and print-number-table.
Richard M. Stallman <rms@gnu.org>
parents:
49600
diff
changeset
|
815 also bind @code{print-number-table} to @code{nil}. |
01229a738c6f
(Output Variables): Add print-continuous-numbering and print-number-table.
Richard M. Stallman <rms@gnu.org>
parents:
49600
diff
changeset
|
816 @end defvar |
01229a738c6f
(Output Variables): Add print-continuous-numbering and print-number-table.
Richard M. Stallman <rms@gnu.org>
parents:
49600
diff
changeset
|
817 |
01229a738c6f
(Output Variables): Add print-continuous-numbering and print-number-table.
Richard M. Stallman <rms@gnu.org>
parents:
49600
diff
changeset
|
818 @defvar print-number-table |
01229a738c6f
(Output Variables): Add print-continuous-numbering and print-number-table.
Richard M. Stallman <rms@gnu.org>
parents:
49600
diff
changeset
|
819 This variable holds a vector used internally by printing to implement |
01229a738c6f
(Output Variables): Add print-continuous-numbering and print-number-table.
Richard M. Stallman <rms@gnu.org>
parents:
49600
diff
changeset
|
820 the @code{print-circle} feature. You should not use it except |
01229a738c6f
(Output Variables): Add print-continuous-numbering and print-number-table.
Richard M. Stallman <rms@gnu.org>
parents:
49600
diff
changeset
|
821 to bind it to @code{nil} when you bind @code{print-continuous-numbering}. |
01229a738c6f
(Output Variables): Add print-continuous-numbering and print-number-table.
Richard M. Stallman <rms@gnu.org>
parents:
49600
diff
changeset
|
822 @end defvar |
52401 | 823 |
55737
2ac351855ad7
(Output Variables): Doc float-output-format.
Richard M. Stallman <rms@gnu.org>
parents:
54039
diff
changeset
|
824 @defvar float-output-format |
2ac351855ad7
(Output Variables): Doc float-output-format.
Richard M. Stallman <rms@gnu.org>
parents:
54039
diff
changeset
|
825 This variable specifies how to print floating point numbers. Its |
2ac351855ad7
(Output Variables): Doc float-output-format.
Richard M. Stallman <rms@gnu.org>
parents:
54039
diff
changeset
|
826 default value is @code{nil}, meaning use the shortest output |
2ac351855ad7
(Output Variables): Doc float-output-format.
Richard M. Stallman <rms@gnu.org>
parents:
54039
diff
changeset
|
827 that represents the number without losing information. |
2ac351855ad7
(Output Variables): Doc float-output-format.
Richard M. Stallman <rms@gnu.org>
parents:
54039
diff
changeset
|
828 |
2ac351855ad7
(Output Variables): Doc float-output-format.
Richard M. Stallman <rms@gnu.org>
parents:
54039
diff
changeset
|
829 To control output format more precisely, you can put a string in this |
2ac351855ad7
(Output Variables): Doc float-output-format.
Richard M. Stallman <rms@gnu.org>
parents:
54039
diff
changeset
|
830 variable. The string should hold a @samp{%}-specification to be used |
2ac351855ad7
(Output Variables): Doc float-output-format.
Richard M. Stallman <rms@gnu.org>
parents:
54039
diff
changeset
|
831 in the C function @code{sprintf}. For further restrictions on what |
2ac351855ad7
(Output Variables): Doc float-output-format.
Richard M. Stallman <rms@gnu.org>
parents:
54039
diff
changeset
|
832 you can use, see the variable's documentation string. |
2ac351855ad7
(Output Variables): Doc float-output-format.
Richard M. Stallman <rms@gnu.org>
parents:
54039
diff
changeset
|
833 @end defvar |
2ac351855ad7
(Output Variables): Doc float-output-format.
Richard M. Stallman <rms@gnu.org>
parents:
54039
diff
changeset
|
834 |
52401 | 835 @ignore |
836 arch-tag: 07636b8c-c4e3-4735-9e06-2e864320b434 | |
837 @end ignore |