Mercurial > emacs
annotate src/print.c @ 13043:2072d3ab4119
Moved stuff to other files.
author | Edward M. Reingold <reingold@emr.cs.iit.edu> |
---|---|
date | Thu, 21 Sep 1995 02:45:33 +0000 |
parents | 029baa39289d |
children | bd9ff4ee6cd4 |
rev | line source |
---|---|
329 | 1 /* Lisp object printing and output streams. |
11235 | 2 Copyright (C) 1985, 86, 88, 93, 94, 95 Free Software Foundation, Inc. |
329 | 3 |
4 This file is part of GNU Emacs. | |
5 | |
6 GNU Emacs is free software; you can redistribute it and/or modify | |
7 it under the terms of the GNU General Public License as published by | |
621 | 8 the Free Software Foundation; either version 2, or (at your option) |
329 | 9 any later version. |
10 | |
11 GNU Emacs is distributed in the hope that it will be useful, | |
12 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 GNU General Public License for more details. | |
15 | |
16 You should have received a copy of the GNU General Public License | |
17 along with GNU Emacs; see the file COPYING. If not, write to | |
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
19 | |
20 | |
4696
1fc792473491
Include <config.h> instead of "config.h".
Roland McGrath <roland@gnu.org>
parents:
4224
diff
changeset
|
21 #include <config.h> |
329 | 22 #include <stdio.h> |
23 #undef NULL | |
24 #include "lisp.h" | |
25 | |
26 #ifndef standalone | |
27 #include "buffer.h" | |
766 | 28 #include "frame.h" |
329 | 29 #include "window.h" |
30 #include "process.h" | |
31 #include "dispextern.h" | |
32 #include "termchar.h" | |
11341 | 33 #include "keyboard.h" |
329 | 34 #endif /* not standalone */ |
35 | |
1967 | 36 #ifdef USE_TEXT_PROPERTIES |
37 #include "intervals.h" | |
38 #endif | |
39 | |
329 | 40 Lisp_Object Vstandard_output, Qstandard_output; |
41 | |
42 #ifdef LISP_FLOAT_TYPE | |
43 Lisp_Object Vfloat_output_format, Qfloat_output_format; | |
44 #endif /* LISP_FLOAT_TYPE */ | |
45 | |
46 /* Avoid actual stack overflow in print. */ | |
47 int print_depth; | |
48 | |
379
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
49 /* Detect most circularities to print finite output. */ |
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
50 #define PRINT_CIRCLE 200 |
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
51 Lisp_Object being_printed[PRINT_CIRCLE]; |
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
52 |
329 | 53 /* Maximum length of list to print in full; noninteger means |
54 effectively infinity */ | |
55 | |
56 Lisp_Object Vprint_length; | |
57 | |
58 /* Maximum depth of list to print in full; noninteger means | |
59 effectively infinity. */ | |
60 | |
61 Lisp_Object Vprint_level; | |
62 | |
63 /* Nonzero means print newlines in strings as \n. */ | |
64 | |
65 int print_escape_newlines; | |
66 | |
67 Lisp_Object Qprint_escape_newlines; | |
68 | |
10418
fdad41459fd6
(printchar, strout): Call message_dolog.
Karl Heuer <kwzh@gnu.org>
parents:
10301
diff
changeset
|
69 /* Nonzero means print newline to stdout before next minibuffer message. |
329 | 70 Defined in xdisp.c */ |
71 | |
72 extern int noninteractive_need_newline; | |
10418
fdad41459fd6
(printchar, strout): Call message_dolog.
Karl Heuer <kwzh@gnu.org>
parents:
10301
diff
changeset
|
73 |
329 | 74 #ifdef MAX_PRINT_CHARS |
75 static int print_chars; | |
76 static int max_print; | |
77 #endif /* MAX_PRINT_CHARS */ | |
1967 | 78 |
79 void print_interval (); | |
329 | 80 |
81 #if 0 | |
82 /* Convert between chars and GLYPHs */ | |
83 | |
84 int | |
85 glyphlen (glyphs) | |
86 register GLYPH *glyphs; | |
87 { | |
88 register int i = 0; | |
89 | |
90 while (glyphs[i]) | |
91 i++; | |
92 return i; | |
93 } | |
94 | |
95 void | |
96 str_to_glyph_cpy (str, glyphs) | |
97 char *str; | |
98 GLYPH *glyphs; | |
99 { | |
100 register GLYPH *gp = glyphs; | |
101 register char *cp = str; | |
102 | |
103 while (*cp) | |
104 *gp++ = *cp++; | |
105 } | |
106 | |
107 void | |
108 str_to_glyph_ncpy (str, glyphs, n) | |
109 char *str; | |
110 GLYPH *glyphs; | |
111 register int n; | |
112 { | |
113 register GLYPH *gp = glyphs; | |
114 register char *cp = str; | |
115 | |
116 while (n-- > 0) | |
117 *gp++ = *cp++; | |
118 } | |
119 | |
120 void | |
121 glyph_to_str_cpy (glyphs, str) | |
122 GLYPH *glyphs; | |
123 char *str; | |
124 { | |
125 register GLYPH *gp = glyphs; | |
126 register char *cp = str; | |
127 | |
128 while (*gp) | |
129 *str++ = *gp++ & 0377; | |
130 } | |
131 #endif | |
132 | |
3591
507f64624555
Apply typo patches from Paul Eggert.
Jim Blandy <jimb@redhat.com>
parents:
3377
diff
changeset
|
133 /* Low level output routines for characters and strings */ |
329 | 134 |
135 /* Lisp functions to do output using a stream | |
136 must have the stream in a variable called printcharfun | |
137 and must start with PRINTPREPARE and end with PRINTFINISH. | |
138 Use PRINTCHAR to output one character, | |
139 or call strout to output a block of characters. | |
140 Also, each one must have the declarations | |
141 struct buffer *old = current_buffer; | |
142 int old_point = -1, start_point; | |
143 Lisp_Object original; | |
144 */ | |
145 | |
2193
652b38173a63
(PRINTPREPARE): Handle marker that points nowhere.
Richard M. Stallman <rms@gnu.org>
parents:
1991
diff
changeset
|
146 #define PRINTPREPARE \ |
652b38173a63
(PRINTPREPARE): Handle marker that points nowhere.
Richard M. Stallman <rms@gnu.org>
parents:
1991
diff
changeset
|
147 original = printcharfun; \ |
652b38173a63
(PRINTPREPARE): Handle marker that points nowhere.
Richard M. Stallman <rms@gnu.org>
parents:
1991
diff
changeset
|
148 if (NILP (printcharfun)) printcharfun = Qt; \ |
9117
f69e6cf74874
(PRINTPREPARE, PRINTFINISH, float_to_string, print): Use type test macros.
Karl Heuer <kwzh@gnu.org>
parents:
8854
diff
changeset
|
149 if (BUFFERP (printcharfun)) \ |
2193
652b38173a63
(PRINTPREPARE): Handle marker that points nowhere.
Richard M. Stallman <rms@gnu.org>
parents:
1991
diff
changeset
|
150 { if (XBUFFER (printcharfun) != current_buffer) \ |
652b38173a63
(PRINTPREPARE): Handle marker that points nowhere.
Richard M. Stallman <rms@gnu.org>
parents:
1991
diff
changeset
|
151 Fset_buffer (printcharfun); \ |
652b38173a63
(PRINTPREPARE): Handle marker that points nowhere.
Richard M. Stallman <rms@gnu.org>
parents:
1991
diff
changeset
|
152 printcharfun = Qnil;} \ |
9117
f69e6cf74874
(PRINTPREPARE, PRINTFINISH, float_to_string, print): Use type test macros.
Karl Heuer <kwzh@gnu.org>
parents:
8854
diff
changeset
|
153 if (MARKERP (printcharfun)) \ |
2193
652b38173a63
(PRINTPREPARE): Handle marker that points nowhere.
Richard M. Stallman <rms@gnu.org>
parents:
1991
diff
changeset
|
154 { if (!(XMARKER (original)->buffer)) \ |
652b38173a63
(PRINTPREPARE): Handle marker that points nowhere.
Richard M. Stallman <rms@gnu.org>
parents:
1991
diff
changeset
|
155 error ("Marker does not point anywhere"); \ |
652b38173a63
(PRINTPREPARE): Handle marker that points nowhere.
Richard M. Stallman <rms@gnu.org>
parents:
1991
diff
changeset
|
156 if (XMARKER (original)->buffer != current_buffer) \ |
652b38173a63
(PRINTPREPARE): Handle marker that points nowhere.
Richard M. Stallman <rms@gnu.org>
parents:
1991
diff
changeset
|
157 set_buffer_internal (XMARKER (original)->buffer); \ |
652b38173a63
(PRINTPREPARE): Handle marker that points nowhere.
Richard M. Stallman <rms@gnu.org>
parents:
1991
diff
changeset
|
158 old_point = point; \ |
652b38173a63
(PRINTPREPARE): Handle marker that points nowhere.
Richard M. Stallman <rms@gnu.org>
parents:
1991
diff
changeset
|
159 SET_PT (marker_position (printcharfun)); \ |
652b38173a63
(PRINTPREPARE): Handle marker that points nowhere.
Richard M. Stallman <rms@gnu.org>
parents:
1991
diff
changeset
|
160 start_point = point; \ |
329 | 161 printcharfun = Qnil;} |
162 | |
2193
652b38173a63
(PRINTPREPARE): Handle marker that points nowhere.
Richard M. Stallman <rms@gnu.org>
parents:
1991
diff
changeset
|
163 #define PRINTFINISH \ |
9117
f69e6cf74874
(PRINTPREPARE, PRINTFINISH, float_to_string, print): Use type test macros.
Karl Heuer <kwzh@gnu.org>
parents:
8854
diff
changeset
|
164 if (MARKERP (original)) \ |
2193
652b38173a63
(PRINTPREPARE): Handle marker that points nowhere.
Richard M. Stallman <rms@gnu.org>
parents:
1991
diff
changeset
|
165 Fset_marker (original, make_number (point), Qnil); \ |
652b38173a63
(PRINTPREPARE): Handle marker that points nowhere.
Richard M. Stallman <rms@gnu.org>
parents:
1991
diff
changeset
|
166 if (old_point >= 0) \ |
652b38173a63
(PRINTPREPARE): Handle marker that points nowhere.
Richard M. Stallman <rms@gnu.org>
parents:
1991
diff
changeset
|
167 SET_PT (old_point + (old_point >= start_point \ |
652b38173a63
(PRINTPREPARE): Handle marker that points nowhere.
Richard M. Stallman <rms@gnu.org>
parents:
1991
diff
changeset
|
168 ? point - start_point : 0)); \ |
652b38173a63
(PRINTPREPARE): Handle marker that points nowhere.
Richard M. Stallman <rms@gnu.org>
parents:
1991
diff
changeset
|
169 if (old != current_buffer) \ |
329 | 170 set_buffer_internal (old) |
171 | |
172 #define PRINTCHAR(ch) printchar (ch, printcharfun) | |
173 | |
5487
58a9bb23c3ea
(strout, printchar): Use proper frame for minibuffer.
Richard M. Stallman <rms@gnu.org>
parents:
5233
diff
changeset
|
174 /* Index of first unused element of FRAME_MESSAGE_BUF(mini_frame). */ |
329 | 175 static int printbufidx; |
176 | |
177 static void | |
178 printchar (ch, fun) | |
179 unsigned char ch; | |
180 Lisp_Object fun; | |
181 { | |
182 Lisp_Object ch1; | |
183 | |
184 #ifdef MAX_PRINT_CHARS | |
185 if (max_print) | |
186 print_chars++; | |
187 #endif /* MAX_PRINT_CHARS */ | |
188 #ifndef standalone | |
189 if (EQ (fun, Qnil)) | |
190 { | |
191 QUIT; | |
192 insert (&ch, 1); | |
193 return; | |
194 } | |
195 | |
196 if (EQ (fun, Qt)) | |
197 { | |
6808
514a324b3681
(printchar, strout): Use FRAME_PTR, not struct frame *.
Karl Heuer <kwzh@gnu.org>
parents:
6802
diff
changeset
|
198 FRAME_PTR mini_frame |
5487
58a9bb23c3ea
(strout, printchar): Use proper frame for minibuffer.
Richard M. Stallman <rms@gnu.org>
parents:
5233
diff
changeset
|
199 = XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window))); |
58a9bb23c3ea
(strout, printchar): Use proper frame for minibuffer.
Richard M. Stallman <rms@gnu.org>
parents:
5233
diff
changeset
|
200 |
329 | 201 if (noninteractive) |
202 { | |
203 putchar (ch); | |
204 noninteractive_need_newline = 1; | |
205 return; | |
206 } | |
207 | |
5487
58a9bb23c3ea
(strout, printchar): Use proper frame for minibuffer.
Richard M. Stallman <rms@gnu.org>
parents:
5233
diff
changeset
|
208 if (echo_area_glyphs != FRAME_MESSAGE_BUF (mini_frame) |
329 | 209 || !message_buf_print) |
210 { | |
10568
275f62e27ee2
(printchar, strout): Use message_log_maybe_newline.
Karl Heuer <kwzh@gnu.org>
parents:
10482
diff
changeset
|
211 message_log_maybe_newline (); |
5487
58a9bb23c3ea
(strout, printchar): Use proper frame for minibuffer.
Richard M. Stallman <rms@gnu.org>
parents:
5233
diff
changeset
|
212 echo_area_glyphs = FRAME_MESSAGE_BUF (mini_frame); |
329 | 213 printbufidx = 0; |
5233
83e771f33251
(printchar, strout): Set echo_area_glyphs_length.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
214 echo_area_glyphs_length = 0; |
329 | 215 message_buf_print = 1; |
216 } | |
217 | |
10418
fdad41459fd6
(printchar, strout): Call message_dolog.
Karl Heuer <kwzh@gnu.org>
parents:
10301
diff
changeset
|
218 message_dolog (&ch, 1, 0); |
5487
58a9bb23c3ea
(strout, printchar): Use proper frame for minibuffer.
Richard M. Stallman <rms@gnu.org>
parents:
5233
diff
changeset
|
219 if (printbufidx < FRAME_WIDTH (mini_frame) - 1) |
58a9bb23c3ea
(strout, printchar): Use proper frame for minibuffer.
Richard M. Stallman <rms@gnu.org>
parents:
5233
diff
changeset
|
220 FRAME_MESSAGE_BUF (mini_frame)[printbufidx++] = ch; |
58a9bb23c3ea
(strout, printchar): Use proper frame for minibuffer.
Richard M. Stallman <rms@gnu.org>
parents:
5233
diff
changeset
|
221 FRAME_MESSAGE_BUF (mini_frame)[printbufidx] = 0; |
5233
83e771f33251
(printchar, strout): Set echo_area_glyphs_length.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
222 echo_area_glyphs_length = printbufidx; |
329 | 223 |
224 return; | |
225 } | |
226 #endif /* not standalone */ | |
227 | |
9317
58f6a917533b
(printchar): Don't use XFASTINT as an lvalue.
Karl Heuer <kwzh@gnu.org>
parents:
9276
diff
changeset
|
228 XSETFASTINT (ch1, ch); |
329 | 229 call1 (fun, ch1); |
230 } | |
231 | |
232 static void | |
233 strout (ptr, size, printcharfun) | |
234 char *ptr; | |
235 int size; | |
236 Lisp_Object printcharfun; | |
237 { | |
238 int i = 0; | |
239 | |
240 if (EQ (printcharfun, Qnil)) | |
241 { | |
242 insert (ptr, size >= 0 ? size : strlen (ptr)); | |
243 #ifdef MAX_PRINT_CHARS | |
244 if (max_print) | |
245 print_chars += size >= 0 ? size : strlen(ptr); | |
246 #endif /* MAX_PRINT_CHARS */ | |
247 return; | |
248 } | |
249 if (EQ (printcharfun, Qt)) | |
250 { | |
6808
514a324b3681
(printchar, strout): Use FRAME_PTR, not struct frame *.
Karl Heuer <kwzh@gnu.org>
parents:
6802
diff
changeset
|
251 FRAME_PTR mini_frame |
5487
58a9bb23c3ea
(strout, printchar): Use proper frame for minibuffer.
Richard M. Stallman <rms@gnu.org>
parents:
5233
diff
changeset
|
252 = XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window))); |
58a9bb23c3ea
(strout, printchar): Use proper frame for minibuffer.
Richard M. Stallman <rms@gnu.org>
parents:
5233
diff
changeset
|
253 |
329 | 254 i = size >= 0 ? size : strlen (ptr); |
255 #ifdef MAX_PRINT_CHARS | |
256 if (max_print) | |
257 print_chars += i; | |
258 #endif /* MAX_PRINT_CHARS */ | |
259 | |
260 if (noninteractive) | |
261 { | |
262 fwrite (ptr, 1, i, stdout); | |
263 noninteractive_need_newline = 1; | |
264 return; | |
265 } | |
266 | |
5487
58a9bb23c3ea
(strout, printchar): Use proper frame for minibuffer.
Richard M. Stallman <rms@gnu.org>
parents:
5233
diff
changeset
|
267 if (echo_area_glyphs != FRAME_MESSAGE_BUF (mini_frame) |
329 | 268 || !message_buf_print) |
269 { | |
10568
275f62e27ee2
(printchar, strout): Use message_log_maybe_newline.
Karl Heuer <kwzh@gnu.org>
parents:
10482
diff
changeset
|
270 message_log_maybe_newline (); |
5487
58a9bb23c3ea
(strout, printchar): Use proper frame for minibuffer.
Richard M. Stallman <rms@gnu.org>
parents:
5233
diff
changeset
|
271 echo_area_glyphs = FRAME_MESSAGE_BUF (mini_frame); |
329 | 272 printbufidx = 0; |
5233
83e771f33251
(printchar, strout): Set echo_area_glyphs_length.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
273 echo_area_glyphs_length = 0; |
329 | 274 message_buf_print = 1; |
275 } | |
276 | |
10418
fdad41459fd6
(printchar, strout): Call message_dolog.
Karl Heuer <kwzh@gnu.org>
parents:
10301
diff
changeset
|
277 message_dolog (ptr, i, 0); |
5487
58a9bb23c3ea
(strout, printchar): Use proper frame for minibuffer.
Richard M. Stallman <rms@gnu.org>
parents:
5233
diff
changeset
|
278 if (i > FRAME_WIDTH (mini_frame) - printbufidx - 1) |
58a9bb23c3ea
(strout, printchar): Use proper frame for minibuffer.
Richard M. Stallman <rms@gnu.org>
parents:
5233
diff
changeset
|
279 i = FRAME_WIDTH (mini_frame) - printbufidx - 1; |
58a9bb23c3ea
(strout, printchar): Use proper frame for minibuffer.
Richard M. Stallman <rms@gnu.org>
parents:
5233
diff
changeset
|
280 bcopy (ptr, &FRAME_MESSAGE_BUF (mini_frame) [printbufidx], i); |
329 | 281 printbufidx += i; |
5233
83e771f33251
(printchar, strout): Set echo_area_glyphs_length.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
282 echo_area_glyphs_length = printbufidx; |
5487
58a9bb23c3ea
(strout, printchar): Use proper frame for minibuffer.
Richard M. Stallman <rms@gnu.org>
parents:
5233
diff
changeset
|
283 FRAME_MESSAGE_BUF (mini_frame) [printbufidx] = 0; |
329 | 284 |
285 return; | |
286 } | |
287 | |
288 if (size >= 0) | |
289 while (i < size) | |
290 PRINTCHAR (ptr[i++]); | |
291 else | |
292 while (ptr[i]) | |
293 PRINTCHAR (ptr[i++]); | |
294 } | |
295 | |
296 /* Print the contents of a string STRING using PRINTCHARFUN. | |
297 It isn't safe to use strout, because printing one char can relocate. */ | |
298 | |
299 print_string (string, printcharfun) | |
300 Lisp_Object string; | |
301 Lisp_Object printcharfun; | |
302 { | |
12782
029baa39289d
(print_string): Use insert_from_string for output to buffer.
Richard M. Stallman <rms@gnu.org>
parents:
11798
diff
changeset
|
303 if (EQ (printcharfun, Qt)) |
029baa39289d
(print_string): Use insert_from_string for output to buffer.
Richard M. Stallman <rms@gnu.org>
parents:
11798
diff
changeset
|
304 /* strout is safe for output to a frame (echo area). */ |
329 | 305 strout (XSTRING (string)->data, XSTRING (string)->size, printcharfun); |
12782
029baa39289d
(print_string): Use insert_from_string for output to buffer.
Richard M. Stallman <rms@gnu.org>
parents:
11798
diff
changeset
|
306 else if (EQ (printcharfun, Qnil)) |
029baa39289d
(print_string): Use insert_from_string for output to buffer.
Richard M. Stallman <rms@gnu.org>
parents:
11798
diff
changeset
|
307 { |
029baa39289d
(print_string): Use insert_from_string for output to buffer.
Richard M. Stallman <rms@gnu.org>
parents:
11798
diff
changeset
|
308 #ifdef MAX_PRINT_CHARS |
029baa39289d
(print_string): Use insert_from_string for output to buffer.
Richard M. Stallman <rms@gnu.org>
parents:
11798
diff
changeset
|
309 if (max_print) |
029baa39289d
(print_string): Use insert_from_string for output to buffer.
Richard M. Stallman <rms@gnu.org>
parents:
11798
diff
changeset
|
310 print_chars += XSTRING (string)->size; |
029baa39289d
(print_string): Use insert_from_string for output to buffer.
Richard M. Stallman <rms@gnu.org>
parents:
11798
diff
changeset
|
311 #endif /* MAX_PRINT_CHARS */ |
029baa39289d
(print_string): Use insert_from_string for output to buffer.
Richard M. Stallman <rms@gnu.org>
parents:
11798
diff
changeset
|
312 insert_from_string (string, 0, XSTRING (string)->size, 1); |
029baa39289d
(print_string): Use insert_from_string for output to buffer.
Richard M. Stallman <rms@gnu.org>
parents:
11798
diff
changeset
|
313 } |
329 | 314 else |
315 { | |
316 /* Otherwise, fetch the string address for each character. */ | |
317 int i; | |
318 int size = XSTRING (string)->size; | |
319 struct gcpro gcpro1; | |
320 GCPRO1 (string); | |
321 for (i = 0; i < size; i++) | |
322 PRINTCHAR (XSTRING (string)->data[i]); | |
323 UNGCPRO; | |
324 } | |
325 } | |
326 | |
327 DEFUN ("write-char", Fwrite_char, Swrite_char, 1, 2, 0, | |
7185 | 328 "Output character CHAR to stream PRINTCHARFUN.\n\ |
329 PRINTCHARFUN defaults to the value of `standard-output' (which see).") | |
329 | 330 (ch, printcharfun) |
331 Lisp_Object ch, printcharfun; | |
332 { | |
333 struct buffer *old = current_buffer; | |
334 int old_point = -1; | |
335 int start_point; | |
336 Lisp_Object original; | |
337 | |
520 | 338 if (NILP (printcharfun)) |
329 | 339 printcharfun = Vstandard_output; |
340 CHECK_NUMBER (ch, 0); | |
341 PRINTPREPARE; | |
342 PRINTCHAR (XINT (ch)); | |
343 PRINTFINISH; | |
344 return ch; | |
345 } | |
346 | |
347 /* Used from outside of print.c to print a block of SIZE chars at DATA | |
348 on the default output stream. | |
349 Do not use this on the contents of a Lisp string. */ | |
350 | |
351 write_string (data, size) | |
352 char *data; | |
353 int size; | |
354 { | |
355 struct buffer *old = current_buffer; | |
356 Lisp_Object printcharfun; | |
357 int old_point = -1; | |
358 int start_point; | |
359 Lisp_Object original; | |
360 | |
361 printcharfun = Vstandard_output; | |
362 | |
363 PRINTPREPARE; | |
364 strout (data, size, printcharfun); | |
365 PRINTFINISH; | |
366 } | |
367 | |
368 /* Used from outside of print.c to print a block of SIZE chars at DATA | |
369 on a specified stream PRINTCHARFUN. | |
370 Do not use this on the contents of a Lisp string. */ | |
371 | |
372 write_string_1 (data, size, printcharfun) | |
373 char *data; | |
374 int size; | |
375 Lisp_Object printcharfun; | |
376 { | |
377 struct buffer *old = current_buffer; | |
378 int old_point = -1; | |
379 int start_point; | |
380 Lisp_Object original; | |
381 | |
382 PRINTPREPARE; | |
383 strout (data, size, printcharfun); | |
384 PRINTFINISH; | |
385 } | |
386 | |
387 | |
388 #ifndef standalone | |
389 | |
390 void | |
391 temp_output_buffer_setup (bufname) | |
392 char *bufname; | |
393 { | |
394 register struct buffer *old = current_buffer; | |
395 register Lisp_Object buf; | |
396 | |
397 Fset_buffer (Fget_buffer_create (build_string (bufname))); | |
398 | |
11114
c8ab5c627f74
(temp_output_buffer_setup): (Re)set the default
Richard M. Stallman <rms@gnu.org>
parents:
11010
diff
changeset
|
399 current_buffer->directory = old->directory; |
329 | 400 current_buffer->read_only = Qnil; |
401 Ferase_buffer (); | |
402 | |
9276
ae62e12feac5
(temp_output_buffer_setup): Use new accessor macros instead of calling XSET
Karl Heuer <kwzh@gnu.org>
parents:
9117
diff
changeset
|
403 XSETBUFFER (buf, current_buffer); |
329 | 404 specbind (Qstandard_output, buf); |
405 | |
406 set_buffer_internal (old); | |
407 } | |
408 | |
409 Lisp_Object | |
410 internal_with_output_to_temp_buffer (bufname, function, args) | |
411 char *bufname; | |
412 Lisp_Object (*function) (); | |
413 Lisp_Object args; | |
414 { | |
415 int count = specpdl_ptr - specpdl; | |
416 Lisp_Object buf, val; | |
8315
8921d0012bd5
(internal_with_output_to_temp_buffer): gcpro things.
Richard M. Stallman <rms@gnu.org>
parents:
7185
diff
changeset
|
417 struct gcpro gcpro1; |
329 | 418 |
8315
8921d0012bd5
(internal_with_output_to_temp_buffer): gcpro things.
Richard M. Stallman <rms@gnu.org>
parents:
7185
diff
changeset
|
419 GCPRO1 (args); |
329 | 420 record_unwind_protect (Fset_buffer, Fcurrent_buffer ()); |
421 temp_output_buffer_setup (bufname); | |
422 buf = Vstandard_output; | |
8315
8921d0012bd5
(internal_with_output_to_temp_buffer): gcpro things.
Richard M. Stallman <rms@gnu.org>
parents:
7185
diff
changeset
|
423 UNGCPRO; |
329 | 424 |
425 val = (*function) (args); | |
426 | |
8315
8921d0012bd5
(internal_with_output_to_temp_buffer): gcpro things.
Richard M. Stallman <rms@gnu.org>
parents:
7185
diff
changeset
|
427 GCPRO1 (val); |
329 | 428 temp_output_buffer_show (buf); |
8315
8921d0012bd5
(internal_with_output_to_temp_buffer): gcpro things.
Richard M. Stallman <rms@gnu.org>
parents:
7185
diff
changeset
|
429 UNGCPRO; |
329 | 430 |
431 return unbind_to (count, val); | |
432 } | |
433 | |
434 DEFUN ("with-output-to-temp-buffer", Fwith_output_to_temp_buffer, Swith_output_to_temp_buffer, | |
435 1, UNEVALLED, 0, | |
436 "Bind `standard-output' to buffer BUFNAME, eval BODY, then show that buffer.\n\ | |
437 The buffer is cleared out initially, and marked as unmodified when done.\n\ | |
438 All output done by BODY is inserted in that buffer by default.\n\ | |
439 The buffer is displayed in another window, but not selected.\n\ | |
440 The value of the last form in BODY is returned.\n\ | |
441 If BODY does not finish normally, the buffer BUFNAME is not displayed.\n\n\ | |
3337
f5f76ebe6286
(Fwith_output_to_temp_buffer): Doc fix.
Richard M. Stallman <rms@gnu.org>
parents:
2782
diff
changeset
|
442 If variable `temp-buffer-show-function' is non-nil, call it at the end\n\ |
329 | 443 to get the buffer displayed. It gets one argument, the buffer to display.") |
444 (args) | |
445 Lisp_Object args; | |
446 { | |
447 struct gcpro gcpro1; | |
448 Lisp_Object name; | |
449 int count = specpdl_ptr - specpdl; | |
450 Lisp_Object buf, val; | |
451 | |
452 GCPRO1(args); | |
453 name = Feval (Fcar (args)); | |
454 UNGCPRO; | |
455 | |
456 CHECK_STRING (name, 0); | |
457 temp_output_buffer_setup (XSTRING (name)->data); | |
458 buf = Vstandard_output; | |
459 | |
460 val = Fprogn (Fcdr (args)); | |
461 | |
462 temp_output_buffer_show (buf); | |
463 | |
464 return unbind_to (count, val); | |
465 } | |
466 #endif /* not standalone */ | |
467 | |
468 static void print (); | |
469 | |
470 DEFUN ("terpri", Fterpri, Sterpri, 0, 1, 0, | |
7185 | 471 "Output a newline to stream PRINTCHARFUN.\n\ |
472 If PRINTCHARFUN is omitted or nil, the value of `standard-output' is used.") | |
329 | 473 (printcharfun) |
474 Lisp_Object printcharfun; | |
475 { | |
476 struct buffer *old = current_buffer; | |
477 int old_point = -1; | |
478 int start_point; | |
479 Lisp_Object original; | |
480 | |
520 | 481 if (NILP (printcharfun)) |
329 | 482 printcharfun = Vstandard_output; |
483 PRINTPREPARE; | |
484 PRINTCHAR ('\n'); | |
485 PRINTFINISH; | |
486 return Qt; | |
487 } | |
488 | |
489 DEFUN ("prin1", Fprin1, Sprin1, 1, 2, 0, | |
490 "Output the printed representation of OBJECT, any Lisp object.\n\ | |
491 Quoting characters are printed when needed to make output that `read'\n\ | |
492 can handle, whenever this is possible.\n\ | |
7185 | 493 Output stream is PRINTCHARFUN, or value of `standard-output' (which see).") |
329 | 494 (obj, printcharfun) |
495 Lisp_Object obj, printcharfun; | |
496 { | |
497 struct buffer *old = current_buffer; | |
498 int old_point = -1; | |
499 int start_point; | |
500 Lisp_Object original; | |
501 | |
502 #ifdef MAX_PRINT_CHARS | |
503 max_print = 0; | |
504 #endif /* MAX_PRINT_CHARS */ | |
520 | 505 if (NILP (printcharfun)) |
329 | 506 printcharfun = Vstandard_output; |
507 PRINTPREPARE; | |
508 print_depth = 0; | |
509 print (obj, printcharfun, 1); | |
510 PRINTFINISH; | |
511 return obj; | |
512 } | |
513 | |
514 /* a buffer which is used to hold output being built by prin1-to-string */ | |
515 Lisp_Object Vprin1_to_string_buffer; | |
516 | |
517 DEFUN ("prin1-to-string", Fprin1_to_string, Sprin1_to_string, 1, 2, 0, | |
518 "Return a string containing the printed representation of OBJECT,\n\ | |
519 any Lisp object. Quoting characters are used when needed to make output\n\ | |
520 that `read' can handle, whenever this is possible, unless the optional\n\ | |
521 second argument NOESCAPE is non-nil.") | |
522 (obj, noescape) | |
523 Lisp_Object obj, noescape; | |
524 { | |
525 struct buffer *old = current_buffer; | |
526 int old_point = -1; | |
527 int start_point; | |
528 Lisp_Object original, printcharfun; | |
529 struct gcpro gcpro1; | |
530 | |
531 printcharfun = Vprin1_to_string_buffer; | |
532 PRINTPREPARE; | |
533 print_depth = 0; | |
520 | 534 print (obj, printcharfun, NILP (noescape)); |
329 | 535 /* Make Vprin1_to_string_buffer be the default buffer after PRINTFINSH */ |
536 PRINTFINISH; | |
537 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer)); | |
538 obj = Fbuffer_string (); | |
539 | |
540 GCPRO1 (obj); | |
541 Ferase_buffer (); | |
542 set_buffer_internal (old); | |
543 UNGCPRO; | |
544 | |
545 return obj; | |
546 } | |
547 | |
548 DEFUN ("princ", Fprinc, Sprinc, 1, 2, 0, | |
549 "Output the printed representation of OBJECT, any Lisp object.\n\ | |
550 No quoting characters are used; no delimiters are printed around\n\ | |
551 the contents of strings.\n\ | |
7185 | 552 Output stream is PRINTCHARFUN, or value of standard-output (which see).") |
329 | 553 (obj, printcharfun) |
554 Lisp_Object obj, printcharfun; | |
555 { | |
556 struct buffer *old = current_buffer; | |
557 int old_point = -1; | |
558 int start_point; | |
559 Lisp_Object original; | |
560 | |
520 | 561 if (NILP (printcharfun)) |
329 | 562 printcharfun = Vstandard_output; |
563 PRINTPREPARE; | |
564 print_depth = 0; | |
565 print (obj, printcharfun, 0); | |
566 PRINTFINISH; | |
567 return obj; | |
568 } | |
569 | |
570 DEFUN ("print", Fprint, Sprint, 1, 2, 0, | |
571 "Output the printed representation of OBJECT, with newlines around it.\n\ | |
572 Quoting characters are printed when needed to make output that `read'\n\ | |
573 can handle, whenever this is possible.\n\ | |
7185 | 574 Output stream is PRINTCHARFUN, or value of `standard-output' (which see).") |
329 | 575 (obj, printcharfun) |
576 Lisp_Object obj, printcharfun; | |
577 { | |
578 struct buffer *old = current_buffer; | |
579 int old_point = -1; | |
580 int start_point; | |
581 Lisp_Object original; | |
582 struct gcpro gcpro1; | |
583 | |
584 #ifdef MAX_PRINT_CHARS | |
585 print_chars = 0; | |
586 max_print = MAX_PRINT_CHARS; | |
587 #endif /* MAX_PRINT_CHARS */ | |
520 | 588 if (NILP (printcharfun)) |
329 | 589 printcharfun = Vstandard_output; |
590 GCPRO1 (obj); | |
591 PRINTPREPARE; | |
592 print_depth = 0; | |
593 PRINTCHAR ('\n'); | |
594 print (obj, printcharfun, 1); | |
595 PRINTCHAR ('\n'); | |
596 PRINTFINISH; | |
597 #ifdef MAX_PRINT_CHARS | |
598 max_print = 0; | |
599 print_chars = 0; | |
600 #endif /* MAX_PRINT_CHARS */ | |
601 UNGCPRO; | |
602 return obj; | |
603 } | |
604 | |
605 /* The subroutine object for external-debugging-output is kept here | |
606 for the convenience of the debugger. */ | |
607 Lisp_Object Qexternal_debugging_output; | |
608 | |
621 | 609 DEFUN ("external-debugging-output", Fexternal_debugging_output, Sexternal_debugging_output, 1, 1, 0, |
610 "Write CHARACTER to stderr.\n\ | |
329 | 611 You can call print while debugging emacs, and pass it this function\n\ |
612 to make it write to the debugging output.\n") | |
621 | 613 (character) |
614 Lisp_Object character; | |
329 | 615 { |
616 CHECK_NUMBER (character, 0); | |
617 putc (XINT (character), stderr); | |
618 | |
619 return character; | |
620 } | |
6533
49f896769be4
(debug_print): New function.
Richard M. Stallman <rms@gnu.org>
parents:
5852
diff
changeset
|
621 |
49f896769be4
(debug_print): New function.
Richard M. Stallman <rms@gnu.org>
parents:
5852
diff
changeset
|
622 /* This is the interface for debugging printing. */ |
49f896769be4
(debug_print): New function.
Richard M. Stallman <rms@gnu.org>
parents:
5852
diff
changeset
|
623 |
49f896769be4
(debug_print): New function.
Richard M. Stallman <rms@gnu.org>
parents:
5852
diff
changeset
|
624 void |
49f896769be4
(debug_print): New function.
Richard M. Stallman <rms@gnu.org>
parents:
5852
diff
changeset
|
625 debug_print (arg) |
49f896769be4
(debug_print): New function.
Richard M. Stallman <rms@gnu.org>
parents:
5852
diff
changeset
|
626 Lisp_Object arg; |
49f896769be4
(debug_print): New function.
Richard M. Stallman <rms@gnu.org>
parents:
5852
diff
changeset
|
627 { |
49f896769be4
(debug_print): New function.
Richard M. Stallman <rms@gnu.org>
parents:
5852
diff
changeset
|
628 Fprin1 (arg, Qexternal_debugging_output); |
49f896769be4
(debug_print): New function.
Richard M. Stallman <rms@gnu.org>
parents:
5852
diff
changeset
|
629 } |
329 | 630 |
631 #ifdef LISP_FLOAT_TYPE | |
632 | |
633 /* | |
1759
3c615a9dcd64
(float_to_string): Add `.0' at end if needed.
Richard M. Stallman <rms@gnu.org>
parents:
1521
diff
changeset
|
634 * The buffer should be at least as large as the max string size of the |
329 | 635 * largest float, printed in the biggest notation. This is undoubtably |
636 * 20d float_output_format, with the negative of the C-constant "HUGE" | |
637 * from <math.h>. | |
638 * | |
639 * On the vax the worst case is -1e38 in 20d format which takes 61 bytes. | |
640 * | |
641 * I assume that IEEE-754 format numbers can take 329 bytes for the worst | |
642 * case of -1e307 in 20d float_output_format. What is one to do (short of | |
643 * re-writing _doprnt to be more sane)? | |
644 * -wsr | |
645 */ | |
1759
3c615a9dcd64
(float_to_string): Add `.0' at end if needed.
Richard M. Stallman <rms@gnu.org>
parents:
1521
diff
changeset
|
646 |
3c615a9dcd64
(float_to_string): Add `.0' at end if needed.
Richard M. Stallman <rms@gnu.org>
parents:
1521
diff
changeset
|
647 void |
3c615a9dcd64
(float_to_string): Add `.0' at end if needed.
Richard M. Stallman <rms@gnu.org>
parents:
1521
diff
changeset
|
648 float_to_string (buf, data) |
1991
0f88f314fc34
* print.c (float_to_string): Define buf to be an unsigned char, to
Jim Blandy <jimb@redhat.com>
parents:
1967
diff
changeset
|
649 unsigned char *buf; |
329 | 650 double data; |
651 { | |
4140
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
652 unsigned char *cp; |
4224
6cb1cfba6500
(float_to_string): Don't use uninitialized pointer `cp'.
Richard M. Stallman <rms@gnu.org>
parents:
4140
diff
changeset
|
653 int width; |
329 | 654 |
520 | 655 if (NILP (Vfloat_output_format) |
9117
f69e6cf74874
(PRINTPREPARE, PRINTFINISH, float_to_string, print): Use type test macros.
Karl Heuer <kwzh@gnu.org>
parents:
8854
diff
changeset
|
656 || !STRINGP (Vfloat_output_format)) |
329 | 657 lose: |
4224
6cb1cfba6500
(float_to_string): Don't use uninitialized pointer `cp'.
Richard M. Stallman <rms@gnu.org>
parents:
4140
diff
changeset
|
658 { |
6cb1cfba6500
(float_to_string): Don't use uninitialized pointer `cp'.
Richard M. Stallman <rms@gnu.org>
parents:
4140
diff
changeset
|
659 sprintf (buf, "%.17g", data); |
6cb1cfba6500
(float_to_string): Don't use uninitialized pointer `cp'.
Richard M. Stallman <rms@gnu.org>
parents:
4140
diff
changeset
|
660 width = -1; |
6cb1cfba6500
(float_to_string): Don't use uninitialized pointer `cp'.
Richard M. Stallman <rms@gnu.org>
parents:
4140
diff
changeset
|
661 } |
329 | 662 else /* oink oink */ |
663 { | |
664 /* Check that the spec we have is fully valid. | |
665 This means not only valid for printf, | |
666 but meant for floats, and reasonable. */ | |
667 cp = XSTRING (Vfloat_output_format)->data; | |
668 | |
669 if (cp[0] != '%') | |
670 goto lose; | |
671 if (cp[1] != '.') | |
672 goto lose; | |
673 | |
674 cp += 2; | |
4140
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
675 |
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
676 /* Check the width specification. */ |
4224
6cb1cfba6500
(float_to_string): Don't use uninitialized pointer `cp'.
Richard M. Stallman <rms@gnu.org>
parents:
4140
diff
changeset
|
677 width = -1; |
4140
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
678 if ('0' <= *cp && *cp <= '9') |
11798
7646040d7383
(float_to_string): Fix type mismatch and simplify.
Karl Heuer <kwzh@gnu.org>
parents:
11697
diff
changeset
|
679 { |
7646040d7383
(float_to_string): Fix type mismatch and simplify.
Karl Heuer <kwzh@gnu.org>
parents:
11697
diff
changeset
|
680 width = 0; |
7646040d7383
(float_to_string): Fix type mismatch and simplify.
Karl Heuer <kwzh@gnu.org>
parents:
11697
diff
changeset
|
681 do |
7646040d7383
(float_to_string): Fix type mismatch and simplify.
Karl Heuer <kwzh@gnu.org>
parents:
11697
diff
changeset
|
682 width = (width * 10) + (*cp++ - '0'); |
7646040d7383
(float_to_string): Fix type mismatch and simplify.
Karl Heuer <kwzh@gnu.org>
parents:
11697
diff
changeset
|
683 while (*cp >= '0' && *cp <= '9'); |
7646040d7383
(float_to_string): Fix type mismatch and simplify.
Karl Heuer <kwzh@gnu.org>
parents:
11697
diff
changeset
|
684 |
7646040d7383
(float_to_string): Fix type mismatch and simplify.
Karl Heuer <kwzh@gnu.org>
parents:
11697
diff
changeset
|
685 /* A precision of zero is valid only for %f. */ |
7646040d7383
(float_to_string): Fix type mismatch and simplify.
Karl Heuer <kwzh@gnu.org>
parents:
11697
diff
changeset
|
686 if (width > DBL_DIG |
7646040d7383
(float_to_string): Fix type mismatch and simplify.
Karl Heuer <kwzh@gnu.org>
parents:
11697
diff
changeset
|
687 || (width == 0 && *cp != 'f')) |
7646040d7383
(float_to_string): Fix type mismatch and simplify.
Karl Heuer <kwzh@gnu.org>
parents:
11697
diff
changeset
|
688 goto lose; |
7646040d7383
(float_to_string): Fix type mismatch and simplify.
Karl Heuer <kwzh@gnu.org>
parents:
11697
diff
changeset
|
689 } |
329 | 690 |
691 if (*cp != 'e' && *cp != 'f' && *cp != 'g') | |
692 goto lose; | |
693 | |
694 if (cp[1] != 0) | |
695 goto lose; | |
696 | |
697 sprintf (buf, XSTRING (Vfloat_output_format)->data, data); | |
698 } | |
1759
3c615a9dcd64
(float_to_string): Add `.0' at end if needed.
Richard M. Stallman <rms@gnu.org>
parents:
1521
diff
changeset
|
699 |
4140
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
700 /* Make sure there is a decimal point with digit after, or an |
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
701 exponent, so that the value is readable as a float. But don't do |
4224
6cb1cfba6500
(float_to_string): Don't use uninitialized pointer `cp'.
Richard M. Stallman <rms@gnu.org>
parents:
4140
diff
changeset
|
702 this with "%.0f"; it's valid for that not to produce a decimal |
6cb1cfba6500
(float_to_string): Don't use uninitialized pointer `cp'.
Richard M. Stallman <rms@gnu.org>
parents:
4140
diff
changeset
|
703 point. Note that width can be 0 only for %.0f. */ |
6cb1cfba6500
(float_to_string): Don't use uninitialized pointer `cp'.
Richard M. Stallman <rms@gnu.org>
parents:
4140
diff
changeset
|
704 if (width != 0) |
1764
94ff5d9ef48a
(float_to_string): Add final 0 if text ends with decimal pt.
Richard M. Stallman <rms@gnu.org>
parents:
1759
diff
changeset
|
705 { |
4140
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
706 for (cp = buf; *cp; cp++) |
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
707 if ((*cp < '0' || *cp > '9') && *cp != '-') |
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
708 break; |
1764
94ff5d9ef48a
(float_to_string): Add final 0 if text ends with decimal pt.
Richard M. Stallman <rms@gnu.org>
parents:
1759
diff
changeset
|
709 |
4140
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
710 if (*cp == '.' && cp[1] == 0) |
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
711 { |
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
712 cp[1] = '0'; |
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
713 cp[2] = 0; |
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
714 } |
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
715 |
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
716 if (*cp == 0) |
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
717 { |
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
718 *cp++ = '.'; |
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
719 *cp++ = '0'; |
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
720 *cp++ = 0; |
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
721 } |
1759
3c615a9dcd64
(float_to_string): Add `.0' at end if needed.
Richard M. Stallman <rms@gnu.org>
parents:
1521
diff
changeset
|
722 } |
329 | 723 } |
724 #endif /* LISP_FLOAT_TYPE */ | |
725 | |
726 static void | |
727 print (obj, printcharfun, escapeflag) | |
728 Lisp_Object obj; | |
729 register Lisp_Object printcharfun; | |
730 int escapeflag; | |
731 { | |
732 char buf[30]; | |
733 | |
734 QUIT; | |
735 | |
379
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
736 #if 1 /* I'm not sure this is really worth doing. */ |
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
737 /* Detect circularities and truncate them. |
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
738 No need to offer any alternative--this is better than an error. */ |
9117
f69e6cf74874
(PRINTPREPARE, PRINTFINISH, float_to_string, print): Use type test macros.
Karl Heuer <kwzh@gnu.org>
parents:
8854
diff
changeset
|
739 if (CONSP (obj) || VECTORP (obj) || COMPILEDP (obj)) |
379
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
740 { |
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
741 int i; |
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
742 for (i = 0; i < print_depth; i++) |
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
743 if (EQ (obj, being_printed[i])) |
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
744 { |
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
745 sprintf (buf, "#%d", i); |
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
746 strout (buf, -1, printcharfun); |
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
747 return; |
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
748 } |
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
749 } |
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
750 #endif |
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
751 |
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
752 being_printed[print_depth] = obj; |
329 | 753 print_depth++; |
754 | |
379
34ec8957c6c0
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
373
diff
changeset
|
755 if (print_depth > PRINT_CIRCLE) |
329 | 756 error ("Apparently circular structure being printed"); |
757 #ifdef MAX_PRINT_CHARS | |
758 if (max_print && print_chars > max_print) | |
759 { | |
760 PRINTCHAR ('\n'); | |
761 print_chars = 0; | |
762 } | |
763 #endif /* MAX_PRINT_CHARS */ | |
764 | |
10293
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
765 switch (XGCTYPE (obj)) |
329 | 766 { |
10293
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
767 case Lisp_Int: |
11697
2de5b0c89802
(print): Make the printing understand EMACS_INTs
Richard M. Stallman <rms@gnu.org>
parents:
11341
diff
changeset
|
768 if (sizeof (int) == sizeof (EMACS_INT)) |
2de5b0c89802
(print): Make the printing understand EMACS_INTs
Richard M. Stallman <rms@gnu.org>
parents:
11341
diff
changeset
|
769 sprintf (buf, "%d", XINT (obj)); |
2de5b0c89802
(print): Make the printing understand EMACS_INTs
Richard M. Stallman <rms@gnu.org>
parents:
11341
diff
changeset
|
770 else if (sizeof (long) == sizeof (EMACS_INT)) |
2de5b0c89802
(print): Make the printing understand EMACS_INTs
Richard M. Stallman <rms@gnu.org>
parents:
11341
diff
changeset
|
771 sprintf (buf, "%ld", XINT (obj)); |
2de5b0c89802
(print): Make the printing understand EMACS_INTs
Richard M. Stallman <rms@gnu.org>
parents:
11341
diff
changeset
|
772 else |
2de5b0c89802
(print): Make the printing understand EMACS_INTs
Richard M. Stallman <rms@gnu.org>
parents:
11341
diff
changeset
|
773 abort (); |
329 | 774 strout (buf, -1, printcharfun); |
10293
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
775 break; |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
776 |
10001 | 777 #ifdef LISP_FLOAT_TYPE |
10293
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
778 case Lisp_Float: |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
779 { |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
780 char pigbuf[350]; /* see comments in float_to_string */ |
329 | 781 |
10293
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
782 float_to_string (pigbuf, XFLOAT(obj)->data); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
783 strout (pigbuf, -1, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
784 } |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
785 break; |
10001 | 786 #endif |
10293
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
787 |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
788 case Lisp_String: |
329 | 789 if (!escapeflag) |
790 print_string (obj, printcharfun); | |
791 else | |
792 { | |
793 register int i; | |
794 register unsigned char c; | |
795 struct gcpro gcpro1; | |
796 | |
1967 | 797 GCPRO1 (obj); |
798 | |
799 #ifdef USE_TEXT_PROPERTIES | |
800 if (!NULL_INTERVAL_P (XSTRING (obj)->intervals)) | |
801 { | |
802 PRINTCHAR ('#'); | |
803 PRINTCHAR ('('); | |
804 } | |
805 #endif | |
329 | 806 |
807 PRINTCHAR ('\"'); | |
808 for (i = 0; i < XSTRING (obj)->size; i++) | |
809 { | |
810 QUIT; | |
811 c = XSTRING (obj)->data[i]; | |
812 if (c == '\n' && print_escape_newlines) | |
813 { | |
814 PRINTCHAR ('\\'); | |
815 PRINTCHAR ('n'); | |
816 } | |
5852
f2e341b1f908
(print): If print_escapes_newlines, print '\f' as "\\f".
Roland McGrath <roland@gnu.org>
parents:
5487
diff
changeset
|
817 else if (c == '\f' && print_escape_newlines) |
f2e341b1f908
(print): If print_escapes_newlines, print '\f' as "\\f".
Roland McGrath <roland@gnu.org>
parents:
5487
diff
changeset
|
818 { |
f2e341b1f908
(print): If print_escapes_newlines, print '\f' as "\\f".
Roland McGrath <roland@gnu.org>
parents:
5487
diff
changeset
|
819 PRINTCHAR ('\\'); |
f2e341b1f908
(print): If print_escapes_newlines, print '\f' as "\\f".
Roland McGrath <roland@gnu.org>
parents:
5487
diff
changeset
|
820 PRINTCHAR ('f'); |
f2e341b1f908
(print): If print_escapes_newlines, print '\f' as "\\f".
Roland McGrath <roland@gnu.org>
parents:
5487
diff
changeset
|
821 } |
329 | 822 else |
823 { | |
824 if (c == '\"' || c == '\\') | |
825 PRINTCHAR ('\\'); | |
826 PRINTCHAR (c); | |
827 } | |
828 } | |
829 PRINTCHAR ('\"'); | |
1967 | 830 |
831 #ifdef USE_TEXT_PROPERTIES | |
832 if (!NULL_INTERVAL_P (XSTRING (obj)->intervals)) | |
833 { | |
834 traverse_intervals (XSTRING (obj)->intervals, | |
835 0, 0, print_interval, printcharfun); | |
836 PRINTCHAR (')'); | |
837 } | |
838 #endif | |
839 | |
329 | 840 UNGCPRO; |
841 } | |
10293
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
842 break; |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
843 |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
844 case Lisp_Symbol: |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
845 { |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
846 register int confusing; |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
847 register unsigned char *p = XSYMBOL (obj)->name->data; |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
848 register unsigned char *end = p + XSYMBOL (obj)->name->size; |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
849 register unsigned char c; |
329 | 850 |
10293
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
851 if (p != end && (*p == '-' || *p == '+')) p++; |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
852 if (p == end) |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
853 confusing = 0; |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
854 else |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
855 { |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
856 while (p != end && *p >= '0' && *p <= '9') |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
857 p++; |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
858 confusing = (end == p); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
859 } |
329 | 860 |
10293
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
861 p = XSYMBOL (obj)->name->data; |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
862 while (p != end) |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
863 { |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
864 QUIT; |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
865 c = *p++; |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
866 if (escapeflag) |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
867 { |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
868 if (c == '\"' || c == '\\' || c == '\'' || c == ';' || c == '#' || |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
869 c == '(' || c == ')' || c == ',' || c =='.' || c == '`' || |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
870 c == '[' || c == ']' || c == '?' || c <= 040 || confusing) |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
871 PRINTCHAR ('\\'), confusing = 0; |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
872 } |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
873 PRINTCHAR (c); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
874 } |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
875 } |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
876 break; |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
877 |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
878 case Lisp_Cons: |
329 | 879 /* If deeper than spec'd depth, print placeholder. */ |
9117
f69e6cf74874
(PRINTPREPARE, PRINTFINISH, float_to_string, print): Use type test macros.
Karl Heuer <kwzh@gnu.org>
parents:
8854
diff
changeset
|
880 if (INTEGERP (Vprint_level) |
329 | 881 && print_depth > XINT (Vprint_level)) |
10001 | 882 strout ("...", -1, printcharfun); |
883 else | |
329 | 884 { |
10001 | 885 PRINTCHAR ('('); |
329 | 886 { |
10001 | 887 register int i = 0; |
888 register int max = 0; | |
889 | |
890 if (INTEGERP (Vprint_length)) | |
891 max = XINT (Vprint_length); | |
892 /* Could recognize circularities in cdrs here, | |
893 but that would make printing of long lists quadratic. | |
894 It's not worth doing. */ | |
895 while (CONSP (obj)) | |
329 | 896 { |
10001 | 897 if (i++) |
898 PRINTCHAR (' '); | |
899 if (max && i > max) | |
900 { | |
901 strout ("...", 3, printcharfun); | |
902 break; | |
903 } | |
904 print (Fcar (obj), printcharfun, escapeflag); | |
905 obj = Fcdr (obj); | |
329 | 906 } |
907 } | |
10001 | 908 if (!NILP (obj) && !CONSP (obj)) |
909 { | |
910 strout (" . ", 3, printcharfun); | |
911 print (obj, printcharfun, escapeflag); | |
912 } | |
913 PRINTCHAR (')'); | |
329 | 914 } |
10293
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
915 break; |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
916 |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
917 case Lisp_Vectorlike: |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
918 if (PROCESSP (obj)) |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
919 { |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
920 if (escapeflag) |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
921 { |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
922 strout ("#<process ", -1, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
923 print_string (XPROCESS (obj)->name, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
924 PRINTCHAR ('>'); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
925 } |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
926 else |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
927 print_string (XPROCESS (obj)->name, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
928 } |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
929 else if (SUBRP (obj)) |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
930 { |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
931 strout ("#<subr ", -1, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
932 strout (XSUBR (obj)->symbol_name, -1, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
933 PRINTCHAR ('>'); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
934 } |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
935 #ifndef standalone |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
936 else if (WINDOWP (obj)) |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
937 { |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
938 strout ("#<window ", -1, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
939 sprintf (buf, "%d", XFASTINT (XWINDOW (obj)->sequence_number)); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
940 strout (buf, -1, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
941 if (!NILP (XWINDOW (obj)->buffer)) |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
942 { |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
943 strout (" on ", -1, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
944 print_string (XBUFFER (XWINDOW (obj)->buffer)->name, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
945 } |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
946 PRINTCHAR ('>'); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
947 } |
10301
aa73a5c0d1f2
(print): Don't drop thru to error for markers and overlays.
Richard M. Stallman <rms@gnu.org>
parents:
10293
diff
changeset
|
948 else if (BUFFERP (obj)) |
aa73a5c0d1f2
(print): Don't drop thru to error for markers and overlays.
Richard M. Stallman <rms@gnu.org>
parents:
10293
diff
changeset
|
949 { |
aa73a5c0d1f2
(print): Don't drop thru to error for markers and overlays.
Richard M. Stallman <rms@gnu.org>
parents:
10293
diff
changeset
|
950 if (NILP (XBUFFER (obj)->name)) |
aa73a5c0d1f2
(print): Don't drop thru to error for markers and overlays.
Richard M. Stallman <rms@gnu.org>
parents:
10293
diff
changeset
|
951 strout ("#<killed buffer>", -1, printcharfun); |
aa73a5c0d1f2
(print): Don't drop thru to error for markers and overlays.
Richard M. Stallman <rms@gnu.org>
parents:
10293
diff
changeset
|
952 else if (escapeflag) |
aa73a5c0d1f2
(print): Don't drop thru to error for markers and overlays.
Richard M. Stallman <rms@gnu.org>
parents:
10293
diff
changeset
|
953 { |
aa73a5c0d1f2
(print): Don't drop thru to error for markers and overlays.
Richard M. Stallman <rms@gnu.org>
parents:
10293
diff
changeset
|
954 strout ("#<buffer ", -1, printcharfun); |
aa73a5c0d1f2
(print): Don't drop thru to error for markers and overlays.
Richard M. Stallman <rms@gnu.org>
parents:
10293
diff
changeset
|
955 print_string (XBUFFER (obj)->name, printcharfun); |
aa73a5c0d1f2
(print): Don't drop thru to error for markers and overlays.
Richard M. Stallman <rms@gnu.org>
parents:
10293
diff
changeset
|
956 PRINTCHAR ('>'); |
aa73a5c0d1f2
(print): Don't drop thru to error for markers and overlays.
Richard M. Stallman <rms@gnu.org>
parents:
10293
diff
changeset
|
957 } |
aa73a5c0d1f2
(print): Don't drop thru to error for markers and overlays.
Richard M. Stallman <rms@gnu.org>
parents:
10293
diff
changeset
|
958 else |
aa73a5c0d1f2
(print): Don't drop thru to error for markers and overlays.
Richard M. Stallman <rms@gnu.org>
parents:
10293
diff
changeset
|
959 print_string (XBUFFER (obj)->name, printcharfun); |
aa73a5c0d1f2
(print): Don't drop thru to error for markers and overlays.
Richard M. Stallman <rms@gnu.org>
parents:
10293
diff
changeset
|
960 } |
10293
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
961 else if (WINDOW_CONFIGURATIONP (obj)) |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
962 { |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
963 strout ("#<window-configuration>", -1, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
964 } |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
965 #ifdef MULTI_FRAME |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
966 else if (FRAMEP (obj)) |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
967 { |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
968 strout ((FRAME_LIVE_P (XFRAME (obj)) |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
969 ? "#<frame " : "#<dead frame "), |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
970 -1, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
971 print_string (XFRAME (obj)->name, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
972 sprintf (buf, " 0x%lx", (unsigned long) (XFRAME (obj))); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
973 strout (buf, -1, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
974 PRINTCHAR ('>'); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
975 } |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
976 #endif |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
977 #endif /* not standalone */ |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
978 else |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
979 { |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
980 int size = XVECTOR (obj)->size; |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
981 if (COMPILEDP (obj)) |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
982 { |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
983 PRINTCHAR ('#'); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
984 size &= PSEUDOVECTOR_SIZE_MASK; |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
985 } |
10482
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
986 if (size & PSEUDOVECTOR_FLAG) |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
987 goto badtype; |
10293
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
988 |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
989 PRINTCHAR ('['); |
329 | 990 { |
10293
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
991 register int i; |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
992 register Lisp_Object tem; |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
993 for (i = 0; i < size; i++) |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
994 { |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
995 if (i) PRINTCHAR (' '); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
996 tem = XVECTOR (obj)->contents[i]; |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
997 print (tem, printcharfun, escapeflag); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
998 } |
329 | 999 } |
10293
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1000 PRINTCHAR (']'); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1001 } |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1002 break; |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1003 |
329 | 1004 #ifndef standalone |
10293
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1005 case Lisp_Misc: |
11241
5fed07fb66fb
(print): Use XMISCTYPE.
Richard M. Stallman <rms@gnu.org>
parents:
11235
diff
changeset
|
1006 switch (XMISCTYPE (obj)) |
329 | 1007 { |
10482
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1008 case Lisp_Misc_Marker: |
10293
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1009 strout ("#<marker ", -1, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1010 if (!(XMARKER (obj)->buffer)) |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1011 strout ("in no buffer", -1, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1012 else |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1013 { |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1014 sprintf (buf, "at %d", marker_position (obj)); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1015 strout (buf, -1, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1016 strout (" in ", -1, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1017 print_string (XMARKER (obj)->buffer->name, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1018 } |
329 | 1019 PRINTCHAR ('>'); |
10301
aa73a5c0d1f2
(print): Don't drop thru to error for markers and overlays.
Richard M. Stallman <rms@gnu.org>
parents:
10293
diff
changeset
|
1020 break; |
10482
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1021 |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1022 case Lisp_Misc_Overlay: |
10293
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1023 strout ("#<overlay ", -1, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1024 if (!(XMARKER (OVERLAY_START (obj))->buffer)) |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1025 strout ("in no buffer", -1, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1026 else |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1027 { |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1028 sprintf (buf, "from %d to %d in ", |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1029 marker_position (OVERLAY_START (obj)), |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1030 marker_position (OVERLAY_END (obj))); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1031 strout (buf, -1, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1032 print_string (XMARKER (OVERLAY_START (obj))->buffer->name, |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1033 printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1034 } |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1035 PRINTCHAR ('>'); |
10301
aa73a5c0d1f2
(print): Don't drop thru to error for markers and overlays.
Richard M. Stallman <rms@gnu.org>
parents:
10293
diff
changeset
|
1036 break; |
10482
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1037 |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1038 /* Remaining cases shouldn't happen in normal usage, but let's print |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1039 them anyway for the benefit of the debugger. */ |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1040 case Lisp_Misc_Free: |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1041 strout ("#<misc free cell>", -1, printcharfun); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1042 break; |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1043 |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1044 case Lisp_Misc_Intfwd: |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1045 sprintf (buf, "#<intfwd to %d>", *XINTFWD (obj)->intvar); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1046 strout (buf, -1, printcharfun); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1047 break; |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1048 |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1049 case Lisp_Misc_Boolfwd: |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1050 sprintf (buf, "#<boolfwd to %s>", |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1051 (*XBOOLFWD (obj)->boolvar ? "t" : "nil")); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1052 strout (buf, -1, printcharfun); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1053 break; |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1054 |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1055 case Lisp_Misc_Objfwd: |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1056 strout (buf, "#<objfwd to ", -1, printcharfun); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1057 print (*XOBJFWD (obj)->objvar, printcharfun, escapeflag); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1058 PRINTCHAR ('>'); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1059 break; |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1060 |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1061 case Lisp_Misc_Buffer_Objfwd: |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1062 strout (buf, "#<buffer_objfwd to ", -1, printcharfun); |
10583
6736693cb8c8
(print): Handle internal display-local object.
Karl Heuer <kwzh@gnu.org>
parents:
10568
diff
changeset
|
1063 print (*(Lisp_Object *)((char *)current_buffer |
6736693cb8c8
(print): Handle internal display-local object.
Karl Heuer <kwzh@gnu.org>
parents:
10568
diff
changeset
|
1064 + XBUFFER_OBJFWD (obj)->offset), |
6736693cb8c8
(print): Handle internal display-local object.
Karl Heuer <kwzh@gnu.org>
parents:
10568
diff
changeset
|
1065 printcharfun, escapeflag); |
6736693cb8c8
(print): Handle internal display-local object.
Karl Heuer <kwzh@gnu.org>
parents:
10568
diff
changeset
|
1066 PRINTCHAR ('>'); |
6736693cb8c8
(print): Handle internal display-local object.
Karl Heuer <kwzh@gnu.org>
parents:
10568
diff
changeset
|
1067 break; |
6736693cb8c8
(print): Handle internal display-local object.
Karl Heuer <kwzh@gnu.org>
parents:
10568
diff
changeset
|
1068 |
11010
45ae0022c48a
(print): Rename perdisplay to kboard.
Karl Heuer <kwzh@gnu.org>
parents:
10993
diff
changeset
|
1069 case Lisp_Misc_Kboard_Objfwd: |
45ae0022c48a
(print): Rename perdisplay to kboard.
Karl Heuer <kwzh@gnu.org>
parents:
10993
diff
changeset
|
1070 strout (buf, "#<kboard_objfwd to ", -1, printcharfun); |
45ae0022c48a
(print): Rename perdisplay to kboard.
Karl Heuer <kwzh@gnu.org>
parents:
10993
diff
changeset
|
1071 print (*(Lisp_Object *)((char *) current_kboard |
45ae0022c48a
(print): Rename perdisplay to kboard.
Karl Heuer <kwzh@gnu.org>
parents:
10993
diff
changeset
|
1072 + XKBOARD_OBJFWD (obj)->offset), |
10993
e72bd65cab70
(print): current_perdisplay now is never null.
Karl Heuer <kwzh@gnu.org>
parents:
10651
diff
changeset
|
1073 printcharfun, escapeflag); |
10482
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1074 PRINTCHAR ('>'); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1075 break; |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1076 |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1077 case Lisp_Misc_Buffer_Local_Value: |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1078 strout ("#<buffer_local_value ", -1, printcharfun); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1079 goto do_buffer_local; |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1080 case Lisp_Misc_Some_Buffer_Local_Value: |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1081 strout ("#<some_buffer_local_value ", -1, printcharfun); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1082 do_buffer_local: |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1083 strout ("[realvalue] ", -1, printcharfun); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1084 print (XBUFFER_LOCAL_VALUE (obj)->car, printcharfun, escapeflag); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1085 strout ("[buffer] ", -1, printcharfun); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1086 print (XCONS (XBUFFER_LOCAL_VALUE (obj)->cdr)->car, |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1087 printcharfun, escapeflag); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1088 strout ("[alist-elt] ", -1, printcharfun); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1089 print (XCONS (XCONS (XBUFFER_LOCAL_VALUE (obj)->cdr)->cdr)->car, |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1090 printcharfun, escapeflag); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1091 strout ("[default-value] ", -1, printcharfun); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1092 print (XCONS (XCONS (XBUFFER_LOCAL_VALUE (obj)->cdr)->cdr)->cdr, |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1093 printcharfun, escapeflag); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1094 PRINTCHAR ('>'); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1095 break; |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1096 |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1097 default: |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1098 goto badtype; |
329 | 1099 } |
10482
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1100 break; |
329 | 1101 #endif /* standalone */ |
10293
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1102 |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1103 default: |
10482
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1104 badtype: |
10293
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1105 { |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1106 /* We're in trouble if this happens! |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1107 Probably should just abort () */ |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1108 strout ("#<EMACS BUG: INVALID DATATYPE ", -1, printcharfun); |
10482
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1109 if (MISCP (obj)) |
11241
5fed07fb66fb
(print): Use XMISCTYPE.
Richard M. Stallman <rms@gnu.org>
parents:
11235
diff
changeset
|
1110 sprintf (buf, "(MISC 0x%04x)", (int) XMISCTYPE (obj)); |
10482
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1111 else if (VECTORLIKEP (obj)) |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1112 sprintf (buf, "(PVEC 0x%08x)", (int) XVECTOR (obj)->size); |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1113 else |
a15a058ec779
(print): Print internal types too, for debugging.
Karl Heuer <kwzh@gnu.org>
parents:
10418
diff
changeset
|
1114 sprintf (buf, "(0x%02x)", (int) XTYPE (obj)); |
10293
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1115 strout (buf, -1, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1116 strout (" Save your buffers immediately and please report this bug>", |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1117 -1, printcharfun); |
96cc5c0a7ada
(print): Get size of compiled function as pseudovector.
Richard M. Stallman <rms@gnu.org>
parents:
10001
diff
changeset
|
1118 } |
329 | 1119 } |
1120 | |
1121 print_depth--; | |
1122 } | |
1123 | |
1967 | 1124 #ifdef USE_TEXT_PROPERTIES |
1125 | |
1126 /* Print a description of INTERVAL using PRINTCHARFUN. | |
1127 This is part of printing a string that has text properties. */ | |
1128 | |
1129 void | |
1130 print_interval (interval, printcharfun) | |
1131 INTERVAL interval; | |
1132 Lisp_Object printcharfun; | |
1133 { | |
4003
49918d6c6dda
* print.c: Get rid of extra space at the end of print syntax for
Jim Blandy <jimb@redhat.com>
parents:
3591
diff
changeset
|
1134 PRINTCHAR (' '); |
1967 | 1135 print (make_number (interval->position), printcharfun, 1); |
1136 PRINTCHAR (' '); | |
1137 print (make_number (interval->position + LENGTH (interval)), | |
1138 printcharfun, 1); | |
1139 PRINTCHAR (' '); | |
1140 print (interval->plist, printcharfun, 1); | |
1141 } | |
1142 | |
1143 #endif /* USE_TEXT_PROPERTIES */ | |
1144 | |
329 | 1145 void |
1146 syms_of_print () | |
1147 { | |
1148 staticpro (&Qprint_escape_newlines); | |
1149 Qprint_escape_newlines = intern ("print-escape-newlines"); | |
1150 | |
1151 DEFVAR_LISP ("standard-output", &Vstandard_output, | |
1152 "Output stream `print' uses by default for outputting a character.\n\ | |
1153 This may be any function of one argument.\n\ | |
1154 It may also be a buffer (output is inserted before point)\n\ | |
1155 or a marker (output is inserted and the marker is advanced)\n\ | |
1156 or the symbol t (output appears in the minibuffer line)."); | |
1157 Vstandard_output = Qt; | |
1158 Qstandard_output = intern ("standard-output"); | |
1159 staticpro (&Qstandard_output); | |
1160 | |
1161 #ifdef LISP_FLOAT_TYPE | |
1162 DEFVAR_LISP ("float-output-format", &Vfloat_output_format, | |
687
e2b747dd6a6e
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
686
diff
changeset
|
1163 "The format descriptor string used to print floats.\n\ |
329 | 1164 This is a %-spec like those accepted by `printf' in C,\n\ |
1165 but with some restrictions. It must start with the two characters `%.'.\n\ | |
1166 After that comes an integer precision specification,\n\ | |
1167 and then a letter which controls the format.\n\ | |
1168 The letters allowed are `e', `f' and `g'.\n\ | |
1169 Use `e' for exponential notation \"DIG.DIGITSeEXPT\"\n\ | |
1170 Use `f' for decimal point notation \"DIGITS.DIGITS\".\n\ | |
1171 Use `g' to choose the shorter of those two formats for the number at hand.\n\ | |
1172 The precision in any of these cases is the number of digits following\n\ | |
1173 the decimal point. With `f', a precision of 0 means to omit the\n\ | |
4140
2738089e8383
* print.c (float_to_string): Distinguish between a precision of
Jim Blandy <jimb@redhat.com>
parents:
4003
diff
changeset
|
1174 decimal point. 0 is not allowed with `e' or `g'.\n\n\ |
4224
6cb1cfba6500
(float_to_string): Don't use uninitialized pointer `cp'.
Richard M. Stallman <rms@gnu.org>
parents:
4140
diff
changeset
|
1175 A value of nil means to use `%.17g'."); |
329 | 1176 Vfloat_output_format = Qnil; |
1177 Qfloat_output_format = intern ("float-output-format"); | |
1178 staticpro (&Qfloat_output_format); | |
1179 #endif /* LISP_FLOAT_TYPE */ | |
1180 | |
1181 DEFVAR_LISP ("print-length", &Vprint_length, | |
686
bd3068742807
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
621
diff
changeset
|
1182 "Maximum length of list to print before abbreviating.\n\ |
329 | 1183 A value of nil means no limit."); |
1184 Vprint_length = Qnil; | |
1185 | |
1186 DEFVAR_LISP ("print-level", &Vprint_level, | |
686
bd3068742807
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
621
diff
changeset
|
1187 "Maximum depth of list nesting to print before abbreviating.\n\ |
329 | 1188 A value of nil means no limit."); |
1189 Vprint_level = Qnil; | |
1190 | |
1191 DEFVAR_BOOL ("print-escape-newlines", &print_escape_newlines, | |
6802
7d69da13c140
(syms_of_print): Doc fix.
Richard M. Stallman <rms@gnu.org>
parents:
6533
diff
changeset
|
1192 "Non-nil means print newlines in strings as backslash-n.\n\ |
5852
f2e341b1f908
(print): If print_escapes_newlines, print '\f' as "\\f".
Roland McGrath <roland@gnu.org>
parents:
5487
diff
changeset
|
1193 Also print formfeeds as backslash-f."); |
329 | 1194 print_escape_newlines = 0; |
1195 | |
1196 /* prin1_to_string_buffer initialized in init_buffer_once in buffer.c */ | |
1197 staticpro (&Vprin1_to_string_buffer); | |
1198 | |
1199 defsubr (&Sprin1); | |
1200 defsubr (&Sprin1_to_string); | |
1201 defsubr (&Sprinc); | |
1202 defsubr (&Sprint); | |
1203 defsubr (&Sterpri); | |
1204 defsubr (&Swrite_char); | |
1205 defsubr (&Sexternal_debugging_output); | |
1206 | |
1207 Qexternal_debugging_output = intern ("external-debugging-output"); | |
1208 staticpro (&Qexternal_debugging_output); | |
1209 | |
1210 #ifndef standalone | |
1211 defsubr (&Swith_output_to_temp_buffer); | |
1212 #endif /* not standalone */ | |
1213 } |