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