HCoop / bpt / emacs.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* bytecode.c (targets): Suppress -Woverride-init warnings.
[bpt/emacs.git] / src / bytecode.c
1 /* Execution of byte code produced by bytecomp.el.
2 Copyright (C) 1985-1988, 1993, 2000-2012 Free Software Foundation, Inc.
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
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) 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. If not, see <http://www.gnu.org/licenses/>. */
18
19 /*
20 hacked on by jwz@lucid.com 17-jun-91
21 o added a compile-time switch to turn on simple sanity checking;
22 o put back the obsolete byte-codes for error-detection;
23 o added a new instruction, unbind_all, which I will use for
24 tail-recursion elimination;
25 o made temp_output_buffer_show be called with the right number
26 of args;
27 o made the new bytecodes be called with args in the right order;
28 o added metering support.
29
30 by Hallvard:
31 o added relative jump instructions;
32 o all conditionals now only do QUIT if they jump.
33 */
34
35 #include <config.h>
36 #include <setjmp.h>
37 #include "lisp.h"
38 #include "character.h"
39 #include "buffer.h"
40 #include "syntax.h"
41 #include "window.h"
42
43 #ifdef CHECK_FRAME_FONT
44 #include "frame.h"
45 #include "xterm.h"
46 #endif
47
48 /*
49 * define BYTE_CODE_SAFE to enable some minor sanity checking (useful for
50 * debugging the byte compiler...)
51 *
52 * define BYTE_CODE_METER to enable generation of a byte-op usage histogram.
53 */
54 /* #define BYTE_CODE_SAFE */
55 /* #define BYTE_CODE_METER */
56
57 /* If BYTE_CODE_THREADED is defined, then the interpreter will be
58 indirect threaded, using GCC's computed goto extension. This code,
59 as currently implemented, is incompatible with BYTE_CODE_SAFE and
60 BYTE_CODE_METER. */
61 #if defined (__GNUC__) && !defined (BYTE_CODE_SAFE) && !defined (BYTE_CODE_METER)
62 #define BYTE_CODE_THREADED
63 #endif
64
65 \f
66 #ifdef BYTE_CODE_METER
67
68 Lisp_Object Qbyte_code_meter;
69 #define METER_2(code1, code2) AREF (AREF (Vbyte_code_meter, code1), code2)
70 #define METER_1(code) METER_2 (0, code)
71
72 #define METER_CODE(last_code, this_code) \
73 { \
74 if (byte_metering_on) \
75 { \
76 if (XFASTINT (METER_1 (this_code)) < MOST_POSITIVE_FIXNUM) \
77 XSETFASTINT (METER_1 (this_code), \
78 XFASTINT (METER_1 (this_code)) + 1); \
79 if (last_code \
80 && (XFASTINT (METER_2 (last_code, this_code)) \
81 < MOST_POSITIVE_FIXNUM)) \
82 XSETFASTINT (METER_2 (last_code, this_code), \
83 XFASTINT (METER_2 (last_code, this_code)) + 1); \
84 } \
85 }
86
87 #endif /* BYTE_CODE_METER */
88 \f
89
90 Lisp_Object Qbytecode;
91
92 /* Byte codes: */
93
94 #define BYTE_CODES \
95 DEFINE (Bstack_ref, 0) /* Actually, Bstack_ref+0 is not implemented: use dup. */ \
96 DEFINE (Bstack_ref1, 1) \
97 DEFINE (Bstack_ref2, 2) \
98 DEFINE (Bstack_ref3, 3) \
99 DEFINE (Bstack_ref4, 4) \
100 DEFINE (Bstack_ref5, 5) \
101 DEFINE (Bstack_ref6, 6) \
102 DEFINE (Bstack_ref7, 7) \
103 DEFINE (Bvarref, 010) \
104 DEFINE (Bvarref1, 011) \
105 DEFINE (Bvarref2, 012) \
106 DEFINE (Bvarref3, 013) \
107 DEFINE (Bvarref4, 014) \
108 DEFINE (Bvarref5, 015) \
109 DEFINE (Bvarref6, 016) \
110 DEFINE (Bvarref7, 017) \
111 DEFINE (Bvarset, 020) \
112 DEFINE (Bvarset1, 021) \
113 DEFINE (Bvarset2, 022) \
114 DEFINE (Bvarset3, 023) \
115 DEFINE (Bvarset4, 024) \
116 DEFINE (Bvarset5, 025) \
117 DEFINE (Bvarset6, 026) \
118 DEFINE (Bvarset7, 027) \
119 DEFINE (Bvarbind, 030) \
120 DEFINE (Bvarbind1, 031) \
121 DEFINE (Bvarbind2, 032) \
122 DEFINE (Bvarbind3, 033) \
123 DEFINE (Bvarbind4, 034) \
124 DEFINE (Bvarbind5, 035) \
125 DEFINE (Bvarbind6, 036) \
126 DEFINE (Bvarbind7, 037) \
127 DEFINE (Bcall, 040) \
128 DEFINE (Bcall1, 041) \
129 DEFINE (Bcall2, 042) \
130 DEFINE (Bcall3, 043) \
131 DEFINE (Bcall4, 044) \
132 DEFINE (Bcall5, 045) \
133 DEFINE (Bcall6, 046) \
134 DEFINE (Bcall7, 047) \
135 DEFINE (Bunbind, 050) \
136 DEFINE (Bunbind1, 051) \
137 DEFINE (Bunbind2, 052) \
138 DEFINE (Bunbind3, 053) \
139 DEFINE (Bunbind4, 054) \
140 DEFINE (Bunbind5, 055) \
141 DEFINE (Bunbind6, 056) \
142 DEFINE (Bunbind7, 057) \
143 \
144 DEFINE (Bnth, 070) \
145 DEFINE (Bsymbolp, 071) \
146 DEFINE (Bconsp, 072) \
147 DEFINE (Bstringp, 073) \
148 DEFINE (Blistp, 074) \
149 DEFINE (Beq, 075) \
150 DEFINE (Bmemq, 076) \
151 DEFINE (Bnot, 077) \
152 DEFINE (Bcar, 0100) \
153 DEFINE (Bcdr, 0101) \
154 DEFINE (Bcons, 0102) \
155 DEFINE (Blist1, 0103) \
156 DEFINE (Blist2, 0104) \
157 DEFINE (Blist3, 0105) \
158 DEFINE (Blist4, 0106) \
159 DEFINE (Blength, 0107) \
160 DEFINE (Baref, 0110) \
161 DEFINE (Baset, 0111) \
162 DEFINE (Bsymbol_value, 0112) \
163 DEFINE (Bsymbol_function, 0113) \
164 DEFINE (Bset, 0114) \
165 DEFINE (Bfset, 0115) \
166 DEFINE (Bget, 0116) \
167 DEFINE (Bsubstring, 0117) \
168 DEFINE (Bconcat2, 0120) \
169 DEFINE (Bconcat3, 0121) \
170 DEFINE (Bconcat4, 0122) \
171 DEFINE (Bsub1, 0123) \
172 DEFINE (Badd1, 0124) \
173 DEFINE (Beqlsign, 0125) \
174 DEFINE (Bgtr, 0126) \
175 DEFINE (Blss, 0127) \
176 DEFINE (Bleq, 0130) \
177 DEFINE (Bgeq, 0131) \
178 DEFINE (Bdiff, 0132) \
179 DEFINE (Bnegate, 0133) \
180 DEFINE (Bplus, 0134) \
181 DEFINE (Bmax, 0135) \
182 DEFINE (Bmin, 0136) \
183 DEFINE (Bmult, 0137) \
184 \
185 DEFINE (Bpoint, 0140) \
186 /* Was Bmark in v17. */ \
187 DEFINE (Bsave_current_buffer, 0141) /* Obsolete. */ \
188 DEFINE (Bgoto_char, 0142) \
189 DEFINE (Binsert, 0143) \
190 DEFINE (Bpoint_max, 0144) \
191 DEFINE (Bpoint_min, 0145) \
192 DEFINE (Bchar_after, 0146) \
193 DEFINE (Bfollowing_char, 0147) \
194 DEFINE (Bpreceding_char, 0150) \
195 DEFINE (Bcurrent_column, 0151) \
196 DEFINE (Bindent_to, 0152) \
197 DEFINE (Beolp, 0154) \
198 DEFINE (Beobp, 0155) \
199 DEFINE (Bbolp, 0156) \
200 DEFINE (Bbobp, 0157) \
201 DEFINE (Bcurrent_buffer, 0160) \
202 DEFINE (Bset_buffer, 0161) \
203 DEFINE (Bsave_current_buffer_1, 0162) /* Replacing Bsave_current_buffer. */ \
204 DEFINE (Binteractive_p, 0164) /* Obsolete since Emacs-24.1. */ \
205 \
206 DEFINE (Bforward_char, 0165) \
207 DEFINE (Bforward_word, 0166) \
208 DEFINE (Bskip_chars_forward, 0167) \
209 DEFINE (Bskip_chars_backward, 0170) \
210 DEFINE (Bforward_line, 0171) \
211 DEFINE (Bchar_syntax, 0172) \
212 DEFINE (Bbuffer_substring, 0173) \
213 DEFINE (Bdelete_region, 0174) \
214 DEFINE (Bnarrow_to_region, 0175) \
215 DEFINE (Bwiden, 0176) \
216 DEFINE (Bend_of_line, 0177) \
217 \
218 DEFINE (Bconstant2, 0201) \
219 DEFINE (Bgoto, 0202) \
220 DEFINE (Bgotoifnil, 0203) \
221 DEFINE (Bgotoifnonnil, 0204) \
222 DEFINE (Bgotoifnilelsepop, 0205) \
223 DEFINE (Bgotoifnonnilelsepop, 0206) \
224 DEFINE (Breturn, 0207) \
225 DEFINE (Bdiscard, 0210) \
226 DEFINE (Bdup, 0211) \
227 \
228 DEFINE (Bsave_excursion, 0212) \
229 DEFINE (Bsave_window_excursion, 0213) /* Obsolete since Emacs-24.1. */ \
230 DEFINE (Bsave_restriction, 0214) \
231 DEFINE (Bcatch, 0215) \
232 \
233 DEFINE (Bunwind_protect, 0216) \
234 DEFINE (Bcondition_case, 0217) \
235 DEFINE (Btemp_output_buffer_setup, 0220) /* Obsolete since Emacs-24.1. */ \
236 DEFINE (Btemp_output_buffer_show, 0221) /* Obsolete since Emacs-24.1. */ \
237 \
238 DEFINE (Bunbind_all, 0222) /* Obsolete. Never used. */ \
239 \
240 DEFINE (Bset_marker, 0223) \
241 DEFINE (Bmatch_beginning, 0224) \
242 DEFINE (Bmatch_end, 0225) \
243 DEFINE (Bupcase, 0226) \
244 DEFINE (Bdowncase, 0227) \
245 \
246 DEFINE (Bstringeqlsign, 0230) \
247 DEFINE (Bstringlss, 0231) \
248 DEFINE (Bequal, 0232) \
249 DEFINE (Bnthcdr, 0233) \
250 DEFINE (Belt, 0234) \
251 DEFINE (Bmember, 0235) \
252 DEFINE (Bassq, 0236) \
253 DEFINE (Bnreverse, 0237) \
254 DEFINE (Bsetcar, 0240) \
255 DEFINE (Bsetcdr, 0241) \
256 DEFINE (Bcar_safe, 0242) \
257 DEFINE (Bcdr_safe, 0243) \
258 DEFINE (Bnconc, 0244) \
259 DEFINE (Bquo, 0245) \
260 DEFINE (Brem, 0246) \
261 DEFINE (Bnumberp, 0247) \
262 DEFINE (Bintegerp, 0250) \
263 \
264 DEFINE (BRgoto, 0252) \
265 DEFINE (BRgotoifnil, 0253) \
266 DEFINE (BRgotoifnonnil, 0254) \
267 DEFINE (BRgotoifnilelsepop, 0255) \
268 DEFINE (BRgotoifnonnilelsepop, 0256) \
269 \
270 DEFINE (BlistN, 0257) \
271 DEFINE (BconcatN, 0260) \
272 DEFINE (BinsertN, 0261) \
273 \
274 /* Bstack_ref is code 0. */ \
275 DEFINE (Bstack_set, 0262) \
276 DEFINE (Bstack_set2, 0263) \
277 DEFINE (BdiscardN, 0266) \
278 \
279 DEFINE (Bconstant, 0300)
280
281 enum byte_code_op
282 {
283 #define DEFINE(name, value) name = value,
284 BYTE_CODES
285 #undef DEFINE
286
287 #ifdef BYTE_CODE_SAFE
288 Bscan_buffer = 0153, /* No longer generated as of v18. */
289 Bset_mark = 0163 /* this loser is no longer generated as of v18 */
290 #endif
291 };
292
293 /* Whether to maintain a `top' and `bottom' field in the stack frame. */
294 #define BYTE_MAINTAIN_TOP (BYTE_CODE_SAFE || BYTE_MARK_STACK)
295 \f
296 /* Structure describing a value stack used during byte-code execution
297 in Fbyte_code. */
298
299 struct byte_stack
300 {
301 /* Program counter. This points into the byte_string below
302 and is relocated when that string is relocated. */
303 const unsigned char *pc;
304
305 /* Top and bottom of stack. The bottom points to an area of memory
306 allocated with alloca in Fbyte_code. */
307 #if BYTE_MAINTAIN_TOP
308 Lisp_Object *top, *bottom;
309 #endif
310
311 /* The string containing the byte-code, and its current address.
312 Storing this here protects it from GC because mark_byte_stack
313 marks it. */
314 Lisp_Object byte_string;
315 const unsigned char *byte_string_start;
316
317 /* The vector of constants used during byte-code execution. Storing
318 this here protects it from GC because mark_byte_stack marks it. */
319 Lisp_Object constants;
320
321 /* Next entry in byte_stack_list. */
322 struct byte_stack *next;
323 };
324
325 /* A list of currently active byte-code execution value stacks.
326 Fbyte_code adds an entry to the head of this list before it starts
327 processing byte-code, and it removed the entry again when it is
328 done. Signaling an error truncates the list analogous to
329 gcprolist. */
330
331 struct byte_stack *byte_stack_list;
332
333 \f
334 /* Mark objects on byte_stack_list. Called during GC. */
335
336 #if BYTE_MARK_STACK
337 void
338 mark_byte_stack (void)
339 {
340 struct byte_stack *stack;
341 Lisp_Object *obj;
342
343 for (stack = byte_stack_list; stack; stack = stack->next)
344 {
345 /* If STACK->top is null here, this means there's an opcode in
346 Fbyte_code that wasn't expected to GC, but did. To find out
347 which opcode this is, record the value of `stack', and walk
348 up the stack in a debugger, stopping in frames of Fbyte_code.
349 The culprit is found in the frame of Fbyte_code where the
350 address of its local variable `stack' is equal to the
351 recorded value of `stack' here. */
352 eassert (stack->top);
353
354 for (obj = stack->bottom; obj <= stack->top; ++obj)
355 mark_object (*obj);
356
357 mark_object (stack->byte_string);
358 mark_object (stack->constants);
359 }
360 }
361 #endif
362
363 /* Unmark objects in the stacks on byte_stack_list. Relocate program
364 counters. Called when GC has completed. */
365
366 void
367 unmark_byte_stack (void)
368 {
369 struct byte_stack *stack;
370
371 for (stack = byte_stack_list; stack; stack = stack->next)
372 {
373 if (stack->byte_string_start != SDATA (stack->byte_string))
374 {
375 ptrdiff_t offset = stack->pc - stack->byte_string_start;
376 stack->byte_string_start = SDATA (stack->byte_string);
377 stack->pc = stack->byte_string_start + offset;
378 }
379 }
380 }
381
382 \f
383 /* Fetch the next byte from the bytecode stream */
384
385 #define FETCH *stack.pc++
386
387 /* Fetch two bytes from the bytecode stream and make a 16-bit number
388 out of them */
389
390 #define FETCH2 (op = FETCH, op + (FETCH << 8))
391
392 /* Push x onto the execution stack. This used to be #define PUSH(x)
393 (*++stackp = (x)) This oddity is necessary because Alliant can't be
394 bothered to compile the preincrement operator properly, as of 4/91.
395 -JimB */
396
397 #define PUSH(x) (top++, *top = (x))
398
399 /* Pop a value off the execution stack. */
400
401 #define POP (*top--)
402
403 /* Discard n values from the execution stack. */
404
405 #define DISCARD(n) (top -= (n))
406
407 /* Get the value which is at the top of the execution stack, but don't
408 pop it. */
409
410 #define TOP (*top)
411
412 /* Actions that must be performed before and after calling a function
413 that might GC. */
414
415 #if !BYTE_MAINTAIN_TOP
416 #define BEFORE_POTENTIAL_GC() ((void)0)
417 #define AFTER_POTENTIAL_GC() ((void)0)
418 #else
419 #define BEFORE_POTENTIAL_GC() stack.top = top
420 #define AFTER_POTENTIAL_GC() stack.top = NULL
421 #endif
422
423 /* Garbage collect if we have consed enough since the last time.
424 We do this at every branch, to avoid loops that never GC. */
425
426 #define MAYBE_GC() \
427 do { \
428 if (consing_since_gc > gc_cons_threshold \
429 && consing_since_gc > gc_relative_threshold) \
430 { \
431 BEFORE_POTENTIAL_GC (); \
432 Fgarbage_collect (); \
433 AFTER_POTENTIAL_GC (); \
434 } \
435 } while (0)
436
437 /* Check for jumping out of range. */
438
439 #ifdef BYTE_CODE_SAFE
440
441 #define CHECK_RANGE(ARG) \
442 if (ARG >= bytestr_length) abort ()
443
444 #else /* not BYTE_CODE_SAFE */
445
446 #define CHECK_RANGE(ARG)
447
448 #endif /* not BYTE_CODE_SAFE */
449
450 /* A version of the QUIT macro which makes sure that the stack top is
451 set before signaling `quit'. */
452
453 #define BYTE_CODE_QUIT \
454 do { \
455 if (!NILP (Vquit_flag) && NILP (Vinhibit_quit)) \
456 { \
457 Lisp_Object flag = Vquit_flag; \
458 Vquit_flag = Qnil; \
459 BEFORE_POTENTIAL_GC (); \
460 if (EQ (Vthrow_on_input, flag)) \
461 Fthrow (Vthrow_on_input, Qt); \
462 Fsignal (Qquit, Qnil); \
463 AFTER_POTENTIAL_GC (); \
464 } \
465 ELSE_PENDING_SIGNALS \
466 } while (0)
467
468
469 DEFUN ("byte-code", Fbyte_code, Sbyte_code, 3, 3, 0,
470 doc: /* Function used internally in byte-compiled code.
471 The first argument, BYTESTR, is a string of byte code;
472 the second, VECTOR, a vector of constants;
473 the third, MAXDEPTH, the maximum stack depth used in this function.
474 If the third argument is incorrect, Emacs may crash. */)
475 (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth)
476 {
477 return exec_byte_code (bytestr, vector, maxdepth, Qnil, 0, NULL);
478 }
479
480 /* Execute the byte-code in BYTESTR. VECTOR is the constant vector, and
481 MAXDEPTH is the maximum stack depth used (if MAXDEPTH is incorrect,
482 emacs may crash!). If ARGS_TEMPLATE is non-nil, it should be a lisp
483 argument list (including &rest, &optional, etc.), and ARGS, of size
484 NARGS, should be a vector of the actual arguments. The arguments in
485 ARGS are pushed on the stack according to ARGS_TEMPLATE before
486 executing BYTESTR. */
487
488 Lisp_Object
489 exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
490 Lisp_Object args_template, ptrdiff_t nargs, Lisp_Object *args)
491 {
492 ptrdiff_t count = SPECPDL_INDEX ();
493 #ifdef BYTE_CODE_METER
494 int this_op = 0;
495 int prev_op;
496 #endif
497 int op;
498 /* Lisp_Object v1, v2; */
499 Lisp_Object *vectorp;
500 #ifdef BYTE_CODE_SAFE
501 ptrdiff_t const_length;
502 Lisp_Object *stacke;
503 ptrdiff_t bytestr_length;
504 #endif
505 struct byte_stack stack;
506 Lisp_Object *top;
507 Lisp_Object result;
508
509 #if 0 /* CHECK_FRAME_FONT */
510 {
511 struct frame *f = SELECTED_FRAME ();
512 if (FRAME_X_P (f)
513 && FRAME_FONT (f)->direction != 0
514 && FRAME_FONT (f)->direction != 1)
515 abort ();
516 }
517 #endif
518
519 CHECK_STRING (bytestr);
520 CHECK_VECTOR (vector);
521 CHECK_NATNUM (maxdepth);
522
523 #ifdef BYTE_CODE_SAFE
524 const_length = ASIZE (vector);
525 #endif
526
527 if (STRING_MULTIBYTE (bytestr))
528 /* BYTESTR must have been produced by Emacs 20.2 or the earlier
529 because they produced a raw 8-bit string for byte-code and now
530 such a byte-code string is loaded as multibyte while raw 8-bit
531 characters converted to multibyte form. Thus, now we must
532 convert them back to the originally intended unibyte form. */
533 bytestr = Fstring_as_unibyte (bytestr);
534
535 #ifdef BYTE_CODE_SAFE
536 bytestr_length = SBYTES (bytestr);
537 #endif
538 vectorp = XVECTOR (vector)->contents;
539
540 stack.byte_string = bytestr;
541 stack.pc = stack.byte_string_start = SDATA (bytestr);
542 stack.constants = vector;
543 if (MAX_ALLOCA / sizeof (Lisp_Object) <= XFASTINT (maxdepth))
544 memory_full (SIZE_MAX);
545 top = alloca ((XFASTINT (maxdepth) + 1) * sizeof *top);
546 #if BYTE_MAINTAIN_TOP
547 stack.bottom = top + 1;
548 stack.top = NULL;
549 #endif
550 stack.next = byte_stack_list;
551 byte_stack_list = &stack;
552
553 #ifdef BYTE_CODE_SAFE
554 stacke = stack.bottom - 1 + XFASTINT (maxdepth);
555 #endif
556
557 if (INTEGERP (args_template))
558 {
559 ptrdiff_t at = XINT (args_template);
560 int rest = at & 128;
561 int mandatory = at & 127;
562 ptrdiff_t nonrest = at >> 8;
563 eassert (mandatory <= nonrest);
564 if (nargs <= nonrest)
565 {
566 ptrdiff_t i;
567 for (i = 0 ; i < nargs; i++, args++)
568 PUSH (*args);
569 if (nargs < mandatory)
570 /* Too few arguments. */
571 Fsignal (Qwrong_number_of_arguments,
572 Fcons (Fcons (make_number (mandatory),
573 rest ? Qand_rest : make_number (nonrest)),
574 Fcons (make_number (nargs), Qnil)));
575 else
576 {
577 for (; i < nonrest; i++)
578 PUSH (Qnil);
579 if (rest)
580 PUSH (Qnil);
581 }
582 }
583 else if (rest)
584 {
585 ptrdiff_t i;
586 for (i = 0 ; i < nonrest; i++, args++)
587 PUSH (*args);
588 PUSH (Flist (nargs - nonrest, args));
589 }
590 else
591 /* Too many arguments. */
592 Fsignal (Qwrong_number_of_arguments,
593 Fcons (Fcons (make_number (mandatory),
594 make_number (nonrest)),
595 Fcons (make_number (nargs), Qnil)));
596 }
597 else if (! NILP (args_template))
598 /* We should push some arguments on the stack. */
599 {
600 error ("Unknown args template!");
601 }
602
603 while (1)
604 {
605 #ifdef BYTE_CODE_SAFE
606 if (top > stacke)
607 abort ();
608 else if (top < stack.bottom - 1)
609 abort ();
610 #endif
611
612 #ifdef BYTE_CODE_METER
613 prev_op = this_op;
614 this_op = op = FETCH;
615 METER_CODE (prev_op, op);
616 #else
617 #ifndef BYTE_CODE_THREADED
618 op = FETCH;
619 #endif
620 #endif
621
622 /* The interpreter can be compiled one of two ways: as an
623 ordinary switch-based interpreter, or as a threaded
624 interpreter. The threaded interpreter relies on GCC's
625 computed goto extension, so it is not available everywhere.
626 Threading provides a performance boost. These macros are how
627 we allow the code to be compiled both ways. */
628 #ifdef BYTE_CODE_THREADED
629 /* The CASE macro introduces an instruction's body. It is
630 either a label or a case label. */
631 #define CASE(OP) insn_ ## OP
632 /* NEXT is invoked at the end of an instruction to go to the
633 next instruction. It is either a computed goto, or a
634 plain break. */
635 #define NEXT goto *(targets[op = FETCH])
636 /* FIRST is like NEXT, but is only used at the start of the
637 interpreter body. In the switch-based interpreter it is the
638 switch, so the threaded definition must include a semicolon. */
639 #define FIRST NEXT;
640 /* Most cases are labeled with the CASE macro, above.
641 CASE_DEFAULT is one exception; it is used if the interpreter
642 being built requires a default case. The threaded
643 interpreter does not, because the dispatch table is
644 completely filled. */
645 #define CASE_DEFAULT
646 /* This introduces an instruction that is known to call abort. */
647 #define CASE_ABORT CASE (Bstack_ref): CASE (default)
648 #else
649 /* See above for the meaning of the various defines. */
650 #define CASE(OP) case OP
651 #define NEXT break
652 #define FIRST switch (op)
653 #define CASE_DEFAULT case 255: default:
654 #define CASE_ABORT case 0
655 #endif
656
657 #ifdef BYTE_CODE_THREADED
658
659 /* A convenience define that saves us a lot of typing and makes
660 the table clearer. */
661 #define LABEL(OP) [OP] = &&insn_ ## OP
662
663 #if (__GNUC__ == 4 && 6 <= __GNUC_MINOR__) || 4 < __GNUC__
664 # pragma GCC diagnostic push
665 # pragma GCC diagnostic ignored "-Woverride-init"
666 #endif
667
668 /* This is the dispatch table for the threaded interpreter. */
669 static const void *const targets[256] =
670 {
671 [0 ... (Bconstant - 1)] = &&insn_default,
672 [Bconstant ... 255] = &&insn_Bconstant,
673
674 #define DEFINE(name, value) LABEL (name) ,
675 BYTE_CODES
676 #undef DEFINE
677 };
678
679 #if (__GNUC__ == 4 && 6 <= __GNUC_MINOR__) || 4 < __GNUC__
680 # pragma GCC diagnostic pop
681 #endif
682
683 #endif
684
685
686 FIRST
687 {
688 CASE (Bvarref7):
689 op = FETCH2;
690 goto varref;
691
692 CASE (Bvarref):
693 CASE (Bvarref1):
694 CASE (Bvarref2):
695 CASE (Bvarref3):
696 CASE (Bvarref4):
697 CASE (Bvarref5):
698 op = op - Bvarref;
699 goto varref;
700
701 /* This seems to be the most frequently executed byte-code
702 among the Bvarref's, so avoid a goto here. */
703 CASE (Bvarref6):
704 op = FETCH;
705 varref:
706 {
707 Lisp_Object v1, v2;
708
709 v1 = vectorp[op];
710 if (SYMBOLP (v1))
711 {
712 if (XSYMBOL (v1)->redirect != SYMBOL_PLAINVAL
713 || (v2 = SYMBOL_VAL (XSYMBOL (v1)),
714 EQ (v2, Qunbound)))
715 {
716 BEFORE_POTENTIAL_GC ();
717 v2 = Fsymbol_value (v1);
718 AFTER_POTENTIAL_GC ();
719 }
720 }
721 else
722 {
723 BEFORE_POTENTIAL_GC ();
724 v2 = Fsymbol_value (v1);
725 AFTER_POTENTIAL_GC ();
726 }
727 PUSH (v2);
728 NEXT;
729 }
730
731 CASE (Bgotoifnil):
732 {
733 Lisp_Object v1;
734 MAYBE_GC ();
735 op = FETCH2;
736 v1 = POP;
737 if (NILP (v1))
738 {
739 BYTE_CODE_QUIT;
740 CHECK_RANGE (op);
741 stack.pc = stack.byte_string_start + op;
742 }
743 NEXT;
744 }
745
746 CASE (Bcar):
747 {
748 Lisp_Object v1;
749 v1 = TOP;
750 if (CONSP (v1))
751 TOP = XCAR (v1);
752 else if (NILP (v1))
753 TOP = Qnil;
754 else
755 {
756 BEFORE_POTENTIAL_GC ();
757 wrong_type_argument (Qlistp, v1);
758 AFTER_POTENTIAL_GC ();
759 }
760 NEXT;
761 }
762
763 CASE (Beq):
764 {
765 Lisp_Object v1;
766 v1 = POP;
767 TOP = EQ (v1, TOP) ? Qt : Qnil;
768 NEXT;
769 }
770
771 CASE (Bmemq):
772 {
773 Lisp_Object v1;
774 BEFORE_POTENTIAL_GC ();
775 v1 = POP;
776 TOP = Fmemq (TOP, v1);
777 AFTER_POTENTIAL_GC ();
778 NEXT;
779 }
780
781 CASE (Bcdr):
782 {
783 Lisp_Object v1;
784 v1 = TOP;
785 if (CONSP (v1))
786 TOP = XCDR (v1);
787 else if (NILP (v1))
788 TOP = Qnil;
789 else
790 {
791 BEFORE_POTENTIAL_GC ();
792 wrong_type_argument (Qlistp, v1);
793 AFTER_POTENTIAL_GC ();
794 }
795 NEXT;
796 }
797
798 CASE (Bvarset):
799 CASE (Bvarset1):
800 CASE (Bvarset2):
801 CASE (Bvarset3):
802 CASE (Bvarset4):
803 CASE (Bvarset5):
804 op -= Bvarset;
805 goto varset;
806
807 CASE (Bvarset7):
808 op = FETCH2;
809 goto varset;
810
811 CASE (Bvarset6):
812 op = FETCH;
813 varset:
814 {
815 Lisp_Object sym, val;
816
817 sym = vectorp[op];
818 val = TOP;
819
820 /* Inline the most common case. */
821 if (SYMBOLP (sym)
822 && !EQ (val, Qunbound)
823 && !XSYMBOL (sym)->redirect
824 && !SYMBOL_CONSTANT_P (sym))
825 XSYMBOL (sym)->val.value = val;
826 else
827 {
828 BEFORE_POTENTIAL_GC ();
829 set_internal (sym, val, Qnil, 0);
830 AFTER_POTENTIAL_GC ();
831 }
832 }
833 (void) POP;
834 NEXT;
835
836 CASE (Bdup):
837 {
838 Lisp_Object v1;
839 v1 = TOP;
840 PUSH (v1);
841 NEXT;
842 }
843
844 /* ------------------ */
845
846 CASE (Bvarbind6):
847 op = FETCH;
848 goto varbind;
849
850 CASE (Bvarbind7):
851 op = FETCH2;
852 goto varbind;
853
854 CASE (Bvarbind):
855 CASE (Bvarbind1):
856 CASE (Bvarbind2):
857 CASE (Bvarbind3):
858 CASE (Bvarbind4):
859 CASE (Bvarbind5):
860 op -= Bvarbind;
861 varbind:
862 /* Specbind can signal and thus GC. */
863 BEFORE_POTENTIAL_GC ();
864 specbind (vectorp[op], POP);
865 AFTER_POTENTIAL_GC ();
866 NEXT;
867
868 CASE (Bcall6):
869 op = FETCH;
870 goto docall;
871
872 CASE (Bcall7):
873 op = FETCH2;
874 goto docall;
875
876 CASE (Bcall):
877 CASE (Bcall1):
878 CASE (Bcall2):
879 CASE (Bcall3):
880 CASE (Bcall4):
881 CASE (Bcall5):
882 op -= Bcall;
883 docall:
884 {
885 BEFORE_POTENTIAL_GC ();
886 DISCARD (op);
887 #ifdef BYTE_CODE_METER
888 if (byte_metering_on && SYMBOLP (TOP))
889 {
890 Lisp_Object v1, v2;
891
892 v1 = TOP;
893 v2 = Fget (v1, Qbyte_code_meter);
894 if (INTEGERP (v2)
895 && XINT (v2) < MOST_POSITIVE_FIXNUM)
896 {
897 XSETINT (v2, XINT (v2) + 1);
898 Fput (v1, Qbyte_code_meter, v2);
899 }
900 }
901 #endif
902 TOP = Ffuncall (op + 1, &TOP);
903 AFTER_POTENTIAL_GC ();
904 NEXT;
905 }
906
907 CASE (Bunbind6):
908 op = FETCH;
909 goto dounbind;
910
911 CASE (Bunbind7):
912 op = FETCH2;
913 goto dounbind;
914
915 CASE (Bunbind):
916 CASE (Bunbind1):
917 CASE (Bunbind2):
918 CASE (Bunbind3):
919 CASE (Bunbind4):
920 CASE (Bunbind5):
921 op -= Bunbind;
922 dounbind:
923 BEFORE_POTENTIAL_GC ();
924 unbind_to (SPECPDL_INDEX () - op, Qnil);
925 AFTER_POTENTIAL_GC ();
926 NEXT;
927
928 CASE (Bunbind_all): /* Obsolete. Never used. */
929 /* To unbind back to the beginning of this frame. Not used yet,
930 but will be needed for tail-recursion elimination. */
931 BEFORE_POTENTIAL_GC ();
932 unbind_to (count, Qnil);
933 AFTER_POTENTIAL_GC ();
934 NEXT;
935
936 CASE (Bgoto):
937 MAYBE_GC ();
938 BYTE_CODE_QUIT;
939 op = FETCH2; /* pc = FETCH2 loses since FETCH2 contains pc++ */
940 CHECK_RANGE (op);
941 stack.pc = stack.byte_string_start + op;
942 NEXT;
943
944 CASE (Bgotoifnonnil):
945 {
946 Lisp_Object v1;
947 MAYBE_GC ();
948 op = FETCH2;
949 v1 = POP;
950 if (!NILP (v1))
951 {
952 BYTE_CODE_QUIT;
953 CHECK_RANGE (op);
954 stack.pc = stack.byte_string_start + op;
955 }
956 NEXT;
957 }
958
959 CASE (Bgotoifnilelsepop):
960 MAYBE_GC ();
961 op = FETCH2;
962 if (NILP (TOP))
963 {
964 BYTE_CODE_QUIT;
965 CHECK_RANGE (op);
966 stack.pc = stack.byte_string_start + op;
967 }
968 else DISCARD (1);
969 NEXT;
970
971 CASE (Bgotoifnonnilelsepop):
972 MAYBE_GC ();
973 op = FETCH2;
974 if (!NILP (TOP))
975 {
976 BYTE_CODE_QUIT;
977 CHECK_RANGE (op);
978 stack.pc = stack.byte_string_start + op;
979 }
980 else DISCARD (1);
981 NEXT;
982
983 CASE (BRgoto):
984 MAYBE_GC ();
985 BYTE_CODE_QUIT;
986 stack.pc += (int) *stack.pc - 127;
987 NEXT;
988
989 CASE (BRgotoifnil):
990 {
991 Lisp_Object v1;
992 MAYBE_GC ();
993 v1 = POP;
994 if (NILP (v1))
995 {
996 BYTE_CODE_QUIT;
997 stack.pc += (int) *stack.pc - 128;
998 }
999 stack.pc++;
1000 NEXT;
1001 }
1002
1003 CASE (BRgotoifnonnil):
1004 {
1005 Lisp_Object v1;
1006 MAYBE_GC ();
1007 v1 = POP;
1008 if (!NILP (v1))
1009 {
1010 BYTE_CODE_QUIT;
1011 stack.pc += (int) *stack.pc - 128;
1012 }
1013 stack.pc++;
1014 NEXT;
1015 }
1016
1017 CASE (BRgotoifnilelsepop):
1018 MAYBE_GC ();
1019 op = *stack.pc++;
1020 if (NILP (TOP))
1021 {
1022 BYTE_CODE_QUIT;
1023 stack.pc += op - 128;
1024 }
1025 else DISCARD (1);
1026 NEXT;
1027
1028 CASE (BRgotoifnonnilelsepop):
1029 MAYBE_GC ();
1030 op = *stack.pc++;
1031 if (!NILP (TOP))
1032 {
1033 BYTE_CODE_QUIT;
1034 stack.pc += op - 128;
1035 }
1036 else DISCARD (1);
1037 NEXT;
1038
1039 CASE (Breturn):
1040 result = POP;
1041 goto exit;
1042
1043 CASE (Bdiscard):
1044 DISCARD (1);
1045 NEXT;
1046
1047 CASE (Bconstant2):
1048 PUSH (vectorp[FETCH2]);
1049 NEXT;
1050
1051 CASE (Bsave_excursion):
1052 record_unwind_protect (save_excursion_restore,
1053 save_excursion_save ());
1054 NEXT;
1055
1056 CASE (Bsave_current_buffer): /* Obsolete since ??. */
1057 CASE (Bsave_current_buffer_1):
1058 record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
1059 NEXT;
1060
1061 CASE (Bsave_window_excursion): /* Obsolete since 24.1. */
1062 {
1063 register ptrdiff_t count1 = SPECPDL_INDEX ();
1064 record_unwind_protect (Fset_window_configuration,
1065 Fcurrent_window_configuration (Qnil));
1066 BEFORE_POTENTIAL_GC ();
1067 TOP = Fprogn (TOP);
1068 unbind_to (count1, TOP);
1069 AFTER_POTENTIAL_GC ();
1070 NEXT;
1071 }
1072
1073 CASE (Bsave_restriction):
1074 record_unwind_protect (save_restriction_restore,
1075 save_restriction_save ());
1076 NEXT;
1077
1078 CASE (Bcatch): /* FIXME: ill-suited for lexbind. */
1079 {
1080 Lisp_Object v1;
1081 BEFORE_POTENTIAL_GC ();
1082 v1 = POP;
1083 TOP = internal_catch (TOP, eval_sub, v1);
1084 AFTER_POTENTIAL_GC ();
1085 NEXT;
1086 }
1087
1088 CASE (Bunwind_protect): /* FIXME: avoid closure for lexbind. */
1089 record_unwind_protect (Fprogn, POP);
1090 NEXT;
1091
1092 CASE (Bcondition_case): /* FIXME: ill-suited for lexbind. */
1093 {
1094 Lisp_Object handlers, body;
1095 handlers = POP;
1096 body = POP;
1097 BEFORE_POTENTIAL_GC ();
1098 TOP = internal_lisp_condition_case (TOP, body, handlers);
1099 AFTER_POTENTIAL_GC ();
1100 NEXT;
1101 }
1102
1103 CASE (Btemp_output_buffer_setup): /* Obsolete since 24.1. */
1104 BEFORE_POTENTIAL_GC ();
1105 CHECK_STRING (TOP);
1106 temp_output_buffer_setup (SSDATA (TOP));
1107 AFTER_POTENTIAL_GC ();
1108 TOP = Vstandard_output;
1109 NEXT;
1110
1111 CASE (Btemp_output_buffer_show): /* Obsolete since 24.1. */
1112 {
1113 Lisp_Object v1;
1114 BEFORE_POTENTIAL_GC ();
1115 v1 = POP;
1116 temp_output_buffer_show (TOP);
1117 TOP = v1;
1118 /* pop binding of standard-output */
1119 unbind_to (SPECPDL_INDEX () - 1, Qnil);
1120 AFTER_POTENTIAL_GC ();
1121 NEXT;
1122 }
1123
1124 CASE (Bnth):
1125 {
1126 Lisp_Object v1, v2;
1127 EMACS_INT n;
1128 BEFORE_POTENTIAL_GC ();
1129 v1 = POP;
1130 v2 = TOP;
1131 CHECK_NUMBER (v2);
1132 n = XINT (v2);
1133 immediate_quit = 1;
1134 while (--n >= 0 && CONSP (v1))
1135 v1 = XCDR (v1);
1136 immediate_quit = 0;
1137 TOP = CAR (v1);
1138 AFTER_POTENTIAL_GC ();
1139 NEXT;
1140 }
1141
1142 CASE (Bsymbolp):
1143 TOP = SYMBOLP (TOP) ? Qt : Qnil;
1144 NEXT;
1145
1146 CASE (Bconsp):
1147 TOP = CONSP (TOP) ? Qt : Qnil;
1148 NEXT;
1149
1150 CASE (Bstringp):
1151 TOP = STRINGP (TOP) ? Qt : Qnil;
1152 NEXT;
1153
1154 CASE (Blistp):
1155 TOP = CONSP (TOP) || NILP (TOP) ? Qt : Qnil;
1156 NEXT;
1157
1158 CASE (Bnot):
1159 TOP = NILP (TOP) ? Qt : Qnil;
1160 NEXT;
1161
1162 CASE (Bcons):
1163 {
1164 Lisp_Object v1;
1165 v1 = POP;
1166 TOP = Fcons (TOP, v1);
1167 NEXT;
1168 }
1169
1170 CASE (Blist1):
1171 TOP = Fcons (TOP, Qnil);
1172 NEXT;
1173
1174 CASE (Blist2):
1175 {
1176 Lisp_Object v1;
1177 v1 = POP;
1178 TOP = Fcons (TOP, Fcons (v1, Qnil));
1179 NEXT;
1180 }
1181
1182 CASE (Blist3):
1183 DISCARD (2);
1184 TOP = Flist (3, &TOP);
1185 NEXT;
1186
1187 CASE (Blist4):
1188 DISCARD (3);
1189 TOP = Flist (4, &TOP);
1190 NEXT;
1191
1192 CASE (BlistN):
1193 op = FETCH;
1194 DISCARD (op - 1);
1195 TOP = Flist (op, &TOP);
1196 NEXT;
1197
1198 CASE (Blength):
1199 BEFORE_POTENTIAL_GC ();
1200 TOP = Flength (TOP);
1201 AFTER_POTENTIAL_GC ();
1202 NEXT;
1203
1204 CASE (Baref):
1205 {
1206 Lisp_Object v1;
1207 BEFORE_POTENTIAL_GC ();
1208 v1 = POP;
1209 TOP = Faref (TOP, v1);
1210 AFTER_POTENTIAL_GC ();
1211 NEXT;
1212 }
1213
1214 CASE (Baset):
1215 {
1216 Lisp_Object v1, v2;
1217 BEFORE_POTENTIAL_GC ();
1218 v2 = POP; v1 = POP;
1219 TOP = Faset (TOP, v1, v2);
1220 AFTER_POTENTIAL_GC ();
1221 NEXT;
1222 }
1223
1224 CASE (Bsymbol_value):
1225 BEFORE_POTENTIAL_GC ();
1226 TOP = Fsymbol_value (TOP);
1227 AFTER_POTENTIAL_GC ();
1228 NEXT;
1229
1230 CASE (Bsymbol_function):
1231 BEFORE_POTENTIAL_GC ();
1232 TOP = Fsymbol_function (TOP);
1233 AFTER_POTENTIAL_GC ();
1234 NEXT;
1235
1236 CASE (Bset):
1237 {
1238 Lisp_Object v1;
1239 BEFORE_POTENTIAL_GC ();
1240 v1 = POP;
1241 TOP = Fset (TOP, v1);
1242 AFTER_POTENTIAL_GC ();
1243 NEXT;
1244 }
1245
1246 CASE (Bfset):
1247 {
1248 Lisp_Object v1;
1249 BEFORE_POTENTIAL_GC ();
1250 v1 = POP;
1251 TOP = Ffset (TOP, v1);
1252 AFTER_POTENTIAL_GC ();
1253 NEXT;
1254 }
1255
1256 CASE (Bget):
1257 {
1258 Lisp_Object v1;
1259 BEFORE_POTENTIAL_GC ();
1260 v1 = POP;
1261 TOP = Fget (TOP, v1);
1262 AFTER_POTENTIAL_GC ();
1263 NEXT;
1264 }
1265
1266 CASE (Bsubstring):
1267 {
1268 Lisp_Object v1, v2;
1269 BEFORE_POTENTIAL_GC ();
1270 v2 = POP; v1 = POP;
1271 TOP = Fsubstring (TOP, v1, v2);
1272 AFTER_POTENTIAL_GC ();
1273 NEXT;
1274 }
1275
1276 CASE (Bconcat2):
1277 BEFORE_POTENTIAL_GC ();
1278 DISCARD (1);
1279 TOP = Fconcat (2, &TOP);
1280 AFTER_POTENTIAL_GC ();
1281 NEXT;
1282
1283 CASE (Bconcat3):
1284 BEFORE_POTENTIAL_GC ();
1285 DISCARD (2);
1286 TOP = Fconcat (3, &TOP);
1287 AFTER_POTENTIAL_GC ();
1288 NEXT;
1289
1290 CASE (Bconcat4):
1291 BEFORE_POTENTIAL_GC ();
1292 DISCARD (3);
1293 TOP = Fconcat (4, &TOP);
1294 AFTER_POTENTIAL_GC ();
1295 NEXT;
1296
1297 CASE (BconcatN):
1298 op = FETCH;
1299 BEFORE_POTENTIAL_GC ();
1300 DISCARD (op - 1);
1301 TOP = Fconcat (op, &TOP);
1302 AFTER_POTENTIAL_GC ();
1303 NEXT;
1304
1305 CASE (Bsub1):
1306 {
1307 Lisp_Object v1;
1308 v1 = TOP;
1309 if (INTEGERP (v1))
1310 {
1311 XSETINT (v1, XINT (v1) - 1);
1312 TOP = v1;
1313 }
1314 else
1315 {
1316 BEFORE_POTENTIAL_GC ();
1317 TOP = Fsub1 (v1);
1318 AFTER_POTENTIAL_GC ();
1319 }
1320 NEXT;
1321 }
1322
1323 CASE (Badd1):
1324 {
1325 Lisp_Object v1;
1326 v1 = TOP;
1327 if (INTEGERP (v1))
1328 {
1329 XSETINT (v1, XINT (v1) + 1);
1330 TOP = v1;
1331 }
1332 else
1333 {
1334 BEFORE_POTENTIAL_GC ();
1335 TOP = Fadd1 (v1);
1336 AFTER_POTENTIAL_GC ();
1337 }
1338 NEXT;
1339 }
1340
1341 CASE (Beqlsign):
1342 {
1343 Lisp_Object v1, v2;
1344 BEFORE_POTENTIAL_GC ();
1345 v2 = POP; v1 = TOP;
1346 CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v1);
1347 CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v2);
1348 AFTER_POTENTIAL_GC ();
1349 if (FLOATP (v1) || FLOATP (v2))
1350 {
1351 double f1, f2;
1352
1353 f1 = (FLOATP (v1) ? XFLOAT_DATA (v1) : XINT (v1));
1354 f2 = (FLOATP (v2) ? XFLOAT_DATA (v2) : XINT (v2));
1355 TOP = (f1 == f2 ? Qt : Qnil);
1356 }
1357 else
1358 TOP = (XINT (v1) == XINT (v2) ? Qt : Qnil);
1359 NEXT;
1360 }
1361
1362 CASE (Bgtr):
1363 {
1364 Lisp_Object v1;
1365 BEFORE_POTENTIAL_GC ();
1366 v1 = POP;
1367 TOP = Fgtr (TOP, v1);
1368 AFTER_POTENTIAL_GC ();
1369 NEXT;
1370 }
1371
1372 CASE (Blss):
1373 {
1374 Lisp_Object v1;
1375 BEFORE_POTENTIAL_GC ();
1376 v1 = POP;
1377 TOP = Flss (TOP, v1);
1378 AFTER_POTENTIAL_GC ();
1379 NEXT;
1380 }
1381
1382 CASE (Bleq):
1383 {
1384 Lisp_Object v1;
1385 BEFORE_POTENTIAL_GC ();
1386 v1 = POP;
1387 TOP = Fleq (TOP, v1);
1388 AFTER_POTENTIAL_GC ();
1389 NEXT;
1390 }
1391
1392 CASE (Bgeq):
1393 {
1394 Lisp_Object v1;
1395 BEFORE_POTENTIAL_GC ();
1396 v1 = POP;
1397 TOP = Fgeq (TOP, v1);
1398 AFTER_POTENTIAL_GC ();
1399 NEXT;
1400 }
1401
1402 CASE (Bdiff):
1403 BEFORE_POTENTIAL_GC ();
1404 DISCARD (1);
1405 TOP = Fminus (2, &TOP);
1406 AFTER_POTENTIAL_GC ();
1407 NEXT;
1408
1409 CASE (Bnegate):
1410 {
1411 Lisp_Object v1;
1412 v1 = TOP;
1413 if (INTEGERP (v1))
1414 {
1415 XSETINT (v1, - XINT (v1));
1416 TOP = v1;
1417 }
1418 else
1419 {
1420 BEFORE_POTENTIAL_GC ();
1421 TOP = Fminus (1, &TOP);
1422 AFTER_POTENTIAL_GC ();
1423 }
1424 NEXT;
1425 }
1426
1427 CASE (Bplus):
1428 BEFORE_POTENTIAL_GC ();
1429 DISCARD (1);
1430 TOP = Fplus (2, &TOP);
1431 AFTER_POTENTIAL_GC ();
1432 NEXT;
1433
1434 CASE (Bmax):
1435 BEFORE_POTENTIAL_GC ();
1436 DISCARD (1);
1437 TOP = Fmax (2, &TOP);
1438 AFTER_POTENTIAL_GC ();
1439 NEXT;
1440
1441 CASE (Bmin):
1442 BEFORE_POTENTIAL_GC ();
1443 DISCARD (1);
1444 TOP = Fmin (2, &TOP);
1445 AFTER_POTENTIAL_GC ();
1446 NEXT;
1447
1448 CASE (Bmult):
1449 BEFORE_POTENTIAL_GC ();
1450 DISCARD (1);
1451 TOP = Ftimes (2, &TOP);
1452 AFTER_POTENTIAL_GC ();
1453 NEXT;
1454
1455 CASE (Bquo):
1456 BEFORE_POTENTIAL_GC ();
1457 DISCARD (1);
1458 TOP = Fquo (2, &TOP);
1459 AFTER_POTENTIAL_GC ();
1460 NEXT;
1461
1462 CASE (Brem):
1463 {
1464 Lisp_Object v1;
1465 BEFORE_POTENTIAL_GC ();
1466 v1 = POP;
1467 TOP = Frem (TOP, v1);
1468 AFTER_POTENTIAL_GC ();
1469 NEXT;
1470 }
1471
1472 CASE (Bpoint):
1473 {
1474 Lisp_Object v1;
1475 XSETFASTINT (v1, PT);
1476 PUSH (v1);
1477 NEXT;
1478 }
1479
1480 CASE (Bgoto_char):
1481 BEFORE_POTENTIAL_GC ();
1482 TOP = Fgoto_char (TOP);
1483 AFTER_POTENTIAL_GC ();
1484 NEXT;
1485
1486 CASE (Binsert):
1487 BEFORE_POTENTIAL_GC ();
1488 TOP = Finsert (1, &TOP);
1489 AFTER_POTENTIAL_GC ();
1490 NEXT;
1491
1492 CASE (BinsertN):
1493 op = FETCH;
1494 BEFORE_POTENTIAL_GC ();
1495 DISCARD (op - 1);
1496 TOP = Finsert (op, &TOP);
1497 AFTER_POTENTIAL_GC ();
1498 NEXT;
1499
1500 CASE (Bpoint_max):
1501 {
1502 Lisp_Object v1;
1503 XSETFASTINT (v1, ZV);
1504 PUSH (v1);
1505 NEXT;
1506 }
1507
1508 CASE (Bpoint_min):
1509 {
1510 Lisp_Object v1;
1511 XSETFASTINT (v1, BEGV);
1512 PUSH (v1);
1513 NEXT;
1514 }
1515
1516 CASE (Bchar_after):
1517 BEFORE_POTENTIAL_GC ();
1518 TOP = Fchar_after (TOP);
1519 AFTER_POTENTIAL_GC ();
1520 NEXT;
1521
1522 CASE (Bfollowing_char):
1523 {
1524 Lisp_Object v1;
1525 BEFORE_POTENTIAL_GC ();
1526 v1 = Ffollowing_char ();
1527 AFTER_POTENTIAL_GC ();
1528 PUSH (v1);
1529 NEXT;
1530 }
1531
1532 CASE (Bpreceding_char):
1533 {
1534 Lisp_Object v1;
1535 BEFORE_POTENTIAL_GC ();
1536 v1 = Fprevious_char ();
1537 AFTER_POTENTIAL_GC ();
1538 PUSH (v1);
1539 NEXT;
1540 }
1541
1542 CASE (Bcurrent_column):
1543 {
1544 Lisp_Object v1;
1545 BEFORE_POTENTIAL_GC ();
1546 XSETFASTINT (v1, current_column ());
1547 AFTER_POTENTIAL_GC ();
1548 PUSH (v1);
1549 NEXT;
1550 }
1551
1552 CASE (Bindent_to):
1553 BEFORE_POTENTIAL_GC ();
1554 TOP = Findent_to (TOP, Qnil);
1555 AFTER_POTENTIAL_GC ();
1556 NEXT;
1557
1558 CASE (Beolp):
1559 PUSH (Feolp ());
1560 NEXT;
1561
1562 CASE (Beobp):
1563 PUSH (Feobp ());
1564 NEXT;
1565
1566 CASE (Bbolp):
1567 PUSH (Fbolp ());
1568 NEXT;
1569
1570 CASE (Bbobp):
1571 PUSH (Fbobp ());
1572 NEXT;
1573
1574 CASE (Bcurrent_buffer):
1575 PUSH (Fcurrent_buffer ());
1576 NEXT;
1577
1578 CASE (Bset_buffer):
1579 BEFORE_POTENTIAL_GC ();
1580 TOP = Fset_buffer (TOP);
1581 AFTER_POTENTIAL_GC ();
1582 NEXT;
1583
1584 CASE (Binteractive_p): /* Obsolete since 24.1. */
1585 PUSH (Finteractive_p ());
1586 NEXT;
1587
1588 CASE (Bforward_char):
1589 BEFORE_POTENTIAL_GC ();
1590 TOP = Fforward_char (TOP);
1591 AFTER_POTENTIAL_GC ();
1592 NEXT;
1593
1594 CASE (Bforward_word):
1595 BEFORE_POTENTIAL_GC ();
1596 TOP = Fforward_word (TOP);
1597 AFTER_POTENTIAL_GC ();
1598 NEXT;
1599
1600 CASE (Bskip_chars_forward):
1601 {
1602 Lisp_Object v1;
1603 BEFORE_POTENTIAL_GC ();
1604 v1 = POP;
1605 TOP = Fskip_chars_forward (TOP, v1);
1606 AFTER_POTENTIAL_GC ();
1607 NEXT;
1608 }
1609
1610 CASE (Bskip_chars_backward):
1611 {
1612 Lisp_Object v1;
1613 BEFORE_POTENTIAL_GC ();
1614 v1 = POP;
1615 TOP = Fskip_chars_backward (TOP, v1);
1616 AFTER_POTENTIAL_GC ();
1617 NEXT;
1618 }
1619
1620 CASE (Bforward_line):
1621 BEFORE_POTENTIAL_GC ();
1622 TOP = Fforward_line (TOP);
1623 AFTER_POTENTIAL_GC ();
1624 NEXT;
1625
1626 CASE (Bchar_syntax):
1627 {
1628 int c;
1629
1630 BEFORE_POTENTIAL_GC ();
1631 CHECK_CHARACTER (TOP);
1632 AFTER_POTENTIAL_GC ();
1633 c = XFASTINT (TOP);
1634 if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
1635 MAKE_CHAR_MULTIBYTE (c);
1636 XSETFASTINT (TOP, syntax_code_spec[(int) SYNTAX (c)]);
1637 }
1638 NEXT;
1639
1640 CASE (Bbuffer_substring):
1641 {
1642 Lisp_Object v1;
1643 BEFORE_POTENTIAL_GC ();
1644 v1 = POP;
1645 TOP = Fbuffer_substring (TOP, v1);
1646 AFTER_POTENTIAL_GC ();
1647 NEXT;
1648 }
1649
1650 CASE (Bdelete_region):
1651 {
1652 Lisp_Object v1;
1653 BEFORE_POTENTIAL_GC ();
1654 v1 = POP;
1655 TOP = Fdelete_region (TOP, v1);
1656 AFTER_POTENTIAL_GC ();
1657 NEXT;
1658 }
1659
1660 CASE (Bnarrow_to_region):
1661 {
1662 Lisp_Object v1;
1663 BEFORE_POTENTIAL_GC ();
1664 v1 = POP;
1665 TOP = Fnarrow_to_region (TOP, v1);
1666 AFTER_POTENTIAL_GC ();
1667 NEXT;
1668 }
1669
1670 CASE (Bwiden):
1671 BEFORE_POTENTIAL_GC ();
1672 PUSH (Fwiden ());
1673 AFTER_POTENTIAL_GC ();
1674 NEXT;
1675
1676 CASE (Bend_of_line):
1677 BEFORE_POTENTIAL_GC ();
1678 TOP = Fend_of_line (TOP);
1679 AFTER_POTENTIAL_GC ();
1680 NEXT;
1681
1682 CASE (Bset_marker):
1683 {
1684 Lisp_Object v1, v2;
1685 BEFORE_POTENTIAL_GC ();
1686 v1 = POP;
1687 v2 = POP;
1688 TOP = Fset_marker (TOP, v2, v1);
1689 AFTER_POTENTIAL_GC ();
1690 NEXT;
1691 }
1692
1693 CASE (Bmatch_beginning):
1694 BEFORE_POTENTIAL_GC ();
1695 TOP = Fmatch_beginning (TOP);
1696 AFTER_POTENTIAL_GC ();
1697 NEXT;
1698
1699 CASE (Bmatch_end):
1700 BEFORE_POTENTIAL_GC ();
1701 TOP = Fmatch_end (TOP);
1702 AFTER_POTENTIAL_GC ();
1703 NEXT;
1704
1705 CASE (Bupcase):
1706 BEFORE_POTENTIAL_GC ();
1707 TOP = Fupcase (TOP);
1708 AFTER_POTENTIAL_GC ();
1709 NEXT;
1710
1711 CASE (Bdowncase):
1712 BEFORE_POTENTIAL_GC ();
1713 TOP = Fdowncase (TOP);
1714 AFTER_POTENTIAL_GC ();
1715 NEXT;
1716
1717 CASE (Bstringeqlsign):
1718 {
1719 Lisp_Object v1;
1720 BEFORE_POTENTIAL_GC ();
1721 v1 = POP;
1722 TOP = Fstring_equal (TOP, v1);
1723 AFTER_POTENTIAL_GC ();
1724 NEXT;
1725 }
1726
1727 CASE (Bstringlss):
1728 {
1729 Lisp_Object v1;
1730 BEFORE_POTENTIAL_GC ();
1731 v1 = POP;
1732 TOP = Fstring_lessp (TOP, v1);
1733 AFTER_POTENTIAL_GC ();
1734 NEXT;
1735 }
1736
1737 CASE (Bequal):
1738 {
1739 Lisp_Object v1;
1740 v1 = POP;
1741 TOP = Fequal (TOP, v1);
1742 NEXT;
1743 }
1744
1745 CASE (Bnthcdr):
1746 {
1747 Lisp_Object v1;
1748 BEFORE_POTENTIAL_GC ();
1749 v1 = POP;
1750 TOP = Fnthcdr (TOP, v1);
1751 AFTER_POTENTIAL_GC ();
1752 NEXT;
1753 }
1754
1755 CASE (Belt):
1756 {
1757 Lisp_Object v1, v2;
1758 if (CONSP (TOP))
1759 {
1760 /* Exchange args and then do nth. */
1761 EMACS_INT n;
1762 BEFORE_POTENTIAL_GC ();
1763 v2 = POP;
1764 v1 = TOP;
1765 CHECK_NUMBER (v2);
1766 AFTER_POTENTIAL_GC ();
1767 n = XINT (v2);
1768 immediate_quit = 1;
1769 while (--n >= 0 && CONSP (v1))
1770 v1 = XCDR (v1);
1771 immediate_quit = 0;
1772 TOP = CAR (v1);
1773 }
1774 else
1775 {
1776 BEFORE_POTENTIAL_GC ();
1777 v1 = POP;
1778 TOP = Felt (TOP, v1);
1779 AFTER_POTENTIAL_GC ();
1780 }
1781 NEXT;
1782 }
1783
1784 CASE (Bmember):
1785 {
1786 Lisp_Object v1;
1787 BEFORE_POTENTIAL_GC ();
1788 v1 = POP;
1789 TOP = Fmember (TOP, v1);
1790 AFTER_POTENTIAL_GC ();
1791 NEXT;
1792 }
1793
1794 CASE (Bassq):
1795 {
1796 Lisp_Object v1;
1797 BEFORE_POTENTIAL_GC ();
1798 v1 = POP;
1799 TOP = Fassq (TOP, v1);
1800 AFTER_POTENTIAL_GC ();
1801 NEXT;
1802 }
1803
1804 CASE (Bnreverse):
1805 BEFORE_POTENTIAL_GC ();
1806 TOP = Fnreverse (TOP);
1807 AFTER_POTENTIAL_GC ();
1808 NEXT;
1809
1810 CASE (Bsetcar):
1811 {
1812 Lisp_Object v1;
1813 BEFORE_POTENTIAL_GC ();
1814 v1 = POP;
1815 TOP = Fsetcar (TOP, v1);
1816 AFTER_POTENTIAL_GC ();
1817 NEXT;
1818 }
1819
1820 CASE (Bsetcdr):
1821 {
1822 Lisp_Object v1;
1823 BEFORE_POTENTIAL_GC ();
1824 v1 = POP;
1825 TOP = Fsetcdr (TOP, v1);
1826 AFTER_POTENTIAL_GC ();
1827 NEXT;
1828 }
1829
1830 CASE (Bcar_safe):
1831 {
1832 Lisp_Object v1;
1833 v1 = TOP;
1834 TOP = CAR_SAFE (v1);
1835 NEXT;
1836 }
1837
1838 CASE (Bcdr_safe):
1839 {
1840 Lisp_Object v1;
1841 v1 = TOP;
1842 TOP = CDR_SAFE (v1);
1843 NEXT;
1844 }
1845
1846 CASE (Bnconc):
1847 BEFORE_POTENTIAL_GC ();
1848 DISCARD (1);
1849 TOP = Fnconc (2, &TOP);
1850 AFTER_POTENTIAL_GC ();
1851 NEXT;
1852
1853 CASE (Bnumberp):
1854 TOP = (NUMBERP (TOP) ? Qt : Qnil);
1855 NEXT;
1856
1857 CASE (Bintegerp):
1858 TOP = INTEGERP (TOP) ? Qt : Qnil;
1859 NEXT;
1860
1861 #ifdef BYTE_CODE_SAFE
1862 /* These are intentionally written using 'case' syntax,
1863 because they are incompatible with the threaded
1864 interpreter. */
1865
1866 case Bset_mark:
1867 BEFORE_POTENTIAL_GC ();
1868 error ("set-mark is an obsolete bytecode");
1869 AFTER_POTENTIAL_GC ();
1870 break;
1871 case Bscan_buffer:
1872 BEFORE_POTENTIAL_GC ();
1873 error ("scan-buffer is an obsolete bytecode");
1874 AFTER_POTENTIAL_GC ();
1875 break;
1876 #endif
1877
1878 CASE_ABORT:
1879 /* Actually this is Bstack_ref with offset 0, but we use Bdup
1880 for that instead. */
1881 /* CASE (Bstack_ref): */
1882 abort ();
1883
1884 /* Handy byte-codes for lexical binding. */
1885 CASE (Bstack_ref1):
1886 CASE (Bstack_ref2):
1887 CASE (Bstack_ref3):
1888 CASE (Bstack_ref4):
1889 CASE (Bstack_ref5):
1890 {
1891 Lisp_Object *ptr = top - (op - Bstack_ref);
1892 PUSH (*ptr);
1893 NEXT;
1894 }
1895 CASE (Bstack_ref6):
1896 {
1897 Lisp_Object *ptr = top - (FETCH);
1898 PUSH (*ptr);
1899 NEXT;
1900 }
1901 CASE (Bstack_ref7):
1902 {
1903 Lisp_Object *ptr = top - (FETCH2);
1904 PUSH (*ptr);
1905 NEXT;
1906 }
1907 CASE (Bstack_set):
1908 /* stack-set-0 = discard; stack-set-1 = discard-1-preserve-tos. */
1909 {
1910 Lisp_Object *ptr = top - (FETCH);
1911 *ptr = POP;
1912 NEXT;
1913 }
1914 CASE (Bstack_set2):
1915 {
1916 Lisp_Object *ptr = top - (FETCH2);
1917 *ptr = POP;
1918 NEXT;
1919 }
1920 CASE (BdiscardN):
1921 op = FETCH;
1922 if (op & 0x80)
1923 {
1924 op &= 0x7F;
1925 top[-op] = TOP;
1926 }
1927 DISCARD (op);
1928 NEXT;
1929
1930 CASE_DEFAULT
1931 CASE (Bconstant):
1932 #ifdef BYTE_CODE_SAFE
1933 if (op < Bconstant)
1934 {
1935 abort ();
1936 }
1937 if ((op -= Bconstant) >= const_length)
1938 {
1939 abort ();
1940 }
1941 PUSH (vectorp[op]);
1942 #else
1943 PUSH (vectorp[op - Bconstant]);
1944 #endif
1945 NEXT;
1946 }
1947 }
1948
1949 exit:
1950
1951 byte_stack_list = byte_stack_list->next;
1952
1953 /* Binds and unbinds are supposed to be compiled balanced. */
1954 if (SPECPDL_INDEX () != count)
1955 #ifdef BYTE_CODE_SAFE
1956 error ("binding stack not balanced (serious byte compiler bug)");
1957 #else
1958 abort ();
1959 #endif
1960
1961 return result;
1962 }
1963
1964 void
1965 syms_of_bytecode (void)
1966 {
1967 DEFSYM (Qbytecode, "byte-code");
1968
1969 defsubr (&Sbyte_code);
1970
1971 #ifdef BYTE_CODE_METER
1972
1973 DEFVAR_LISP ("byte-code-meter", Vbyte_code_meter,
1974 doc: /* A vector of vectors which holds a histogram of byte-code usage.
1975 \(aref (aref byte-code-meter 0) CODE) indicates how many times the byte
1976 opcode CODE has been executed.
1977 \(aref (aref byte-code-meter CODE1) CODE2), where CODE1 is not 0,
1978 indicates how many times the byte opcodes CODE1 and CODE2 have been
1979 executed in succession. */);
1980
1981 DEFVAR_BOOL ("byte-metering-on", byte_metering_on,
1982 doc: /* If non-nil, keep profiling information on byte code usage.
1983 The variable byte-code-meter indicates how often each byte opcode is used.
1984 If a symbol has a property named `byte-code-meter' whose value is an
1985 integer, it is incremented each time that symbol's function is called. */);
1986
1987 byte_metering_on = 0;
1988 Vbyte_code_meter = Fmake_vector (make_number (256), make_number (0));
1989 DEFSYM (Qbyte_code_meter, "byte-code-meter");
1990 {
1991 int i = 256;
1992 while (i--)
1993 ASET (Vbyte_code_meter, i,
1994 Fmake_vector (make_number (256), make_number (0)));
1995 }
1996 #endif
1997 }
Unnamed repository; edit this file 'description' to name the repository.