HCoop / bpt / emacs.git / blob
? search:


f1bdfd9d9c5f28c87851c0f19e4e4a88598d9a57
[bpt/emacs.git] / src / bytecode.c
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 #ifdef BYTE_CODE_METER
505 int volatile this_op = 0;
506 int prev_op;
507 #endif
508 int op;
509 /* Lisp_Object v1, v2; */
510 Lisp_Object *vectorp;
511 #ifdef BYTE_CODE_SAFE
512 ptrdiff_t const_length;
513 Lisp_Object *stacke;
514 ptrdiff_t bytestr_length;
515 #endif
516 struct byte_stack stack;
517 Lisp_Object *top;
518 Lisp_Object result;
519 enum handlertype type;
520
521 #if 0 /* CHECK_FRAME_FONT */
522 {
523 struct frame *f = SELECTED_FRAME ();
524 if (FRAME_X_P (f)
525 && FRAME_FONT (f)->direction != 0
526 && FRAME_FONT (f)->direction != 1)
527 emacs_abort ();
528 }
529 #endif
530
531 CHECK_STRING (bytestr);
532 CHECK_VECTOR (vector);
533 CHECK_NATNUM (maxdepth);
534
535 #ifdef BYTE_CODE_SAFE
536 const_length = ASIZE (vector);
537 #endif
538
539 if (STRING_MULTIBYTE (bytestr))
540 /* BYTESTR must have been produced by Emacs 20.2 or the earlier
541 because they produced a raw 8-bit string for byte-code and now
542 such a byte-code string is loaded as multibyte while raw 8-bit
543 characters converted to multibyte form. Thus, now we must
544 convert them back to the originally intended unibyte form. */
545 bytestr = Fstring_as_unibyte (bytestr);
546
547 #ifdef BYTE_CODE_SAFE
548 bytestr_length = SBYTES (bytestr);
549 #endif
550 vectorp = XVECTOR (vector)->contents;
551
552 stack.byte_string = bytestr;
553 stack.pc = stack.byte_string_start = SDATA (bytestr);
554 #if BYTE_MARK_STACK
555 stack.constants = vector;
556 #endif
557 if (MAX_ALLOCA / word_size <= XFASTINT (maxdepth))
558 memory_full (SIZE_MAX);
559 top = alloca ((XFASTINT (maxdepth) + 1) * sizeof *top);
560 #if BYTE_MAINTAIN_TOP
561 stack.bottom = top + 1;
562 stack.top = NULL;
563 #endif
564 stack.next = byte_stack_list;
565 byte_stack_list = &stack;
566
567 #ifdef BYTE_CODE_SAFE
568 stacke = stack.bottom - 1 + XFASTINT (maxdepth);
569 #endif
570
571 if (INTEGERP (args_template))
572 {
573 ptrdiff_t at = XINT (args_template);
574 bool rest = (at & 128) != 0;
575 int mandatory = at & 127;
576 ptrdiff_t nonrest = at >> 8;
577 eassert (mandatory <= nonrest);
578 if (nargs <= nonrest)
579 {
580 ptrdiff_t i;
581 for (i = 0 ; i < nargs; i++, args++)
582 PUSH (*args);
583 if (nargs < mandatory)
584 /* Too few arguments. */
585 Fsignal (Qwrong_number_of_arguments,
586 list2 (Fcons (make_number (mandatory),
587 rest ? Qand_rest : make_number (nonrest)),
588 make_number (nargs)));
589 else
590 {
591 for (; i < nonrest; i++)
592 PUSH (Qnil);
593 if (rest)
594 PUSH (Qnil);
595 }
596 }
597 else if (rest)
598 {
599 ptrdiff_t i;
600 for (i = 0 ; i < nonrest; i++, args++)
601 PUSH (*args);
602 PUSH (Flist (nargs - nonrest, args));
603 }
604 else
605 /* Too many arguments. */
606 Fsignal (Qwrong_number_of_arguments,
607 list2 (Fcons (make_number (mandatory), make_number (nonrest)),
608 make_number (nargs)));
609 }
610 else if (! NILP (args_template))
611 /* We should push some arguments on the stack. */
612 {
613 error ("Unknown args template!");
614 }
615
616 while (1)
617 {
618 #ifdef BYTE_CODE_SAFE
619 if (top > stacke)
620 emacs_abort ();
621 else if (top < stack.bottom - 1)
622 emacs_abort ();
623 #endif
624
625 #ifdef BYTE_CODE_METER
626 prev_op = this_op;
627 this_op = op = FETCH;
628 METER_CODE (prev_op, op);
629 #else
630 #ifndef BYTE_CODE_THREADED
631 op = FETCH;
632 #endif
633 #endif
634
635 /* The interpreter can be compiled one of two ways: as an
636 ordinary switch-based interpreter, or as a threaded
637 interpreter. The threaded interpreter relies on GCC's
638 computed goto extension, so it is not available everywhere.
639 Threading provides a performance boost. These macros are how
640 we allow the code to be compiled both ways. */
641 #ifdef BYTE_CODE_THREADED
642 /* The CASE macro introduces an instruction's body. It is
643 either a label or a case label. */
644 #define CASE(OP) insn_ ## OP
645 /* NEXT is invoked at the end of an instruction to go to the
646 next instruction. It is either a computed goto, or a
647 plain break. */
648 #define NEXT goto *(targets[op = FETCH])
649 /* FIRST is like NEXT, but is only used at the start of the
650 interpreter body. In the switch-based interpreter it is the
651 switch, so the threaded definition must include a semicolon. */
652 #define FIRST NEXT;
653 /* Most cases are labeled with the CASE macro, above.
654 CASE_DEFAULT is one exception; it is used if the interpreter
655 being built requires a default case. The threaded
656 interpreter does not, because the dispatch table is
657 completely filled. */
658 #define CASE_DEFAULT
659 /* This introduces an instruction that is known to call abort. */
660 #define CASE_ABORT CASE (Bstack_ref): CASE (default)
661 #else
662 /* See above for the meaning of the various defines. */
663 #define CASE(OP) case OP
664 #define NEXT break
665 #define FIRST switch (op)
666 #define CASE_DEFAULT case 255: default:
667 #define CASE_ABORT case 0
668 #endif
669
670 #ifdef BYTE_CODE_THREADED
671
672 /* A convenience define that saves us a lot of typing and makes
673 the table clearer. */
674 #define LABEL(OP) [OP] = &&insn_ ## OP
675
676 #if 4 < __GNUC__ + (6 <= __GNUC_MINOR__)
677 # pragma GCC diagnostic push
678 # pragma GCC diagnostic ignored "-Woverride-init"
679 #elif defined __clang__
680 # pragma GCC diagnostic push
681 # pragma GCC diagnostic ignored "-Winitializer-overrides"
682 #endif
683
684 /* This is the dispatch table for the threaded interpreter. */
685 static const void *const targets[256] =
686 {
687 [0 ... (Bconstant - 1)] = &&insn_default,
688 [Bconstant ... 255] = &&insn_Bconstant,
689
690 #define DEFINE(name, value) LABEL (name) ,
691 BYTE_CODES
692 #undef DEFINE
693 };
694
695 #if 4 < __GNUC__ + (6 <= __GNUC_MINOR__) || defined __clang__
696 # pragma GCC diagnostic pop
697 #endif
698
699 #endif
700
701
702 FIRST
703 {
704 CASE (Bvarref7):
705 op = FETCH2;
706 goto varref;
707
708 CASE (Bvarref):
709 CASE (Bvarref1):
710 CASE (Bvarref2):
711 CASE (Bvarref3):
712 CASE (Bvarref4):
713 CASE (Bvarref5):
714 op = op - Bvarref;
715 goto varref;
716
717 /* This seems to be the most frequently executed byte-code
718 among the Bvarref's, so avoid a goto here. */
719 CASE (Bvarref6):
720 op = FETCH;
721 varref:
722 {
723 Lisp_Object v1, v2;
724
725 v1 = vectorp[op];
726 if (SYMBOLP (v1))
727 {
728 if (XSYMBOL (v1)->redirect != SYMBOL_PLAINVAL
729 || (v2 = SYMBOL_VAL (XSYMBOL (v1)),
730 EQ (v2, Qunbound)))
731 {
732 BEFORE_POTENTIAL_GC ();
733 v2 = Fsymbol_value (v1);
734 AFTER_POTENTIAL_GC ();
735 }
736 }
737 else
738 {
739 BEFORE_POTENTIAL_GC ();
740 v2 = Fsymbol_value (v1);
741 AFTER_POTENTIAL_GC ();
742 }
743 PUSH (v2);
744 NEXT;
745 }
746
747 CASE (Bgotoifnil):
748 {
749 Lisp_Object v1;
750 MAYBE_GC ();
751 op = FETCH2;
752 v1 = POP;
753 if (NILP (v1))
754 {
755 BYTE_CODE_QUIT;
756 CHECK_RANGE (op);
757 stack.pc = stack.byte_string_start + op;
758 }
759 NEXT;
760 }
761
762 CASE (Bcar):
763 {
764 Lisp_Object v1;
765 v1 = TOP;
766 if (CONSP (v1))
767 TOP = XCAR (v1);
768 else if (NILP (v1))
769 TOP = Qnil;
770 else
771 {
772 BEFORE_POTENTIAL_GC ();
773 wrong_type_argument (Qlistp, v1);
774 }
775 NEXT;
776 }
777
778 CASE (Beq):
779 {
780 Lisp_Object v1;
781 v1 = POP;
782 TOP = EQ (v1, TOP) ? Qt : Qnil;
783 NEXT;
784 }
785
786 CASE (Bmemq):
787 {
788 Lisp_Object v1;
789 BEFORE_POTENTIAL_GC ();
790 v1 = POP;
791 TOP = Fmemq (TOP, v1);
792 AFTER_POTENTIAL_GC ();
793 NEXT;
794 }
795
796 CASE (Bcdr):
797 {
798 Lisp_Object v1;
799 v1 = TOP;
800 if (CONSP (v1))
801 TOP = XCDR (v1);
802 else if (NILP (v1))
803 TOP = Qnil;
804 else
805 {
806 BEFORE_POTENTIAL_GC ();
807 wrong_type_argument (Qlistp, v1);
808 }
809 NEXT;
810 }
811
812 CASE (Bvarset):
813 CASE (Bvarset1):
814 CASE (Bvarset2):
815 CASE (Bvarset3):
816 CASE (Bvarset4):
817 CASE (Bvarset5):
818 op -= Bvarset;
819 goto varset;
820
821 CASE (Bvarset7):
822 op = FETCH2;
823 goto varset;
824
825 CASE (Bvarset6):
826 op = FETCH;
827 varset:
828 {
829 Lisp_Object sym, val;
830
831 sym = vectorp[op];
832 val = TOP;
833
834 /* Inline the most common case. */
835 if (SYMBOLP (sym)
836 && !EQ (val, Qunbound)
837 && !XSYMBOL (sym)->redirect
838 && !SYMBOL_CONSTANT_P (sym))
839 SET_SYMBOL_VAL (XSYMBOL (sym), val);
840 else
841 {
842 BEFORE_POTENTIAL_GC ();
843 set_internal (sym, val, Qnil, 0);
844 AFTER_POTENTIAL_GC ();
845 }
846 }
847 (void) POP;
848 NEXT;
849
850 CASE (Bdup):
851 {
852 Lisp_Object v1;
853 v1 = TOP;
854 PUSH (v1);
855 NEXT;
856 }
857
858 /* ------------------ */
859
860 CASE (Bvarbind6):
861 op = FETCH;
862 goto varbind;
863
864 CASE (Bvarbind7):
865 op = FETCH2;
866 goto varbind;
867
868 CASE (Bvarbind):
869 CASE (Bvarbind1):
870 CASE (Bvarbind2):
871 CASE (Bvarbind3):
872 CASE (Bvarbind4):
873 CASE (Bvarbind5):
874 op -= Bvarbind;
875 varbind:
876 /* Specbind can signal and thus GC. */
877 BEFORE_POTENTIAL_GC ();
878 specbind (vectorp[op], POP);
879 AFTER_POTENTIAL_GC ();
880 NEXT;
881
882 CASE (Bcall6):
883 op = FETCH;
884 goto docall;
885
886 CASE (Bcall7):
887 op = FETCH2;
888 goto docall;
889
890 CASE (Bcall):
891 CASE (Bcall1):
892 CASE (Bcall2):
893 CASE (Bcall3):
894 CASE (Bcall4):
895 CASE (Bcall5):
896 op -= Bcall;
897 docall:
898 {
899 BEFORE_POTENTIAL_GC ();
900 DISCARD (op);
901 #ifdef BYTE_CODE_METER
902 if (byte_metering_on && SYMBOLP (TOP))
903 {
904 Lisp_Object v1, v2;
905
906 v1 = TOP;
907 v2 = Fget (v1, Qbyte_code_meter);
908 if (INTEGERP (v2)
909 && XINT (v2) < MOST_POSITIVE_FIXNUM)
910 {
911 XSETINT (v2, XINT (v2) + 1);
912 Fput (v1, Qbyte_code_meter, v2);
913 }
914 }
915 #endif
916 TOP = Ffuncall (op + 1, &TOP);
917 AFTER_POTENTIAL_GC ();
918 NEXT;
919 }
920
921 CASE (Bunbind6):
922 op = FETCH;
923 goto dounbind;
924
925 CASE (Bunbind7):
926 op = FETCH2;
927 goto dounbind;
928
929 CASE (Bunbind):
930 CASE (Bunbind1):
931 CASE (Bunbind2):
932 CASE (Bunbind3):
933 CASE (Bunbind4):
934 CASE (Bunbind5):
935 op -= Bunbind;
936 dounbind:
937 BEFORE_POTENTIAL_GC ();
938 unbind_to (SPECPDL_INDEX () - op, Qnil);
939 AFTER_POTENTIAL_GC ();
940 NEXT;
941
942 CASE (Bunbind_all): /* Obsolete. Never used. */
943 /* To unbind back to the beginning of this frame. Not used yet,
944 but will be needed for tail-recursion elimination. */
945 BEFORE_POTENTIAL_GC ();
946 unbind_to (count, Qnil);
947 AFTER_POTENTIAL_GC ();
948 NEXT;
949
950 CASE (Bgoto):
951 MAYBE_GC ();
952 BYTE_CODE_QUIT;
953 op = FETCH2; /* pc = FETCH2 loses since FETCH2 contains pc++ */
954 CHECK_RANGE (op);
955 stack.pc = stack.byte_string_start + op;
956 NEXT;
957
958 CASE (Bgotoifnonnil):
959 {
960 Lisp_Object v1;
961 MAYBE_GC ();
962 op = FETCH2;
963 v1 = POP;
964 if (!NILP (v1))
965 {
966 BYTE_CODE_QUIT;
967 CHECK_RANGE (op);
968 stack.pc = stack.byte_string_start + op;
969 }
970 NEXT;
971 }
972
973 CASE (Bgotoifnilelsepop):
974 MAYBE_GC ();
975 op = FETCH2;
976 if (NILP (TOP))
977 {
978 BYTE_CODE_QUIT;
979 CHECK_RANGE (op);
980 stack.pc = stack.byte_string_start + op;
981 }
982 else DISCARD (1);
983 NEXT;
984
985 CASE (Bgotoifnonnilelsepop):
986 MAYBE_GC ();
987 op = FETCH2;
988 if (!NILP (TOP))
989 {
990 BYTE_CODE_QUIT;
991 CHECK_RANGE (op);
992 stack.pc = stack.byte_string_start + op;
993 }
994 else DISCARD (1);
995 NEXT;
996
997 CASE (BRgoto):
998 MAYBE_GC ();
999 BYTE_CODE_QUIT;
1000 stack.pc += (int) *stack.pc - 127;
1001 NEXT;
1002
1003 CASE (BRgotoifnil):
1004 {
1005 Lisp_Object v1;
1006 MAYBE_GC ();
1007 v1 = POP;
1008 if (NILP (v1))
1009 {
1010 BYTE_CODE_QUIT;
1011 stack.pc += (int) *stack.pc - 128;
1012 }
1013 stack.pc++;
1014 NEXT;
1015 }
1016
1017 CASE (BRgotoifnonnil):
1018 {
1019 Lisp_Object v1;
1020 MAYBE_GC ();
1021 v1 = POP;
1022 if (!NILP (v1))
1023 {
1024 BYTE_CODE_QUIT;
1025 stack.pc += (int) *stack.pc - 128;
1026 }
1027 stack.pc++;
1028 NEXT;
1029 }
1030
1031 CASE (BRgotoifnilelsepop):
1032 MAYBE_GC ();
1033 op = *stack.pc++;
1034 if (NILP (TOP))
1035 {
1036 BYTE_CODE_QUIT;
1037 stack.pc += op - 128;
1038 }
1039 else DISCARD (1);
1040 NEXT;
1041
1042 CASE (BRgotoifnonnilelsepop):
1043 MAYBE_GC ();
1044 op = *stack.pc++;
1045 if (!NILP (TOP))
1046 {
1047 BYTE_CODE_QUIT;
1048 stack.pc += op - 128;
1049 }
1050 else DISCARD (1);
1051 NEXT;
1052
1053 CASE (Breturn):
1054 result = POP;
1055 goto exit;
1056
1057 CASE (Bdiscard):
1058 DISCARD (1);
1059 NEXT;
1060
1061 CASE (Bconstant2):
1062 PUSH (vectorp[FETCH2]);
1063 NEXT;
1064
1065 CASE (Bsave_excursion):
1066 record_unwind_protect (save_excursion_restore,
1067 save_excursion_save ());
1068 NEXT;
1069
1070 CASE (Bsave_current_buffer): /* Obsolete since ??. */
1071 CASE (Bsave_current_buffer_1):
1072 record_unwind_current_buffer ();
1073 NEXT;
1074
1075 CASE (Bsave_window_excursion): /* Obsolete since 24.1. */
1076 {
1077 ptrdiff_t count1 = SPECPDL_INDEX ();
1078 record_unwind_protect (restore_window_configuration,
1079 Fcurrent_window_configuration (Qnil));
1080 BEFORE_POTENTIAL_GC ();
1081 TOP = Fprogn (TOP);
1082 unbind_to (count1, TOP);
1083 AFTER_POTENTIAL_GC ();
1084 NEXT;
1085 }
1086
1087 CASE (Bsave_restriction):
1088 record_unwind_protect (save_restriction_restore,
1089 save_restriction_save ());
1090 NEXT;
1091
1092 CASE (Bcatch): /* Obsolete since 24.4. */
1093 {
1094 Lisp_Object v1;
1095 BEFORE_POTENTIAL_GC ();
1096 v1 = POP;
1097 TOP = internal_catch (TOP, eval_sub, v1);
1098 AFTER_POTENTIAL_GC ();
1099 NEXT;
1100 }
1101
1102 CASE (Bpushcatch): /* New in 24.4. */
1103 type = CATCHER;
1104 goto pushhandler;
1105 CASE (Bpushconditioncase): /* New in 24.4. */
1106 {
1107 extern EMACS_INT lisp_eval_depth;
1108 extern int poll_suppress_count;
1109 extern int interrupt_input_blocked;
1110 struct handler *c;
1111 Lisp_Object tag;
1112 int dest;
1113
1114 type = CONDITION_CASE;
1115 pushhandler:
1116 tag = POP;
1117 dest = FETCH2;
1118
1119 PUSH_HANDLER (c, tag, type);
1120 c->bytecode_dest = dest;
1121 c->bytecode_top = top;
1122
1123 if (sys_setjmp (c->jmp))
1124 {
1125 struct handler *c = handlerlist;
1126 int dest;
1127 top = c->bytecode_top;
1128 dest = c->bytecode_dest;
1129 handlerlist = c->next;
1130 PUSH (c->val);
1131 CHECK_RANGE (dest);
1132 /* Might have been re-set by longjmp! */
1133 stack.byte_string_start = SDATA (stack.byte_string);
1134 stack.pc = stack.byte_string_start + dest;
1135 }
1136
1137 NEXT;
1138 }
1139
1140 CASE (Bpophandler): /* New in 24.4. */
1141 {
1142 handlerlist = handlerlist->next;
1143 NEXT;
1144 }
1145
1146 CASE (Bunwind_protect): /* FIXME: avoid closure for lexbind. */
1147 {
1148 Lisp_Object handler = POP;
1149 /* Support for a function here is new in 24.4. */
1150 record_unwind_protect (NILP (Ffunctionp (handler))
1151 ? unwind_body : bcall0,
1152 handler);
1153 NEXT;
1154 }
1155
1156 CASE (Bcondition_case): /* Obsolete since 24.4. */
1157 {
1158 Lisp_Object handlers, body;
1159 handlers = POP;
1160 body = POP;
1161 BEFORE_POTENTIAL_GC ();
1162 TOP = internal_lisp_condition_case (TOP, body, handlers);
1163 AFTER_POTENTIAL_GC ();
1164 NEXT;
1165 }
1166
1167 CASE (Btemp_output_buffer_setup): /* Obsolete since 24.1. */
1168 BEFORE_POTENTIAL_GC ();
1169 CHECK_STRING (TOP);
1170 temp_output_buffer_setup (SSDATA (TOP));
1171 AFTER_POTENTIAL_GC ();
1172 TOP = Vstandard_output;
1173 NEXT;
1174
1175 CASE (Btemp_output_buffer_show): /* Obsolete since 24.1. */
1176 {
1177 Lisp_Object v1;
1178 BEFORE_POTENTIAL_GC ();
1179 v1 = POP;
1180 temp_output_buffer_show (TOP);
1181 TOP = v1;
1182 /* pop binding of standard-output */
1183 unbind_to (SPECPDL_INDEX () - 1, Qnil);
1184 AFTER_POTENTIAL_GC ();
1185 NEXT;
1186 }
1187
1188 CASE (Bnth):
1189 {
1190 Lisp_Object v1, v2;
1191 EMACS_INT n;
1192 BEFORE_POTENTIAL_GC ();
1193 v1 = POP;
1194 v2 = TOP;
1195 CHECK_NUMBER (v2);
1196 n = XINT (v2);
1197 immediate_quit = 1;
1198 while (--n >= 0 && CONSP (v1))
1199 v1 = XCDR (v1);
1200 immediate_quit = 0;
1201 TOP = CAR (v1);
1202 AFTER_POTENTIAL_GC ();
1203 NEXT;
1204 }
1205
1206 CASE (Bsymbolp):
1207 TOP = SYMBOLP (TOP) ? Qt : Qnil;
1208 NEXT;
1209
1210 CASE (Bconsp):
1211 TOP = CONSP (TOP) ? Qt : Qnil;
1212 NEXT;
1213
1214 CASE (Bstringp):
1215 TOP = STRINGP (TOP) ? Qt : Qnil;
1216 NEXT;
1217
1218 CASE (Blistp):
1219 TOP = CONSP (TOP) || NILP (TOP) ? Qt : Qnil;
1220 NEXT;
1221
1222 CASE (Bnot):
1223 TOP = NILP (TOP) ? Qt : Qnil;
1224 NEXT;
1225
1226 CASE (Bcons):
1227 {
1228 Lisp_Object v1;
1229 v1 = POP;
1230 TOP = Fcons (TOP, v1);
1231 NEXT;
1232 }
1233
1234 CASE (Blist1):
1235 TOP = list1 (TOP);
1236 NEXT;
1237
1238 CASE (Blist2):
1239 {
1240 Lisp_Object v1;
1241 v1 = POP;
1242 TOP = list2 (TOP, v1);
1243 NEXT;
1244 }
1245
1246 CASE (Blist3):
1247 DISCARD (2);
1248 TOP = Flist (3, &TOP);
1249 NEXT;
1250
1251 CASE (Blist4):
1252 DISCARD (3);
1253 TOP = Flist (4, &TOP);
1254 NEXT;
1255
1256 CASE (BlistN):
1257 op = FETCH;
1258 DISCARD (op - 1);
1259 TOP = Flist (op, &TOP);
1260 NEXT;
1261
1262 CASE (Blength):
1263 BEFORE_POTENTIAL_GC ();
1264 TOP = Flength (TOP);
1265 AFTER_POTENTIAL_GC ();
1266 NEXT;
1267
1268 CASE (Baref):
1269 {
1270 Lisp_Object v1;
1271 BEFORE_POTENTIAL_GC ();
1272 v1 = POP;
1273 TOP = Faref (TOP, v1);
1274 AFTER_POTENTIAL_GC ();
1275 NEXT;
1276 }
1277
1278 CASE (Baset):
1279 {
1280 Lisp_Object v1, v2;
1281 BEFORE_POTENTIAL_GC ();
1282 v2 = POP; v1 = POP;
1283 TOP = Faset (TOP, v1, v2);
1284 AFTER_POTENTIAL_GC ();
1285 NEXT;
1286 }
1287
1288 CASE (Bsymbol_value):
1289 BEFORE_POTENTIAL_GC ();
1290 TOP = Fsymbol_value (TOP);
1291 AFTER_POTENTIAL_GC ();
1292 NEXT;
1293
1294 CASE (Bsymbol_function):
1295 BEFORE_POTENTIAL_GC ();
1296 TOP = Fsymbol_function (TOP);
1297 AFTER_POTENTIAL_GC ();
1298 NEXT;
1299
1300 CASE (Bset):
1301 {
1302 Lisp_Object v1;
1303 BEFORE_POTENTIAL_GC ();
1304 v1 = POP;
1305 TOP = Fset (TOP, v1);
1306 AFTER_POTENTIAL_GC ();
1307 NEXT;
1308 }
1309
1310 CASE (Bfset):
1311 {
1312 Lisp_Object v1;
1313 BEFORE_POTENTIAL_GC ();
1314 v1 = POP;
1315 TOP = Ffset (TOP, v1);
1316 AFTER_POTENTIAL_GC ();
1317 NEXT;
1318 }
1319
1320 CASE (Bget):
1321 {
1322 Lisp_Object v1;
1323 BEFORE_POTENTIAL_GC ();
1324 v1 = POP;
1325 TOP = Fget (TOP, v1);
1326 AFTER_POTENTIAL_GC ();
1327 NEXT;
1328 }
1329
1330 CASE (Bsubstring):
1331 {
1332 Lisp_Object v1, v2;
1333 BEFORE_POTENTIAL_GC ();
1334 v2 = POP; v1 = POP;
1335 TOP = Fsubstring (TOP, v1, v2);
1336 AFTER_POTENTIAL_GC ();
1337 NEXT;
1338 }
1339
1340 CASE (Bconcat2):
1341 BEFORE_POTENTIAL_GC ();
1342 DISCARD (1);
1343 TOP = Fconcat (2, &TOP);
1344 AFTER_POTENTIAL_GC ();
1345 NEXT;
1346
1347 CASE (Bconcat3):
1348 BEFORE_POTENTIAL_GC ();
1349 DISCARD (2);
1350 TOP = Fconcat (3, &TOP);
1351 AFTER_POTENTIAL_GC ();
1352 NEXT;
1353
1354 CASE (Bconcat4):
1355 BEFORE_POTENTIAL_GC ();
1356 DISCARD (3);
1357 TOP = Fconcat (4, &TOP);
1358 AFTER_POTENTIAL_GC ();
1359 NEXT;
1360
1361 CASE (BconcatN):
1362 op = FETCH;
1363 BEFORE_POTENTIAL_GC ();
1364 DISCARD (op - 1);
1365 TOP = Fconcat (op, &TOP);
1366 AFTER_POTENTIAL_GC ();
1367 NEXT;
1368
1369 CASE (Bsub1):
1370 {
1371 Lisp_Object v1;
1372 v1 = TOP;
1373 if (INTEGERP (v1))
1374 {
1375 XSETINT (v1, XINT (v1) - 1);
1376 TOP = v1;
1377 }
1378 else
1379 {
1380 BEFORE_POTENTIAL_GC ();
1381 TOP = Fsub1 (v1);
1382 AFTER_POTENTIAL_GC ();
1383 }
1384 NEXT;
1385 }
1386
1387 CASE (Badd1):
1388 {
1389 Lisp_Object v1;
1390 v1 = TOP;
1391 if (INTEGERP (v1))
1392 {
1393 XSETINT (v1, XINT (v1) + 1);
1394 TOP = v1;
1395 }
1396 else
1397 {
1398 BEFORE_POTENTIAL_GC ();
1399 TOP = Fadd1 (v1);
1400 AFTER_POTENTIAL_GC ();
1401 }
1402 NEXT;
1403 }
1404
1405 CASE (Beqlsign):
1406 {
1407 Lisp_Object v1, v2;
1408 BEFORE_POTENTIAL_GC ();
1409 v2 = POP; v1 = TOP;
1410 CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v1);
1411 CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v2);
1412 AFTER_POTENTIAL_GC ();
1413 if (FLOATP (v1) || FLOATP (v2))
1414 {
1415 double f1, f2;
1416
1417 f1 = (FLOATP (v1) ? XFLOAT_DATA (v1) : XINT (v1));
1418 f2 = (FLOATP (v2) ? XFLOAT_DATA (v2) : XINT (v2));
1419 TOP = (f1 == f2 ? Qt : Qnil);
1420 }
1421 else
1422 TOP = (XINT (v1) == XINT (v2) ? Qt : Qnil);
1423 NEXT;
1424 }
1425
1426 CASE (Bgtr):
1427 {
1428 Lisp_Object v1;
1429 BEFORE_POTENTIAL_GC ();
1430 v1 = POP;
1431 TOP = arithcompare (TOP, v1, ARITH_GRTR);
1432 AFTER_POTENTIAL_GC ();
1433 NEXT;
1434 }
1435
1436 CASE (Blss):
1437 {
1438 Lisp_Object v1;
1439 BEFORE_POTENTIAL_GC ();
1440 v1 = POP;
1441 TOP = arithcompare (TOP, v1, ARITH_LESS);
1442 AFTER_POTENTIAL_GC ();
1443 NEXT;
1444 }
1445
1446 CASE (Bleq):
1447 {
1448 Lisp_Object v1;
1449 BEFORE_POTENTIAL_GC ();
1450 v1 = POP;
1451 TOP = arithcompare (TOP, v1, ARITH_LESS_OR_EQUAL);
1452 AFTER_POTENTIAL_GC ();
1453 NEXT;
1454 }
1455
1456 CASE (Bgeq):
1457 {
1458 Lisp_Object v1;
1459 BEFORE_POTENTIAL_GC ();
1460 v1 = POP;
1461 TOP = arithcompare (TOP, v1, ARITH_GRTR_OR_EQUAL);
1462 AFTER_POTENTIAL_GC ();
1463 NEXT;
1464 }
1465
1466 CASE (Bdiff):
1467 BEFORE_POTENTIAL_GC ();
1468 DISCARD (1);
1469 TOP = Fminus (2, &TOP);
1470 AFTER_POTENTIAL_GC ();
1471 NEXT;
1472
1473 CASE (Bnegate):
1474 {
1475 Lisp_Object v1;
1476 v1 = TOP;
1477 if (INTEGERP (v1))
1478 {
1479 XSETINT (v1, - XINT (v1));
1480 TOP = v1;
1481 }
1482 else
1483 {
1484 BEFORE_POTENTIAL_GC ();
1485 TOP = Fminus (1, &TOP);
1486 AFTER_POTENTIAL_GC ();
1487 }
1488 NEXT;
1489 }
1490
1491 CASE (Bplus):
1492 BEFORE_POTENTIAL_GC ();
1493 DISCARD (1);
1494 TOP = Fplus (2, &TOP);
1495 AFTER_POTENTIAL_GC ();
1496 NEXT;
1497
1498 CASE (Bmax):
1499 BEFORE_POTENTIAL_GC ();
1500 DISCARD (1);
1501 TOP = Fmax (2, &TOP);
1502 AFTER_POTENTIAL_GC ();
1503 NEXT;
1504
1505 CASE (Bmin):
1506 BEFORE_POTENTIAL_GC ();
1507 DISCARD (1);
1508 TOP = Fmin (2, &TOP);
1509 AFTER_POTENTIAL_GC ();
1510 NEXT;
1511
1512 CASE (Bmult):
1513 BEFORE_POTENTIAL_GC ();
1514 DISCARD (1);
1515 TOP = Ftimes (2, &TOP);
1516 AFTER_POTENTIAL_GC ();
1517 NEXT;
1518
1519 CASE (Bquo):
1520 BEFORE_POTENTIAL_GC ();
1521 DISCARD (1);
1522 TOP = Fquo (2, &TOP);
1523 AFTER_POTENTIAL_GC ();
1524 NEXT;
1525
1526 CASE (Brem):
1527 {
1528 Lisp_Object v1;
1529 BEFORE_POTENTIAL_GC ();
1530 v1 = POP;
1531 TOP = Frem (TOP, v1);
1532 AFTER_POTENTIAL_GC ();
1533 NEXT;
1534 }
1535
1536 CASE (Bpoint):
1537 {
1538 Lisp_Object v1;
1539 XSETFASTINT (v1, PT);
1540 PUSH (v1);
1541 NEXT;
1542 }
1543
1544 CASE (Bgoto_char):
1545 BEFORE_POTENTIAL_GC ();
1546 TOP = Fgoto_char (TOP);
1547 AFTER_POTENTIAL_GC ();
1548 NEXT;
1549
1550 CASE (Binsert):
1551 BEFORE_POTENTIAL_GC ();
1552 TOP = Finsert (1, &TOP);
1553 AFTER_POTENTIAL_GC ();
1554 NEXT;
1555
1556 CASE (BinsertN):
1557 op = FETCH;
1558 BEFORE_POTENTIAL_GC ();
1559 DISCARD (op - 1);
1560 TOP = Finsert (op, &TOP);
1561 AFTER_POTENTIAL_GC ();
1562 NEXT;
1563
1564 CASE (Bpoint_max):
1565 {
1566 Lisp_Object v1;
1567 XSETFASTINT (v1, ZV);
1568 PUSH (v1);
1569 NEXT;
1570 }
1571
1572 CASE (Bpoint_min):
1573 {
1574 Lisp_Object v1;
1575 XSETFASTINT (v1, BEGV);
1576 PUSH (v1);
1577 NEXT;
1578 }
1579
1580 CASE (Bchar_after):
1581 BEFORE_POTENTIAL_GC ();
1582 TOP = Fchar_after (TOP);
1583 AFTER_POTENTIAL_GC ();
1584 NEXT;
1585
1586 CASE (Bfollowing_char):
1587 {
1588 Lisp_Object v1;
1589 BEFORE_POTENTIAL_GC ();
1590 v1 = Ffollowing_char ();
1591 AFTER_POTENTIAL_GC ();
1592 PUSH (v1);
1593 NEXT;
1594 }
1595
1596 CASE (Bpreceding_char):
1597 {
1598 Lisp_Object v1;
1599 BEFORE_POTENTIAL_GC ();
1600 v1 = Fprevious_char ();
1601 AFTER_POTENTIAL_GC ();
1602 PUSH (v1);
1603 NEXT;
1604 }
1605
1606 CASE (Bcurrent_column):
1607 {
1608 Lisp_Object v1;
1609 BEFORE_POTENTIAL_GC ();
1610 XSETFASTINT (v1, current_column ());
1611 AFTER_POTENTIAL_GC ();
1612 PUSH (v1);
1613 NEXT;
1614 }
1615
1616 CASE (Bindent_to):
1617 BEFORE_POTENTIAL_GC ();
1618 TOP = Findent_to (TOP, Qnil);
1619 AFTER_POTENTIAL_GC ();
1620 NEXT;
1621
1622 CASE (Beolp):
1623 PUSH (Feolp ());
1624 NEXT;
1625
1626 CASE (Beobp):
1627 PUSH (Feobp ());
1628 NEXT;
1629
1630 CASE (Bbolp):
1631 PUSH (Fbolp ());
1632 NEXT;
1633
1634 CASE (Bbobp):
1635 PUSH (Fbobp ());
1636 NEXT;
1637
1638 CASE (Bcurrent_buffer):
1639 PUSH (Fcurrent_buffer ());
1640 NEXT;
1641
1642 CASE (Bset_buffer):
1643 BEFORE_POTENTIAL_GC ();
1644 TOP = Fset_buffer (TOP);
1645 AFTER_POTENTIAL_GC ();
1646 NEXT;
1647
1648 CASE (Binteractive_p): /* Obsolete since 24.1. */
1649 BEFORE_POTENTIAL_GC ();
1650 PUSH (call0 (intern ("interactive-p")));
1651 AFTER_POTENTIAL_GC ();
1652 NEXT;
1653
1654 CASE (Bforward_char):
1655 BEFORE_POTENTIAL_GC ();
1656 TOP = Fforward_char (TOP);
1657 AFTER_POTENTIAL_GC ();
1658 NEXT;
1659
1660 CASE (Bforward_word):
1661 BEFORE_POTENTIAL_GC ();
1662 TOP = Fforward_word (TOP);
1663 AFTER_POTENTIAL_GC ();
1664 NEXT;
1665
1666 CASE (Bskip_chars_forward):
1667 {
1668 Lisp_Object v1;
1669 BEFORE_POTENTIAL_GC ();
1670 v1 = POP;
1671 TOP = Fskip_chars_forward (TOP, v1);
1672 AFTER_POTENTIAL_GC ();
1673 NEXT;
1674 }
1675
1676 CASE (Bskip_chars_backward):
1677 {
1678 Lisp_Object v1;
1679 BEFORE_POTENTIAL_GC ();
1680 v1 = POP;
1681 TOP = Fskip_chars_backward (TOP, v1);
1682 AFTER_POTENTIAL_GC ();
1683 NEXT;
1684 }
1685
1686 CASE (Bforward_line):
1687 BEFORE_POTENTIAL_GC ();
1688 TOP = Fforward_line (TOP);
1689 AFTER_POTENTIAL_GC ();
1690 NEXT;
1691
1692 CASE (Bchar_syntax):
1693 {
1694 int c;
1695
1696 BEFORE_POTENTIAL_GC ();
1697 CHECK_CHARACTER (TOP);
1698 AFTER_POTENTIAL_GC ();
1699 c = XFASTINT (TOP);
1700 if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
1701 MAKE_CHAR_MULTIBYTE (c);
1702 XSETFASTINT (TOP, syntax_code_spec[SYNTAX (c)]);
1703 }
1704 NEXT;
1705
1706 CASE (Bbuffer_substring):
1707 {
1708 Lisp_Object v1;
1709 BEFORE_POTENTIAL_GC ();
1710 v1 = POP;
1711 TOP = Fbuffer_substring (TOP, v1);
1712 AFTER_POTENTIAL_GC ();
1713 NEXT;
1714 }
1715
1716 CASE (Bdelete_region):
1717 {
1718 Lisp_Object v1;
1719 BEFORE_POTENTIAL_GC ();
1720 v1 = POP;
1721 TOP = Fdelete_region (TOP, v1);
1722 AFTER_POTENTIAL_GC ();
1723 NEXT;
1724 }
1725
1726 CASE (Bnarrow_to_region):
1727 {
1728 Lisp_Object v1;
1729 BEFORE_POTENTIAL_GC ();
1730 v1 = POP;
1731 TOP = Fnarrow_to_region (TOP, v1);
1732 AFTER_POTENTIAL_GC ();
1733 NEXT;
1734 }
1735
1736 CASE (Bwiden):
1737 BEFORE_POTENTIAL_GC ();
1738 PUSH (Fwiden ());
1739 AFTER_POTENTIAL_GC ();
1740 NEXT;
1741
1742 CASE (Bend_of_line):
1743 BEFORE_POTENTIAL_GC ();
1744 TOP = Fend_of_line (TOP);
1745 AFTER_POTENTIAL_GC ();
1746 NEXT;
1747
1748 CASE (Bset_marker):
1749 {
1750 Lisp_Object v1, v2;
1751 BEFORE_POTENTIAL_GC ();
1752 v1 = POP;
1753 v2 = POP;
1754 TOP = Fset_marker (TOP, v2, v1);
1755 AFTER_POTENTIAL_GC ();
1756 NEXT;
1757 }
1758
1759 CASE (Bmatch_beginning):
1760 BEFORE_POTENTIAL_GC ();
1761 TOP = Fmatch_beginning (TOP);
1762 AFTER_POTENTIAL_GC ();
1763 NEXT;
1764
1765 CASE (Bmatch_end):
1766 BEFORE_POTENTIAL_GC ();
1767 TOP = Fmatch_end (TOP);
1768 AFTER_POTENTIAL_GC ();
1769 NEXT;
1770
1771 CASE (Bupcase):
1772 BEFORE_POTENTIAL_GC ();
1773 TOP = Fupcase (TOP);
1774 AFTER_POTENTIAL_GC ();
1775 NEXT;
1776
1777 CASE (Bdowncase):
1778 BEFORE_POTENTIAL_GC ();
1779 TOP = Fdowncase (TOP);
1780 AFTER_POTENTIAL_GC ();
1781 NEXT;
1782
1783 CASE (Bstringeqlsign):
1784 {
1785 Lisp_Object v1;
1786 BEFORE_POTENTIAL_GC ();
1787 v1 = POP;
1788 TOP = Fstring_equal (TOP, v1);
1789 AFTER_POTENTIAL_GC ();
1790 NEXT;
1791 }
1792
1793 CASE (Bstringlss):
1794 {
1795 Lisp_Object v1;
1796 BEFORE_POTENTIAL_GC ();
1797 v1 = POP;
1798 TOP = Fstring_lessp (TOP, v1);
1799 AFTER_POTENTIAL_GC ();
1800 NEXT;
1801 }
1802
1803 CASE (Bequal):
1804 {
1805 Lisp_Object v1;
1806 v1 = POP;
1807 TOP = Fequal (TOP, v1);
1808 NEXT;
1809 }
1810
1811 CASE (Bnthcdr):
1812 {
1813 Lisp_Object v1;
1814 BEFORE_POTENTIAL_GC ();
1815 v1 = POP;
1816 TOP = Fnthcdr (TOP, v1);
1817 AFTER_POTENTIAL_GC ();
1818 NEXT;
1819 }
1820
1821 CASE (Belt):
1822 {
1823 Lisp_Object v1, v2;
1824 if (CONSP (TOP))
1825 {
1826 /* Exchange args and then do nth. */
1827 EMACS_INT n;
1828 BEFORE_POTENTIAL_GC ();
1829 v2 = POP;
1830 v1 = TOP;
1831 CHECK_NUMBER (v2);
1832 AFTER_POTENTIAL_GC ();
1833 n = XINT (v2);
1834 immediate_quit = 1;
1835 while (--n >= 0 && CONSP (v1))
1836 v1 = XCDR (v1);
1837 immediate_quit = 0;
1838 TOP = CAR (v1);
1839 }
1840 else
1841 {
1842 BEFORE_POTENTIAL_GC ();
1843 v1 = POP;
1844 TOP = Felt (TOP, v1);
1845 AFTER_POTENTIAL_GC ();
1846 }
1847 NEXT;
1848 }
1849
1850 CASE (Bmember):
1851 {
1852 Lisp_Object v1;
1853 BEFORE_POTENTIAL_GC ();
1854 v1 = POP;
1855 TOP = Fmember (TOP, v1);
1856 AFTER_POTENTIAL_GC ();
1857 NEXT;
1858 }
1859
1860 CASE (Bassq):
1861 {
1862 Lisp_Object v1;
1863 BEFORE_POTENTIAL_GC ();
1864 v1 = POP;
1865 TOP = Fassq (TOP, v1);
1866 AFTER_POTENTIAL_GC ();
1867 NEXT;
1868 }
1869
1870 CASE (Bnreverse):
1871 BEFORE_POTENTIAL_GC ();
1872 TOP = Fnreverse (TOP);
1873 AFTER_POTENTIAL_GC ();
1874 NEXT;
1875
1876 CASE (Bsetcar):
1877 {
1878 Lisp_Object v1;
1879 BEFORE_POTENTIAL_GC ();
1880 v1 = POP;
1881 TOP = Fsetcar (TOP, v1);
1882 AFTER_POTENTIAL_GC ();
1883 NEXT;
1884 }
1885
1886 CASE (Bsetcdr):
1887 {
1888 Lisp_Object v1;
1889 BEFORE_POTENTIAL_GC ();
1890 v1 = POP;
1891 TOP = Fsetcdr (TOP, v1);
1892 AFTER_POTENTIAL_GC ();
1893 NEXT;
1894 }
1895
1896 CASE (Bcar_safe):
1897 {
1898 Lisp_Object v1;
1899 v1 = TOP;
1900 TOP = CAR_SAFE (v1);
1901 NEXT;
1902 }
1903
1904 CASE (Bcdr_safe):
1905 {
1906 Lisp_Object v1;
1907 v1 = TOP;
1908 TOP = CDR_SAFE (v1);
1909 NEXT;
1910 }
1911
1912 CASE (Bnconc):
1913 BEFORE_POTENTIAL_GC ();
1914 DISCARD (1);
1915 TOP = Fnconc (2, &TOP);
1916 AFTER_POTENTIAL_GC ();
1917 NEXT;
1918
1919 CASE (Bnumberp):
1920 TOP = (NUMBERP (TOP) ? Qt : Qnil);
1921 NEXT;
1922
1923 CASE (Bintegerp):
1924 TOP = INTEGERP (TOP) ? Qt : Qnil;
1925 NEXT;
1926
1927 #ifdef BYTE_CODE_SAFE
1928 /* These are intentionally written using 'case' syntax,
1929 because they are incompatible with the threaded
1930 interpreter. */
1931
1932 case Bset_mark:
1933 BEFORE_POTENTIAL_GC ();
1934 error ("set-mark is an obsolete bytecode");
1935 AFTER_POTENTIAL_GC ();
1936 break;
1937 case Bscan_buffer:
1938 BEFORE_POTENTIAL_GC ();
1939 error ("scan-buffer is an obsolete bytecode");
1940 AFTER_POTENTIAL_GC ();
1941 break;
1942 #endif
1943
1944 CASE_ABORT:
1945 /* Actually this is Bstack_ref with offset 0, but we use Bdup
1946 for that instead. */
1947 /* CASE (Bstack_ref): */
1948 call3 (intern ("error"),
1949 build_string ("Invalid byte opcode: op=%s, ptr=%d"),
1950 make_number (op),
1951 make_number ((stack.pc - 1) - stack.byte_string_start));
1952
1953 /* Handy byte-codes for lexical binding. */
1954 CASE (Bstack_ref1):
1955 CASE (Bstack_ref2):
1956 CASE (Bstack_ref3):
1957 CASE (Bstack_ref4):
1958 CASE (Bstack_ref5):
1959 {
1960 Lisp_Object *ptr = top - (op - Bstack_ref);
1961 PUSH (*ptr);
1962 NEXT;
1963 }
1964 CASE (Bstack_ref6):
1965 {
1966 Lisp_Object *ptr = top - (FETCH);
1967 PUSH (*ptr);
1968 NEXT;
1969 }
1970 CASE (Bstack_ref7):
1971 {
1972 Lisp_Object *ptr = top - (FETCH2);
1973 PUSH (*ptr);
1974 NEXT;
1975 }
1976 CASE (Bstack_set):
1977 /* stack-set-0 = discard; stack-set-1 = discard-1-preserve-tos. */
1978 {
1979 Lisp_Object *ptr = top - (FETCH);
1980 *ptr = POP;
1981 NEXT;
1982 }
1983 CASE (Bstack_set2):
1984 {
1985 Lisp_Object *ptr = top - (FETCH2);
1986 *ptr = POP;
1987 NEXT;
1988 }
1989 CASE (BdiscardN):
1990 op = FETCH;
1991 if (op & 0x80)
1992 {
1993 op &= 0x7F;
1994 top[-op] = TOP;
1995 }
1996 DISCARD (op);
1997 NEXT;
1998
1999 CASE_DEFAULT
2000 CASE (Bconstant):
2001 #ifdef BYTE_CODE_SAFE
2002 if (op < Bconstant)
2003 {
2004 emacs_abort ();
2005 }
2006 if ((op -= Bconstant) >= const_length)
2007 {
2008 emacs_abort ();
2009 }
2010 PUSH (vectorp[op]);
2011 #else
2012 PUSH (vectorp[op - Bconstant]);
2013 #endif
2014 NEXT;
2015 }
2016 }
2017
2018 exit:
2019
2020 byte_stack_list = byte_stack_list->next;
2021
2022 /* Binds and unbinds are supposed to be compiled balanced. */
2023 if (SPECPDL_INDEX () != count)
2024 {
2025 if (SPECPDL_INDEX () > count)
2026 unbind_to (count, Qnil);
2027 error ("binding stack not balanced (serious byte compiler bug)");
2028 }
2029
2030 return result;
2031 }
2032
2033 void
2034 syms_of_bytecode (void)
2035 {
2036 defsubr (&Sbyte_code);
2037
2038 #ifdef BYTE_CODE_METER
2039
2040 DEFVAR_LISP ("byte-code-meter", Vbyte_code_meter,
2041 doc: /* A vector of vectors which holds a histogram of byte-code usage.
2042 \(aref (aref byte-code-meter 0) CODE) indicates how many times the byte
2043 opcode CODE has been executed.
2044 \(aref (aref byte-code-meter CODE1) CODE2), where CODE1 is not 0,
2045 indicates how many times the byte opcodes CODE1 and CODE2 have been
2046 executed in succession. */);
2047
2048 DEFVAR_BOOL ("byte-metering-on", byte_metering_on,
2049 doc: /* If non-nil, keep profiling information on byte code usage.
2050 The variable byte-code-meter indicates how often each byte opcode is used.
2051 If a symbol has a property named `byte-code-meter' whose value is an
2052 integer, it is incremented each time that symbol's function is called. */);
2053
2054 byte_metering_on = 0;
2055 Vbyte_code_meter = Fmake_vector (make_number (256), make_number (0));
2056 DEFSYM (Qbyte_code_meter, "byte-code-meter");
2057 {
2058 int i = 256;
2059 while (i--)
2060 ASET (Vbyte_code_meter, i,
2061 Fmake_vector (make_number (256), make_number (0)));
2062 }
2063 #endif
2064 }
Unnamed repository; edit this file 'description' to name the repository.