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