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