aboutsummaryrefslogtreecommitdiffstats
path: root/src/bytecode.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/bytecode.c')
-rw-r--r--src/bytecode.c1123
1 files changed, 623 insertions, 500 deletions
diff --git a/src/bytecode.c b/src/bytecode.c
index 3af0abd63cf..3267c7c8c76 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -1,5 +1,5 @@
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-2011 Free Software Foundation, Inc. 2 Copyright (C) 1985-1988, 1993, 2000-2012 Free Software Foundation, Inc.
3 3
4This file is part of GNU Emacs. 4This file is part of GNU Emacs.
5 5
@@ -33,10 +33,10 @@ by Hallvard:
33 */ 33 */
34 34
35#include <config.h> 35#include <config.h>
36#include <setjmp.h> 36
37#include "lisp.h" 37#include "lisp.h"
38#include "buffer.h"
39#include "character.h" 38#include "character.h"
39#include "buffer.h"
40#include "syntax.h" 40#include "syntax.h"
41#include "window.h" 41#include "window.h"
42 42
@@ -54,25 +54,33 @@ by Hallvard:
54/* #define BYTE_CODE_SAFE */ 54/* #define BYTE_CODE_SAFE */
55/* #define BYTE_CODE_METER */ 55/* #define BYTE_CODE_METER */
56 56
57/* If BYTE_CODE_THREADED is defined, then the interpreter will be
58 indirect threaded, using GCC's computed goto extension. This code,
59 as currently implemented, is incompatible with BYTE_CODE_SAFE and
60 BYTE_CODE_METER. */
61#if defined (__GNUC__) && !defined (BYTE_CODE_SAFE) && !defined (BYTE_CODE_METER)
62#define BYTE_CODE_THREADED
63#endif
64
57 65
58#ifdef BYTE_CODE_METER 66#ifdef BYTE_CODE_METER
59 67
60Lisp_Object Qbyte_code_meter; 68Lisp_Object Qbyte_code_meter;
61#define METER_2(code1, code2) \ 69#define METER_2(code1, code2) AREF (AREF (Vbyte_code_meter, code1), code2)
62 XFASTINT (XVECTOR (XVECTOR (Vbyte_code_meter)->contents[(code1)]) \ 70#define METER_1(code) METER_2 (0, code)
63 ->contents[(code2)])
64
65#define METER_1(code) METER_2 (0, (code))
66 71
67#define METER_CODE(last_code, this_code) \ 72#define METER_CODE(last_code, this_code) \
68{ \ 73{ \
69 if (byte_metering_on) \ 74 if (byte_metering_on) \
70 { \ 75 { \
71 if (METER_1 (this_code) < MOST_POSITIVE_FIXNUM) \ 76 if (XFASTINT (METER_1 (this_code)) < MOST_POSITIVE_FIXNUM) \
72 METER_1 (this_code)++; \ 77 XSETFASTINT (METER_1 (this_code), \
78 XFASTINT (METER_1 (this_code)) + 1); \
73 if (last_code \ 79 if (last_code \
74 && METER_2 (last_code, this_code) < MOST_POSITIVE_FIXNUM) \ 80 && (XFASTINT (METER_2 (last_code, this_code)) \
75 METER_2 (last_code, this_code)++; \ 81 < MOST_POSITIVE_FIXNUM)) \
82 XSETFASTINT (METER_2 (last_code, this_code), \
83 XFASTINT (METER_2 (last_code, this_code)) + 1); \
76 } \ 84 } \
77} 85}
78 86
@@ -83,158 +91,204 @@ Lisp_Object Qbytecode;
83 91
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
164#define Bforward_char 0165
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 292
239/* Whether to maintain a `top' and `bottom' field in the stack frame. */ 293/* Whether to maintain a `top' and `bottom' field in the stack frame. */
240#define BYTE_MAINTAIN_TOP (BYTE_CODE_SAFE || BYTE_MARK_STACK) 294#define BYTE_MAINTAIN_TOP (BYTE_CODE_SAFE || BYTE_MARK_STACK)
@@ -318,7 +372,7 @@ unmark_byte_stack (void)
318 { 372 {
319 if (stack->byte_string_start != SDATA (stack->byte_string)) 373 if (stack->byte_string_start != SDATA (stack->byte_string))
320 { 374 {
321 int offset = stack->pc - stack->byte_string_start; 375 ptrdiff_t offset = stack->pc - stack->byte_string_start;
322 stack->byte_string_start = SDATA (stack->byte_string); 376 stack->byte_string_start = SDATA (stack->byte_string);
323 stack->pc = stack->byte_string_start + offset; 377 stack->pc = stack->byte_string_start + offset;
324 } 378 }
@@ -369,15 +423,11 @@ unmark_byte_stack (void)
369/* Garbage collect if we have consed enough since the last time. 423/* Garbage collect if we have consed enough since the last time.
370 We do this at every branch, to avoid loops that never GC. */ 424 We do this at every branch, to avoid loops that never GC. */
371 425
372#define MAYBE_GC() \ 426#define MAYBE_GC() \
373 do { \ 427 do { \
374 if (consing_since_gc > gc_cons_threshold \ 428 BEFORE_POTENTIAL_GC (); \
375 && consing_since_gc > gc_relative_threshold) \ 429 maybe_gc (); \
376 { \ 430 AFTER_POTENTIAL_GC (); \
377 BEFORE_POTENTIAL_GC (); \
378 Fgarbage_collect (); \
379 AFTER_POTENTIAL_GC (); \
380 } \
381 } while (0) 431 } while (0)
382 432
383/* Check for jumping out of range. */ 433/* Check for jumping out of range. */
@@ -385,7 +435,7 @@ unmark_byte_stack (void)
385#ifdef BYTE_CODE_SAFE 435#ifdef BYTE_CODE_SAFE
386 436
387#define CHECK_RANGE(ARG) \ 437#define CHECK_RANGE(ARG) \
388 if (ARG >= bytestr_length) abort () 438 if (ARG >= bytestr_length) emacs_abort ()
389 439
390#else /* not BYTE_CODE_SAFE */ 440#else /* not BYTE_CODE_SAFE */
391 441
@@ -408,7 +458,8 @@ unmark_byte_stack (void)
408 Fsignal (Qquit, Qnil); \ 458 Fsignal (Qquit, Qnil); \
409 AFTER_POTENTIAL_GC (); \ 459 AFTER_POTENTIAL_GC (); \
410 } \ 460 } \
411 ELSE_PENDING_SIGNALS \ 461 else if (pending_signals) \
462 process_pending_signals (); \
412 } while (0) 463 } while (0)
413 464
414 465
@@ -435,7 +486,7 @@ Lisp_Object
435exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth, 486exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
436 Lisp_Object args_template, ptrdiff_t nargs, Lisp_Object *args) 487 Lisp_Object args_template, ptrdiff_t nargs, Lisp_Object *args)
437{ 488{
438 int count = SPECPDL_INDEX (); 489 ptrdiff_t count = SPECPDL_INDEX ();
439#ifdef BYTE_CODE_METER 490#ifdef BYTE_CODE_METER
440 int this_op = 0; 491 int this_op = 0;
441 int prev_op; 492 int prev_op;
@@ -446,7 +497,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
446#ifdef BYTE_CODE_SAFE 497#ifdef BYTE_CODE_SAFE
447 ptrdiff_t const_length; 498 ptrdiff_t const_length;
448 Lisp_Object *stacke; 499 Lisp_Object *stacke;
449 int bytestr_length; 500 ptrdiff_t bytestr_length;
450#endif 501#endif
451 struct byte_stack stack; 502 struct byte_stack stack;
452 Lisp_Object *top; 503 Lisp_Object *top;
@@ -458,7 +509,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
458 if (FRAME_X_P (f) 509 if (FRAME_X_P (f)
459 && FRAME_FONT (f)->direction != 0 510 && FRAME_FONT (f)->direction != 0
460 && FRAME_FONT (f)->direction != 1) 511 && FRAME_FONT (f)->direction != 1)
461 abort (); 512 emacs_abort ();
462 } 513 }
463#endif 514#endif
464 515
@@ -486,15 +537,13 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
486 stack.byte_string = bytestr; 537 stack.byte_string = bytestr;
487 stack.pc = stack.byte_string_start = SDATA (bytestr); 538 stack.pc = stack.byte_string_start = SDATA (bytestr);
488 stack.constants = vector; 539 stack.constants = vector;
489 if (min (PTRDIFF_MAX, SIZE_MAX) / sizeof (Lisp_Object) < XFASTINT (maxdepth)) 540 if (MAX_ALLOCA / word_size <= XFASTINT (maxdepth))
490 memory_full (SIZE_MAX); 541 memory_full (SIZE_MAX);
491 top = (Lisp_Object *) alloca (XFASTINT (maxdepth) 542 top = alloca ((XFASTINT (maxdepth) + 1) * sizeof *top);
492 * sizeof (Lisp_Object));
493#if BYTE_MAINTAIN_TOP 543#if BYTE_MAINTAIN_TOP
494 stack.bottom = top; 544 stack.bottom = top + 1;
495 stack.top = NULL; 545 stack.top = NULL;
496#endif 546#endif
497 top -= 1;
498 stack.next = byte_stack_list; 547 stack.next = byte_stack_list;
499 byte_stack_list = &stack; 548 byte_stack_list = &stack;
500 549
@@ -505,7 +554,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
505 if (INTEGERP (args_template)) 554 if (INTEGERP (args_template))
506 { 555 {
507 ptrdiff_t at = XINT (args_template); 556 ptrdiff_t at = XINT (args_template);
508 int rest = at & 128; 557 bool rest = (at & 128) != 0;
509 int mandatory = at & 127; 558 int mandatory = at & 127;
510 ptrdiff_t nonrest = at >> 8; 559 ptrdiff_t nonrest = at >> 8;
511 eassert (mandatory <= nonrest); 560 eassert (mandatory <= nonrest);
@@ -552,9 +601,9 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
552 { 601 {
553#ifdef BYTE_CODE_SAFE 602#ifdef BYTE_CODE_SAFE
554 if (top > stacke) 603 if (top > stacke)
555 abort (); 604 emacs_abort ();
556 else if (top < stack.bottom - 1) 605 else if (top < stack.bottom - 1)
557 abort (); 606 emacs_abort ();
558#endif 607#endif
559 608
560#ifdef BYTE_CODE_METER 609#ifdef BYTE_CODE_METER
@@ -562,27 +611,93 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
562 this_op = op = FETCH; 611 this_op = op = FETCH;
563 METER_CODE (prev_op, op); 612 METER_CODE (prev_op, op);
564#else 613#else
614#ifndef BYTE_CODE_THREADED
565 op = FETCH; 615 op = FETCH;
566#endif 616#endif
617#endif
618
619 /* The interpreter can be compiled one of two ways: as an
620 ordinary switch-based interpreter, or as a threaded
621 interpreter. The threaded interpreter relies on GCC's
622 computed goto extension, so it is not available everywhere.
623 Threading provides a performance boost. These macros are how
624 we allow the code to be compiled both ways. */
625#ifdef BYTE_CODE_THREADED
626 /* The CASE macro introduces an instruction's body. It is
627 either a label or a case label. */
628#define CASE(OP) insn_ ## OP
629 /* NEXT is invoked at the end of an instruction to go to the
630 next instruction. It is either a computed goto, or a
631 plain break. */
632#define NEXT goto *(targets[op = FETCH])
633 /* FIRST is like NEXT, but is only used at the start of the
634 interpreter body. In the switch-based interpreter it is the
635 switch, so the threaded definition must include a semicolon. */
636#define FIRST NEXT;
637 /* Most cases are labeled with the CASE macro, above.
638 CASE_DEFAULT is one exception; it is used if the interpreter
639 being built requires a default case. The threaded
640 interpreter does not, because the dispatch table is
641 completely filled. */
642#define CASE_DEFAULT
643 /* This introduces an instruction that is known to call abort. */
644#define CASE_ABORT CASE (Bstack_ref): CASE (default)
645#else
646 /* See above for the meaning of the various defines. */
647#define CASE(OP) case OP
648#define NEXT break
649#define FIRST switch (op)
650#define CASE_DEFAULT case 255: default:
651#define CASE_ABORT case 0
652#endif
653
654#ifdef BYTE_CODE_THREADED
655
656 /* A convenience define that saves us a lot of typing and makes
657 the table clearer. */
658#define LABEL(OP) [OP] = &&insn_ ## OP
659
660#if (__GNUC__ == 4 && 6 <= __GNUC_MINOR__) || 4 < __GNUC__
661# pragma GCC diagnostic push
662# pragma GCC diagnostic ignored "-Woverride-init"
663#endif
664
665 /* This is the dispatch table for the threaded interpreter. */
666 static const void *const targets[256] =
667 {
668 [0 ... (Bconstant - 1)] = &&insn_default,
669 [Bconstant ... 255] = &&insn_Bconstant,
670
671#define DEFINE(name, value) LABEL (name) ,
672 BYTE_CODES
673#undef DEFINE
674 };
675
676#if (__GNUC__ == 4 && 6 <= __GNUC_MINOR__) || 4 < __GNUC__
677# pragma GCC diagnostic pop
678#endif
679
680#endif
567 681
568 switch (op) 682
683 FIRST
569 { 684 {
570 case Bvarref + 7: 685 CASE (Bvarref7):
571 op = FETCH2; 686 op = FETCH2;
572 goto varref; 687 goto varref;
573 688
574 case Bvarref: 689 CASE (Bvarref):
575 case Bvarref + 1: 690 CASE (Bvarref1):
576 case Bvarref + 2: 691 CASE (Bvarref2):
577 case Bvarref + 3: 692 CASE (Bvarref3):
578 case Bvarref + 4: 693 CASE (Bvarref4):
579 case Bvarref + 5: 694 CASE (Bvarref5):
580 op = op - Bvarref; 695 op = op - Bvarref;
581 goto varref; 696 goto varref;
582 697
583 /* This seems to be the most frequently executed byte-code 698 /* This seems to be the most frequently executed byte-code
584 among the Bvarref's, so avoid a goto here. */ 699 among the Bvarref's, so avoid a goto here. */
585 case Bvarref+6: 700 CASE (Bvarref6):
586 op = FETCH; 701 op = FETCH;
587 varref: 702 varref:
588 { 703 {
@@ -607,10 +722,10 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
607 AFTER_POTENTIAL_GC (); 722 AFTER_POTENTIAL_GC ();
608 } 723 }
609 PUSH (v2); 724 PUSH (v2);
610 break; 725 NEXT;
611 } 726 }
612 727
613 case Bgotoifnil: 728 CASE (Bgotoifnil):
614 { 729 {
615 Lisp_Object v1; 730 Lisp_Object v1;
616 MAYBE_GC (); 731 MAYBE_GC ();
@@ -622,10 +737,10 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
622 CHECK_RANGE (op); 737 CHECK_RANGE (op);
623 stack.pc = stack.byte_string_start + op; 738 stack.pc = stack.byte_string_start + op;
624 } 739 }
625 break; 740 NEXT;
626 } 741 }
627 742
628 case Bcar: 743 CASE (Bcar):
629 { 744 {
630 Lisp_Object v1; 745 Lisp_Object v1;
631 v1 = TOP; 746 v1 = TOP;
@@ -639,28 +754,28 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
639 wrong_type_argument (Qlistp, v1); 754 wrong_type_argument (Qlistp, v1);
640 AFTER_POTENTIAL_GC (); 755 AFTER_POTENTIAL_GC ();
641 } 756 }
642 break; 757 NEXT;
643 } 758 }
644 759
645 case Beq: 760 CASE (Beq):
646 { 761 {
647 Lisp_Object v1; 762 Lisp_Object v1;
648 v1 = POP; 763 v1 = POP;
649 TOP = EQ (v1, TOP) ? Qt : Qnil; 764 TOP = EQ (v1, TOP) ? Qt : Qnil;
650 break; 765 NEXT;
651 } 766 }
652 767
653 case Bmemq: 768 CASE (Bmemq):
654 { 769 {
655 Lisp_Object v1; 770 Lisp_Object v1;
656 BEFORE_POTENTIAL_GC (); 771 BEFORE_POTENTIAL_GC ();
657 v1 = POP; 772 v1 = POP;
658 TOP = Fmemq (TOP, v1); 773 TOP = Fmemq (TOP, v1);
659 AFTER_POTENTIAL_GC (); 774 AFTER_POTENTIAL_GC ();
660 break; 775 NEXT;
661 } 776 }
662 777
663 case Bcdr: 778 CASE (Bcdr):
664 { 779 {
665 Lisp_Object v1; 780 Lisp_Object v1;
666 v1 = TOP; 781 v1 = TOP;
@@ -674,24 +789,23 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
674 wrong_type_argument (Qlistp, v1); 789 wrong_type_argument (Qlistp, v1);
675 AFTER_POTENTIAL_GC (); 790 AFTER_POTENTIAL_GC ();
676 } 791 }
677 break; 792 NEXT;
678 break;
679 } 793 }
680 794
681 case Bvarset: 795 CASE (Bvarset):
682 case Bvarset+1: 796 CASE (Bvarset1):
683 case Bvarset+2: 797 CASE (Bvarset2):
684 case Bvarset+3: 798 CASE (Bvarset3):
685 case Bvarset+4: 799 CASE (Bvarset4):
686 case Bvarset+5: 800 CASE (Bvarset5):
687 op -= Bvarset; 801 op -= Bvarset;
688 goto varset; 802 goto varset;
689 803
690 case Bvarset+7: 804 CASE (Bvarset7):
691 op = FETCH2; 805 op = FETCH2;
692 goto varset; 806 goto varset;
693 807
694 case Bvarset+6: 808 CASE (Bvarset6):
695 op = FETCH; 809 op = FETCH;
696 varset: 810 varset:
697 { 811 {
@@ -705,7 +819,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
705 && !EQ (val, Qunbound) 819 && !EQ (val, Qunbound)
706 && !XSYMBOL (sym)->redirect 820 && !XSYMBOL (sym)->redirect
707 && !SYMBOL_CONSTANT_P (sym)) 821 && !SYMBOL_CONSTANT_P (sym))
708 XSYMBOL (sym)->val.value = val; 822 SET_SYMBOL_VAL (XSYMBOL (sym), val);
709 else 823 else
710 { 824 {
711 BEFORE_POTENTIAL_GC (); 825 BEFORE_POTENTIAL_GC ();
@@ -714,54 +828,54 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
714 } 828 }
715 } 829 }
716 (void) POP; 830 (void) POP;
717 break; 831 NEXT;
718 832
719 case Bdup: 833 CASE (Bdup):
720 { 834 {
721 Lisp_Object v1; 835 Lisp_Object v1;
722 v1 = TOP; 836 v1 = TOP;
723 PUSH (v1); 837 PUSH (v1);
724 break; 838 NEXT;
725 } 839 }
726 840
727 /* ------------------ */ 841 /* ------------------ */
728 842
729 case Bvarbind+6: 843 CASE (Bvarbind6):
730 op = FETCH; 844 op = FETCH;
731 goto varbind; 845 goto varbind;
732 846
733 case Bvarbind+7: 847 CASE (Bvarbind7):
734 op = FETCH2; 848 op = FETCH2;
735 goto varbind; 849 goto varbind;
736 850
737 case Bvarbind: 851 CASE (Bvarbind):
738 case Bvarbind+1: 852 CASE (Bvarbind1):
739 case Bvarbind+2: 853 CASE (Bvarbind2):
740 case Bvarbind+3: 854 CASE (Bvarbind3):
741 case Bvarbind+4: 855 CASE (Bvarbind4):
742 case Bvarbind+5: 856 CASE (Bvarbind5):
743 op -= Bvarbind; 857 op -= Bvarbind;
744 varbind: 858 varbind:
745 /* Specbind can signal and thus GC. */ 859 /* Specbind can signal and thus GC. */
746 BEFORE_POTENTIAL_GC (); 860 BEFORE_POTENTIAL_GC ();
747 specbind (vectorp[op], POP); 861 specbind (vectorp[op], POP);
748 AFTER_POTENTIAL_GC (); 862 AFTER_POTENTIAL_GC ();
749 break; 863 NEXT;
750 864
751 case Bcall+6: 865 CASE (Bcall6):
752 op = FETCH; 866 op = FETCH;
753 goto docall; 867 goto docall;
754 868
755 case Bcall+7: 869 CASE (Bcall7):
756 op = FETCH2; 870 op = FETCH2;
757 goto docall; 871 goto docall;
758 872
759 case Bcall: 873 CASE (Bcall):
760 case Bcall+1: 874 CASE (Bcall1):
761 case Bcall+2: 875 CASE (Bcall2):
762 case Bcall+3: 876 CASE (Bcall3):
763 case Bcall+4: 877 CASE (Bcall4):
764 case Bcall+5: 878 CASE (Bcall5):
765 op -= Bcall; 879 op -= Bcall;
766 docall: 880 docall:
767 { 881 {
@@ -784,47 +898,47 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
784#endif 898#endif
785 TOP = Ffuncall (op + 1, &TOP); 899 TOP = Ffuncall (op + 1, &TOP);
786 AFTER_POTENTIAL_GC (); 900 AFTER_POTENTIAL_GC ();
787 break; 901 NEXT;
788 } 902 }
789 903
790 case Bunbind+6: 904 CASE (Bunbind6):
791 op = FETCH; 905 op = FETCH;
792 goto dounbind; 906 goto dounbind;
793 907
794 case Bunbind+7: 908 CASE (Bunbind7):
795 op = FETCH2; 909 op = FETCH2;
796 goto dounbind; 910 goto dounbind;
797 911
798 case Bunbind: 912 CASE (Bunbind):
799 case Bunbind+1: 913 CASE (Bunbind1):
800 case Bunbind+2: 914 CASE (Bunbind2):
801 case Bunbind+3: 915 CASE (Bunbind3):
802 case Bunbind+4: 916 CASE (Bunbind4):
803 case Bunbind+5: 917 CASE (Bunbind5):
804 op -= Bunbind; 918 op -= Bunbind;
805 dounbind: 919 dounbind:
806 BEFORE_POTENTIAL_GC (); 920 BEFORE_POTENTIAL_GC ();
807 unbind_to (SPECPDL_INDEX () - op, Qnil); 921 unbind_to (SPECPDL_INDEX () - op, Qnil);
808 AFTER_POTENTIAL_GC (); 922 AFTER_POTENTIAL_GC ();
809 break; 923 NEXT;
810 924
811 case Bunbind_all: /* Obsolete. Never used. */ 925 CASE (Bunbind_all): /* Obsolete. Never used. */
812 /* To unbind back to the beginning of this frame. Not used yet, 926 /* To unbind back to the beginning of this frame. Not used yet,
813 but will be needed for tail-recursion elimination. */ 927 but will be needed for tail-recursion elimination. */
814 BEFORE_POTENTIAL_GC (); 928 BEFORE_POTENTIAL_GC ();
815 unbind_to (count, Qnil); 929 unbind_to (count, Qnil);
816 AFTER_POTENTIAL_GC (); 930 AFTER_POTENTIAL_GC ();
817 break; 931 NEXT;
818 932
819 case Bgoto: 933 CASE (Bgoto):
820 MAYBE_GC (); 934 MAYBE_GC ();
821 BYTE_CODE_QUIT; 935 BYTE_CODE_QUIT;
822 op = FETCH2; /* pc = FETCH2 loses since FETCH2 contains pc++ */ 936 op = FETCH2; /* pc = FETCH2 loses since FETCH2 contains pc++ */
823 CHECK_RANGE (op); 937 CHECK_RANGE (op);
824 stack.pc = stack.byte_string_start + op; 938 stack.pc = stack.byte_string_start + op;
825 break; 939 NEXT;
826 940
827 case Bgotoifnonnil: 941 CASE (Bgotoifnonnil):
828 { 942 {
829 Lisp_Object v1; 943 Lisp_Object v1;
830 MAYBE_GC (); 944 MAYBE_GC ();
@@ -836,10 +950,10 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
836 CHECK_RANGE (op); 950 CHECK_RANGE (op);
837 stack.pc = stack.byte_string_start + op; 951 stack.pc = stack.byte_string_start + op;
838 } 952 }
839 break; 953 NEXT;
840 } 954 }
841 955
842 case Bgotoifnilelsepop: 956 CASE (Bgotoifnilelsepop):
843 MAYBE_GC (); 957 MAYBE_GC ();
844 op = FETCH2; 958 op = FETCH2;
845 if (NILP (TOP)) 959 if (NILP (TOP))
@@ -849,9 +963,9 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
849 stack.pc = stack.byte_string_start + op; 963 stack.pc = stack.byte_string_start + op;
850 } 964 }
851 else DISCARD (1); 965 else DISCARD (1);
852 break; 966 NEXT;
853 967
854 case Bgotoifnonnilelsepop: 968 CASE (Bgotoifnonnilelsepop):
855 MAYBE_GC (); 969 MAYBE_GC ();
856 op = FETCH2; 970 op = FETCH2;
857 if (!NILP (TOP)) 971 if (!NILP (TOP))
@@ -861,15 +975,15 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
861 stack.pc = stack.byte_string_start + op; 975 stack.pc = stack.byte_string_start + op;
862 } 976 }
863 else DISCARD (1); 977 else DISCARD (1);
864 break; 978 NEXT;
865 979
866 case BRgoto: 980 CASE (BRgoto):
867 MAYBE_GC (); 981 MAYBE_GC ();
868 BYTE_CODE_QUIT; 982 BYTE_CODE_QUIT;
869 stack.pc += (int) *stack.pc - 127; 983 stack.pc += (int) *stack.pc - 127;
870 break; 984 NEXT;
871 985
872 case BRgotoifnil: 986 CASE (BRgotoifnil):
873 { 987 {
874 Lisp_Object v1; 988 Lisp_Object v1;
875 MAYBE_GC (); 989 MAYBE_GC ();
@@ -880,10 +994,10 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
880 stack.pc += (int) *stack.pc - 128; 994 stack.pc += (int) *stack.pc - 128;
881 } 995 }
882 stack.pc++; 996 stack.pc++;
883 break; 997 NEXT;
884 } 998 }
885 999
886 case BRgotoifnonnil: 1000 CASE (BRgotoifnonnil):
887 { 1001 {
888 Lisp_Object v1; 1002 Lisp_Object v1;
889 MAYBE_GC (); 1003 MAYBE_GC ();
@@ -894,10 +1008,10 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
894 stack.pc += (int) *stack.pc - 128; 1008 stack.pc += (int) *stack.pc - 128;
895 } 1009 }
896 stack.pc++; 1010 stack.pc++;
897 break; 1011 NEXT;
898 } 1012 }
899 1013
900 case BRgotoifnilelsepop: 1014 CASE (BRgotoifnilelsepop):
901 MAYBE_GC (); 1015 MAYBE_GC ();
902 op = *stack.pc++; 1016 op = *stack.pc++;
903 if (NILP (TOP)) 1017 if (NILP (TOP))
@@ -906,9 +1020,9 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
906 stack.pc += op - 128; 1020 stack.pc += op - 128;
907 } 1021 }
908 else DISCARD (1); 1022 else DISCARD (1);
909 break; 1023 NEXT;
910 1024
911 case BRgotoifnonnilelsepop: 1025 CASE (BRgotoifnonnilelsepop):
912 MAYBE_GC (); 1026 MAYBE_GC ();
913 op = *stack.pc++; 1027 op = *stack.pc++;
914 if (!NILP (TOP)) 1028 if (!NILP (TOP))
@@ -917,62 +1031,62 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
917 stack.pc += op - 128; 1031 stack.pc += op - 128;
918 } 1032 }
919 else DISCARD (1); 1033 else DISCARD (1);
920 break; 1034 NEXT;
921 1035
922 case Breturn: 1036 CASE (Breturn):
923 result = POP; 1037 result = POP;
924 goto exit; 1038 goto exit;
925 1039
926 case Bdiscard: 1040 CASE (Bdiscard):
927 DISCARD (1); 1041 DISCARD (1);
928 break; 1042 NEXT;
929 1043
930 case Bconstant2: 1044 CASE (Bconstant2):
931 PUSH (vectorp[FETCH2]); 1045 PUSH (vectorp[FETCH2]);
932 break; 1046 NEXT;
933 1047
934 case Bsave_excursion: 1048 CASE (Bsave_excursion):
935 record_unwind_protect (save_excursion_restore, 1049 record_unwind_protect (save_excursion_restore,
936 save_excursion_save ()); 1050 save_excursion_save ());
937 break; 1051 NEXT;
938 1052
939 case Bsave_current_buffer: /* Obsolete since ??. */ 1053 CASE (Bsave_current_buffer): /* Obsolete since ??. */
940 case Bsave_current_buffer_1: 1054 CASE (Bsave_current_buffer_1):
941 record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ()); 1055 record_unwind_current_buffer ();
942 break; 1056 NEXT;
943 1057
944 case Bsave_window_excursion: /* Obsolete since 24.1. */ 1058 CASE (Bsave_window_excursion): /* Obsolete since 24.1. */
945 { 1059 {
946 register int count1 = SPECPDL_INDEX (); 1060 register ptrdiff_t count1 = SPECPDL_INDEX ();
947 record_unwind_protect (Fset_window_configuration, 1061 record_unwind_protect (Fset_window_configuration,
948 Fcurrent_window_configuration (Qnil)); 1062 Fcurrent_window_configuration (Qnil));
949 BEFORE_POTENTIAL_GC (); 1063 BEFORE_POTENTIAL_GC ();
950 TOP = Fprogn (TOP); 1064 TOP = Fprogn (TOP);
951 unbind_to (count1, TOP); 1065 unbind_to (count1, TOP);
952 AFTER_POTENTIAL_GC (); 1066 AFTER_POTENTIAL_GC ();
953 break; 1067 NEXT;
954 } 1068 }
955 1069
956 case Bsave_restriction: 1070 CASE (Bsave_restriction):
957 record_unwind_protect (save_restriction_restore, 1071 record_unwind_protect (save_restriction_restore,
958 save_restriction_save ()); 1072 save_restriction_save ());
959 break; 1073 NEXT;
960 1074
961 case Bcatch: /* FIXME: ill-suited for lexbind. */ 1075 CASE (Bcatch): /* FIXME: ill-suited for lexbind. */
962 { 1076 {
963 Lisp_Object v1; 1077 Lisp_Object v1;
964 BEFORE_POTENTIAL_GC (); 1078 BEFORE_POTENTIAL_GC ();
965 v1 = POP; 1079 v1 = POP;
966 TOP = internal_catch (TOP, eval_sub, v1); 1080 TOP = internal_catch (TOP, eval_sub, v1);
967 AFTER_POTENTIAL_GC (); 1081 AFTER_POTENTIAL_GC ();
968 break; 1082 NEXT;
969 } 1083 }
970 1084
971 case Bunwind_protect: /* FIXME: avoid closure for lexbind. */ 1085 CASE (Bunwind_protect): /* FIXME: avoid closure for lexbind. */
972 record_unwind_protect (Fprogn, POP); 1086 record_unwind_protect (Fprogn, POP);
973 break; 1087 NEXT;
974 1088
975 case Bcondition_case: /* FIXME: ill-suited for lexbind. */ 1089 CASE (Bcondition_case): /* FIXME: ill-suited for lexbind. */
976 { 1090 {
977 Lisp_Object handlers, body; 1091 Lisp_Object handlers, body;
978 handlers = POP; 1092 handlers = POP;
@@ -980,18 +1094,18 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
980 BEFORE_POTENTIAL_GC (); 1094 BEFORE_POTENTIAL_GC ();
981 TOP = internal_lisp_condition_case (TOP, body, handlers); 1095 TOP = internal_lisp_condition_case (TOP, body, handlers);
982 AFTER_POTENTIAL_GC (); 1096 AFTER_POTENTIAL_GC ();
983 break; 1097 NEXT;
984 } 1098 }
985 1099
986 case Btemp_output_buffer_setup: /* Obsolete since 24.1. */ 1100 CASE (Btemp_output_buffer_setup): /* Obsolete since 24.1. */
987 BEFORE_POTENTIAL_GC (); 1101 BEFORE_POTENTIAL_GC ();
988 CHECK_STRING (TOP); 1102 CHECK_STRING (TOP);
989 temp_output_buffer_setup (SSDATA (TOP)); 1103 temp_output_buffer_setup (SSDATA (TOP));
990 AFTER_POTENTIAL_GC (); 1104 AFTER_POTENTIAL_GC ();
991 TOP = Vstandard_output; 1105 TOP = Vstandard_output;
992 break; 1106 NEXT;
993 1107
994 case Btemp_output_buffer_show: /* Obsolete since 24.1. */ 1108 CASE (Btemp_output_buffer_show): /* Obsolete since 24.1. */
995 { 1109 {
996 Lisp_Object v1; 1110 Lisp_Object v1;
997 BEFORE_POTENTIAL_GC (); 1111 BEFORE_POTENTIAL_GC ();
@@ -1001,190 +1115,191 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
1001 /* pop binding of standard-output */ 1115 /* pop binding of standard-output */
1002 unbind_to (SPECPDL_INDEX () - 1, Qnil); 1116 unbind_to (SPECPDL_INDEX () - 1, Qnil);
1003 AFTER_POTENTIAL_GC (); 1117 AFTER_POTENTIAL_GC ();
1004 break; 1118 NEXT;
1005 } 1119 }
1006 1120
1007 case Bnth: 1121 CASE (Bnth):
1008 { 1122 {
1009 Lisp_Object v1, v2; 1123 Lisp_Object v1, v2;
1124 EMACS_INT n;
1010 BEFORE_POTENTIAL_GC (); 1125 BEFORE_POTENTIAL_GC ();
1011 v1 = POP; 1126 v1 = POP;
1012 v2 = TOP; 1127 v2 = TOP;
1013 CHECK_NUMBER (v2); 1128 CHECK_NUMBER (v2);
1014 op = XINT (v2); 1129 n = XINT (v2);
1015 immediate_quit = 1; 1130 immediate_quit = 1;
1016 while (--op >= 0 && CONSP (v1)) 1131 while (--n >= 0 && CONSP (v1))
1017 v1 = XCDR (v1); 1132 v1 = XCDR (v1);
1018 immediate_quit = 0; 1133 immediate_quit = 0;
1019 TOP = CAR (v1); 1134 TOP = CAR (v1);
1020 AFTER_POTENTIAL_GC (); 1135 AFTER_POTENTIAL_GC ();
1021 break; 1136 NEXT;
1022 } 1137 }
1023 1138
1024 case Bsymbolp: 1139 CASE (Bsymbolp):
1025 TOP = SYMBOLP (TOP) ? Qt : Qnil; 1140 TOP = SYMBOLP (TOP) ? Qt : Qnil;
1026 break; 1141 NEXT;
1027 1142
1028 case Bconsp: 1143 CASE (Bconsp):
1029 TOP = CONSP (TOP) ? Qt : Qnil; 1144 TOP = CONSP (TOP) ? Qt : Qnil;
1030 break; 1145 NEXT;
1031 1146
1032 case Bstringp: 1147 CASE (Bstringp):
1033 TOP = STRINGP (TOP) ? Qt : Qnil; 1148 TOP = STRINGP (TOP) ? Qt : Qnil;
1034 break; 1149 NEXT;
1035 1150
1036 case Blistp: 1151 CASE (Blistp):
1037 TOP = CONSP (TOP) || NILP (TOP) ? Qt : Qnil; 1152 TOP = CONSP (TOP) || NILP (TOP) ? Qt : Qnil;
1038 break; 1153 NEXT;
1039 1154
1040 case Bnot: 1155 CASE (Bnot):
1041 TOP = NILP (TOP) ? Qt : Qnil; 1156 TOP = NILP (TOP) ? Qt : Qnil;
1042 break; 1157 NEXT;
1043 1158
1044 case Bcons: 1159 CASE (Bcons):
1045 { 1160 {
1046 Lisp_Object v1; 1161 Lisp_Object v1;
1047 v1 = POP; 1162 v1 = POP;
1048 TOP = Fcons (TOP, v1); 1163 TOP = Fcons (TOP, v1);
1049 break; 1164 NEXT;
1050 } 1165 }
1051 1166
1052 case Blist1: 1167 CASE (Blist1):
1053 TOP = Fcons (TOP, Qnil); 1168 TOP = Fcons (TOP, Qnil);
1054 break; 1169 NEXT;
1055 1170
1056 case Blist2: 1171 CASE (Blist2):
1057 { 1172 {
1058 Lisp_Object v1; 1173 Lisp_Object v1;
1059 v1 = POP; 1174 v1 = POP;
1060 TOP = Fcons (TOP, Fcons (v1, Qnil)); 1175 TOP = Fcons (TOP, Fcons (v1, Qnil));
1061 break; 1176 NEXT;
1062 } 1177 }
1063 1178
1064 case Blist3: 1179 CASE (Blist3):
1065 DISCARD (2); 1180 DISCARD (2);
1066 TOP = Flist (3, &TOP); 1181 TOP = Flist (3, &TOP);
1067 break; 1182 NEXT;
1068 1183
1069 case Blist4: 1184 CASE (Blist4):
1070 DISCARD (3); 1185 DISCARD (3);
1071 TOP = Flist (4, &TOP); 1186 TOP = Flist (4, &TOP);
1072 break; 1187 NEXT;
1073 1188
1074 case BlistN: 1189 CASE (BlistN):
1075 op = FETCH; 1190 op = FETCH;
1076 DISCARD (op - 1); 1191 DISCARD (op - 1);
1077 TOP = Flist (op, &TOP); 1192 TOP = Flist (op, &TOP);
1078 break; 1193 NEXT;
1079 1194
1080 case Blength: 1195 CASE (Blength):
1081 BEFORE_POTENTIAL_GC (); 1196 BEFORE_POTENTIAL_GC ();
1082 TOP = Flength (TOP); 1197 TOP = Flength (TOP);
1083 AFTER_POTENTIAL_GC (); 1198 AFTER_POTENTIAL_GC ();
1084 break; 1199 NEXT;
1085 1200
1086 case Baref: 1201 CASE (Baref):
1087 { 1202 {
1088 Lisp_Object v1; 1203 Lisp_Object v1;
1089 BEFORE_POTENTIAL_GC (); 1204 BEFORE_POTENTIAL_GC ();
1090 v1 = POP; 1205 v1 = POP;
1091 TOP = Faref (TOP, v1); 1206 TOP = Faref (TOP, v1);
1092 AFTER_POTENTIAL_GC (); 1207 AFTER_POTENTIAL_GC ();
1093 break; 1208 NEXT;
1094 } 1209 }
1095 1210
1096 case Baset: 1211 CASE (Baset):
1097 { 1212 {
1098 Lisp_Object v1, v2; 1213 Lisp_Object v1, v2;
1099 BEFORE_POTENTIAL_GC (); 1214 BEFORE_POTENTIAL_GC ();
1100 v2 = POP; v1 = POP; 1215 v2 = POP; v1 = POP;
1101 TOP = Faset (TOP, v1, v2); 1216 TOP = Faset (TOP, v1, v2);
1102 AFTER_POTENTIAL_GC (); 1217 AFTER_POTENTIAL_GC ();
1103 break; 1218 NEXT;
1104 } 1219 }
1105 1220
1106 case Bsymbol_value: 1221 CASE (Bsymbol_value):
1107 BEFORE_POTENTIAL_GC (); 1222 BEFORE_POTENTIAL_GC ();
1108 TOP = Fsymbol_value (TOP); 1223 TOP = Fsymbol_value (TOP);
1109 AFTER_POTENTIAL_GC (); 1224 AFTER_POTENTIAL_GC ();
1110 break; 1225 NEXT;
1111 1226
1112 case Bsymbol_function: 1227 CASE (Bsymbol_function):
1113 BEFORE_POTENTIAL_GC (); 1228 BEFORE_POTENTIAL_GC ();
1114 TOP = Fsymbol_function (TOP); 1229 TOP = Fsymbol_function (TOP);
1115 AFTER_POTENTIAL_GC (); 1230 AFTER_POTENTIAL_GC ();
1116 break; 1231 NEXT;
1117 1232
1118 case Bset: 1233 CASE (Bset):
1119 { 1234 {
1120 Lisp_Object v1; 1235 Lisp_Object v1;
1121 BEFORE_POTENTIAL_GC (); 1236 BEFORE_POTENTIAL_GC ();
1122 v1 = POP; 1237 v1 = POP;
1123 TOP = Fset (TOP, v1); 1238 TOP = Fset (TOP, v1);
1124 AFTER_POTENTIAL_GC (); 1239 AFTER_POTENTIAL_GC ();
1125 break; 1240 NEXT;
1126 } 1241 }
1127 1242
1128 case Bfset: 1243 CASE (Bfset):
1129 { 1244 {
1130 Lisp_Object v1; 1245 Lisp_Object v1;
1131 BEFORE_POTENTIAL_GC (); 1246 BEFORE_POTENTIAL_GC ();
1132 v1 = POP; 1247 v1 = POP;
1133 TOP = Ffset (TOP, v1); 1248 TOP = Ffset (TOP, v1);
1134 AFTER_POTENTIAL_GC (); 1249 AFTER_POTENTIAL_GC ();
1135 break; 1250 NEXT;
1136 } 1251 }
1137 1252
1138 case Bget: 1253 CASE (Bget):
1139 { 1254 {
1140 Lisp_Object v1; 1255 Lisp_Object v1;
1141 BEFORE_POTENTIAL_GC (); 1256 BEFORE_POTENTIAL_GC ();
1142 v1 = POP; 1257 v1 = POP;
1143 TOP = Fget (TOP, v1); 1258 TOP = Fget (TOP, v1);
1144 AFTER_POTENTIAL_GC (); 1259 AFTER_POTENTIAL_GC ();
1145 break; 1260 NEXT;
1146 } 1261 }
1147 1262
1148 case Bsubstring: 1263 CASE (Bsubstring):
1149 { 1264 {
1150 Lisp_Object v1, v2; 1265 Lisp_Object v1, v2;
1151 BEFORE_POTENTIAL_GC (); 1266 BEFORE_POTENTIAL_GC ();
1152 v2 = POP; v1 = POP; 1267 v2 = POP; v1 = POP;
1153 TOP = Fsubstring (TOP, v1, v2); 1268 TOP = Fsubstring (TOP, v1, v2);
1154 AFTER_POTENTIAL_GC (); 1269 AFTER_POTENTIAL_GC ();
1155 break; 1270 NEXT;
1156 } 1271 }
1157 1272
1158 case Bconcat2: 1273 CASE (Bconcat2):
1159 BEFORE_POTENTIAL_GC (); 1274 BEFORE_POTENTIAL_GC ();
1160 DISCARD (1); 1275 DISCARD (1);
1161 TOP = Fconcat (2, &TOP); 1276 TOP = Fconcat (2, &TOP);
1162 AFTER_POTENTIAL_GC (); 1277 AFTER_POTENTIAL_GC ();
1163 break; 1278 NEXT;
1164 1279
1165 case Bconcat3: 1280 CASE (Bconcat3):
1166 BEFORE_POTENTIAL_GC (); 1281 BEFORE_POTENTIAL_GC ();
1167 DISCARD (2); 1282 DISCARD (2);
1168 TOP = Fconcat (3, &TOP); 1283 TOP = Fconcat (3, &TOP);
1169 AFTER_POTENTIAL_GC (); 1284 AFTER_POTENTIAL_GC ();
1170 break; 1285 NEXT;
1171 1286
1172 case Bconcat4: 1287 CASE (Bconcat4):
1173 BEFORE_POTENTIAL_GC (); 1288 BEFORE_POTENTIAL_GC ();
1174 DISCARD (3); 1289 DISCARD (3);
1175 TOP = Fconcat (4, &TOP); 1290 TOP = Fconcat (4, &TOP);
1176 AFTER_POTENTIAL_GC (); 1291 AFTER_POTENTIAL_GC ();
1177 break; 1292 NEXT;
1178 1293
1179 case BconcatN: 1294 CASE (BconcatN):
1180 op = FETCH; 1295 op = FETCH;
1181 BEFORE_POTENTIAL_GC (); 1296 BEFORE_POTENTIAL_GC ();
1182 DISCARD (op - 1); 1297 DISCARD (op - 1);
1183 TOP = Fconcat (op, &TOP); 1298 TOP = Fconcat (op, &TOP);
1184 AFTER_POTENTIAL_GC (); 1299 AFTER_POTENTIAL_GC ();
1185 break; 1300 NEXT;
1186 1301
1187 case Bsub1: 1302 CASE (Bsub1):
1188 { 1303 {
1189 Lisp_Object v1; 1304 Lisp_Object v1;
1190 v1 = TOP; 1305 v1 = TOP;
@@ -1199,10 +1314,10 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
1199 TOP = Fsub1 (v1); 1314 TOP = Fsub1 (v1);
1200 AFTER_POTENTIAL_GC (); 1315 AFTER_POTENTIAL_GC ();
1201 } 1316 }
1202 break; 1317 NEXT;
1203 } 1318 }
1204 1319
1205 case Badd1: 1320 CASE (Badd1):
1206 { 1321 {
1207 Lisp_Object v1; 1322 Lisp_Object v1;
1208 v1 = TOP; 1323 v1 = TOP;
@@ -1217,10 +1332,10 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
1217 TOP = Fadd1 (v1); 1332 TOP = Fadd1 (v1);
1218 AFTER_POTENTIAL_GC (); 1333 AFTER_POTENTIAL_GC ();
1219 } 1334 }
1220 break; 1335 NEXT;
1221 } 1336 }
1222 1337
1223 case Beqlsign: 1338 CASE (Beqlsign):
1224 { 1339 {
1225 Lisp_Object v1, v2; 1340 Lisp_Object v1, v2;
1226 BEFORE_POTENTIAL_GC (); 1341 BEFORE_POTENTIAL_GC ();
@@ -1238,57 +1353,57 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
1238 } 1353 }
1239 else 1354 else
1240 TOP = (XINT (v1) == XINT (v2) ? Qt : Qnil); 1355 TOP = (XINT (v1) == XINT (v2) ? Qt : Qnil);
1241 break; 1356 NEXT;
1242 } 1357 }
1243 1358
1244 case Bgtr: 1359 CASE (Bgtr):
1245 { 1360 {
1246 Lisp_Object v1; 1361 Lisp_Object v1;
1247 BEFORE_POTENTIAL_GC (); 1362 BEFORE_POTENTIAL_GC ();
1248 v1 = POP; 1363 v1 = POP;
1249 TOP = Fgtr (TOP, v1); 1364 TOP = Fgtr (TOP, v1);
1250 AFTER_POTENTIAL_GC (); 1365 AFTER_POTENTIAL_GC ();
1251 break; 1366 NEXT;
1252 } 1367 }
1253 1368
1254 case Blss: 1369 CASE (Blss):
1255 { 1370 {
1256 Lisp_Object v1; 1371 Lisp_Object v1;
1257 BEFORE_POTENTIAL_GC (); 1372 BEFORE_POTENTIAL_GC ();
1258 v1 = POP; 1373 v1 = POP;
1259 TOP = Flss (TOP, v1); 1374 TOP = Flss (TOP, v1);
1260 AFTER_POTENTIAL_GC (); 1375 AFTER_POTENTIAL_GC ();
1261 break; 1376 NEXT;
1262 } 1377 }
1263 1378
1264 case Bleq: 1379 CASE (Bleq):
1265 { 1380 {
1266 Lisp_Object v1; 1381 Lisp_Object v1;
1267 BEFORE_POTENTIAL_GC (); 1382 BEFORE_POTENTIAL_GC ();
1268 v1 = POP; 1383 v1 = POP;
1269 TOP = Fleq (TOP, v1); 1384 TOP = Fleq (TOP, v1);
1270 AFTER_POTENTIAL_GC (); 1385 AFTER_POTENTIAL_GC ();
1271 break; 1386 NEXT;
1272 } 1387 }
1273 1388
1274 case Bgeq: 1389 CASE (Bgeq):
1275 { 1390 {
1276 Lisp_Object v1; 1391 Lisp_Object v1;
1277 BEFORE_POTENTIAL_GC (); 1392 BEFORE_POTENTIAL_GC ();
1278 v1 = POP; 1393 v1 = POP;
1279 TOP = Fgeq (TOP, v1); 1394 TOP = Fgeq (TOP, v1);
1280 AFTER_POTENTIAL_GC (); 1395 AFTER_POTENTIAL_GC ();
1281 break; 1396 NEXT;
1282 } 1397 }
1283 1398
1284 case Bdiff: 1399 CASE (Bdiff):
1285 BEFORE_POTENTIAL_GC (); 1400 BEFORE_POTENTIAL_GC ();
1286 DISCARD (1); 1401 DISCARD (1);
1287 TOP = Fminus (2, &TOP); 1402 TOP = Fminus (2, &TOP);
1288 AFTER_POTENTIAL_GC (); 1403 AFTER_POTENTIAL_GC ();
1289 break; 1404 NEXT;
1290 1405
1291 case Bnegate: 1406 CASE (Bnegate):
1292 { 1407 {
1293 Lisp_Object v1; 1408 Lisp_Object v1;
1294 v1 = TOP; 1409 v1 = TOP;
@@ -1303,209 +1418,211 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
1303 TOP = Fminus (1, &TOP); 1418 TOP = Fminus (1, &TOP);
1304 AFTER_POTENTIAL_GC (); 1419 AFTER_POTENTIAL_GC ();
1305 } 1420 }
1306 break; 1421 NEXT;
1307 } 1422 }
1308 1423
1309 case Bplus: 1424 CASE (Bplus):
1310 BEFORE_POTENTIAL_GC (); 1425 BEFORE_POTENTIAL_GC ();
1311 DISCARD (1); 1426 DISCARD (1);
1312 TOP = Fplus (2, &TOP); 1427 TOP = Fplus (2, &TOP);
1313 AFTER_POTENTIAL_GC (); 1428 AFTER_POTENTIAL_GC ();
1314 break; 1429 NEXT;
1315 1430
1316 case Bmax: 1431 CASE (Bmax):
1317 BEFORE_POTENTIAL_GC (); 1432 BEFORE_POTENTIAL_GC ();
1318 DISCARD (1); 1433 DISCARD (1);
1319 TOP = Fmax (2, &TOP); 1434 TOP = Fmax (2, &TOP);
1320 AFTER_POTENTIAL_GC (); 1435 AFTER_POTENTIAL_GC ();
1321 break; 1436 NEXT;
1322 1437
1323 case Bmin: 1438 CASE (Bmin):
1324 BEFORE_POTENTIAL_GC (); 1439 BEFORE_POTENTIAL_GC ();
1325 DISCARD (1); 1440 DISCARD (1);
1326 TOP = Fmin (2, &TOP); 1441 TOP = Fmin (2, &TOP);
1327 AFTER_POTENTIAL_GC (); 1442 AFTER_POTENTIAL_GC ();
1328 break; 1443 NEXT;
1329 1444
1330 case Bmult: 1445 CASE (Bmult):
1331 BEFORE_POTENTIAL_GC (); 1446 BEFORE_POTENTIAL_GC ();
1332 DISCARD (1); 1447 DISCARD (1);
1333 TOP = Ftimes (2, &TOP); 1448 TOP = Ftimes (2, &TOP);
1334 AFTER_POTENTIAL_GC (); 1449 AFTER_POTENTIAL_GC ();
1335 break; 1450 NEXT;
1336 1451
1337 case Bquo: 1452 CASE (Bquo):
1338 BEFORE_POTENTIAL_GC (); 1453 BEFORE_POTENTIAL_GC ();
1339 DISCARD (1); 1454 DISCARD (1);
1340 TOP = Fquo (2, &TOP); 1455 TOP = Fquo (2, &TOP);
1341 AFTER_POTENTIAL_GC (); 1456 AFTER_POTENTIAL_GC ();
1342 break; 1457 NEXT;
1343 1458
1344 case Brem: 1459 CASE (Brem):
1345 { 1460 {
1346 Lisp_Object v1; 1461 Lisp_Object v1;
1347 BEFORE_POTENTIAL_GC (); 1462 BEFORE_POTENTIAL_GC ();
1348 v1 = POP; 1463 v1 = POP;
1349 TOP = Frem (TOP, v1); 1464 TOP = Frem (TOP, v1);
1350 AFTER_POTENTIAL_GC (); 1465 AFTER_POTENTIAL_GC ();
1351 break; 1466 NEXT;
1352 } 1467 }
1353 1468
1354 case Bpoint: 1469 CASE (Bpoint):
1355 { 1470 {
1356 Lisp_Object v1; 1471 Lisp_Object v1;
1357 XSETFASTINT (v1, PT); 1472 XSETFASTINT (v1, PT);
1358 PUSH (v1); 1473 PUSH (v1);
1359 break; 1474 NEXT;
1360 } 1475 }
1361 1476
1362 case Bgoto_char: 1477 CASE (Bgoto_char):
1363 BEFORE_POTENTIAL_GC (); 1478 BEFORE_POTENTIAL_GC ();
1364 TOP = Fgoto_char (TOP); 1479 TOP = Fgoto_char (TOP);
1365 AFTER_POTENTIAL_GC (); 1480 AFTER_POTENTIAL_GC ();
1366 break; 1481 NEXT;
1367 1482
1368 case Binsert: 1483 CASE (Binsert):
1369 BEFORE_POTENTIAL_GC (); 1484 BEFORE_POTENTIAL_GC ();
1370 TOP = Finsert (1, &TOP); 1485 TOP = Finsert (1, &TOP);
1371 AFTER_POTENTIAL_GC (); 1486 AFTER_POTENTIAL_GC ();
1372 break; 1487 NEXT;
1373 1488
1374 case BinsertN: 1489 CASE (BinsertN):
1375 op = FETCH; 1490 op = FETCH;
1376 BEFORE_POTENTIAL_GC (); 1491 BEFORE_POTENTIAL_GC ();
1377 DISCARD (op - 1); 1492 DISCARD (op - 1);
1378 TOP = Finsert (op, &TOP); 1493 TOP = Finsert (op, &TOP);
1379 AFTER_POTENTIAL_GC (); 1494 AFTER_POTENTIAL_GC ();
1380 break; 1495 NEXT;
1381 1496
1382 case Bpoint_max: 1497 CASE (Bpoint_max):
1383 { 1498 {
1384 Lisp_Object v1; 1499 Lisp_Object v1;
1385 XSETFASTINT (v1, ZV); 1500 XSETFASTINT (v1, ZV);
1386 PUSH (v1); 1501 PUSH (v1);
1387 break; 1502 NEXT;
1388 } 1503 }
1389 1504
1390 case Bpoint_min: 1505 CASE (Bpoint_min):
1391 { 1506 {
1392 Lisp_Object v1; 1507 Lisp_Object v1;
1393 XSETFASTINT (v1, BEGV); 1508 XSETFASTINT (v1, BEGV);
1394 PUSH (v1); 1509 PUSH (v1);
1395 break; 1510 NEXT;
1396 } 1511 }
1397 1512
1398 case Bchar_after: 1513 CASE (Bchar_after):
1399 BEFORE_POTENTIAL_GC (); 1514 BEFORE_POTENTIAL_GC ();
1400 TOP = Fchar_after (TOP); 1515 TOP = Fchar_after (TOP);
1401 AFTER_POTENTIAL_GC (); 1516 AFTER_POTENTIAL_GC ();
1402 break; 1517 NEXT;
1403 1518
1404 case Bfollowing_char: 1519 CASE (Bfollowing_char):
1405 { 1520 {
1406 Lisp_Object v1; 1521 Lisp_Object v1;
1407 BEFORE_POTENTIAL_GC (); 1522 BEFORE_POTENTIAL_GC ();
1408 v1 = Ffollowing_char (); 1523 v1 = Ffollowing_char ();
1409 AFTER_POTENTIAL_GC (); 1524 AFTER_POTENTIAL_GC ();
1410 PUSH (v1); 1525 PUSH (v1);
1411 break; 1526 NEXT;
1412 } 1527 }
1413 1528
1414 case Bpreceding_char: 1529 CASE (Bpreceding_char):
1415 { 1530 {
1416 Lisp_Object v1; 1531 Lisp_Object v1;
1417 BEFORE_POTENTIAL_GC (); 1532 BEFORE_POTENTIAL_GC ();
1418 v1 = Fprevious_char (); 1533 v1 = Fprevious_char ();
1419 AFTER_POTENTIAL_GC (); 1534 AFTER_POTENTIAL_GC ();
1420 PUSH (v1); 1535 PUSH (v1);
1421 break; 1536 NEXT;
1422 } 1537 }
1423 1538
1424 case Bcurrent_column: 1539 CASE (Bcurrent_column):
1425 { 1540 {
1426 Lisp_Object v1; 1541 Lisp_Object v1;
1427 BEFORE_POTENTIAL_GC (); 1542 BEFORE_POTENTIAL_GC ();
1428 XSETFASTINT (v1, current_column ()); 1543 XSETFASTINT (v1, current_column ());
1429 AFTER_POTENTIAL_GC (); 1544 AFTER_POTENTIAL_GC ();
1430 PUSH (v1); 1545 PUSH (v1);
1431 break; 1546 NEXT;
1432 } 1547 }
1433 1548
1434 case Bindent_to: 1549 CASE (Bindent_to):
1435 BEFORE_POTENTIAL_GC (); 1550 BEFORE_POTENTIAL_GC ();
1436 TOP = Findent_to (TOP, Qnil); 1551 TOP = Findent_to (TOP, Qnil);
1437 AFTER_POTENTIAL_GC (); 1552 AFTER_POTENTIAL_GC ();
1438 break; 1553 NEXT;
1439 1554
1440 case Beolp: 1555 CASE (Beolp):
1441 PUSH (Feolp ()); 1556 PUSH (Feolp ());
1442 break; 1557 NEXT;
1443 1558
1444 case Beobp: 1559 CASE (Beobp):
1445 PUSH (Feobp ()); 1560 PUSH (Feobp ());
1446 break; 1561 NEXT;
1447 1562
1448 case Bbolp: 1563 CASE (Bbolp):
1449 PUSH (Fbolp ()); 1564 PUSH (Fbolp ());
1450 break; 1565 NEXT;
1451 1566
1452 case Bbobp: 1567 CASE (Bbobp):
1453 PUSH (Fbobp ()); 1568 PUSH (Fbobp ());
1454 break; 1569 NEXT;
1455 1570
1456 case Bcurrent_buffer: 1571 CASE (Bcurrent_buffer):
1457 PUSH (Fcurrent_buffer ()); 1572 PUSH (Fcurrent_buffer ());
1458 break; 1573 NEXT;
1459 1574
1460 case Bset_buffer: 1575 CASE (Bset_buffer):
1461 BEFORE_POTENTIAL_GC (); 1576 BEFORE_POTENTIAL_GC ();
1462 TOP = Fset_buffer (TOP); 1577 TOP = Fset_buffer (TOP);
1463 AFTER_POTENTIAL_GC (); 1578 AFTER_POTENTIAL_GC ();
1464 break; 1579 NEXT;
1465 1580
1466 case Binteractive_p: /* Obsolete since 24.1. */ 1581 CASE (Binteractive_p): /* Obsolete since 24.1. */
1467 PUSH (Finteractive_p ()); 1582 BEFORE_POTENTIAL_GC ();
1468 break; 1583 PUSH (call0 (intern ("interactive-p")));
1584 AFTER_POTENTIAL_GC ();
1585 NEXT;
1469 1586
1470 case Bforward_char: 1587 CASE (Bforward_char):
1471 BEFORE_POTENTIAL_GC (); 1588 BEFORE_POTENTIAL_GC ();
1472 TOP = Fforward_char (TOP); 1589 TOP = Fforward_char (TOP);
1473 AFTER_POTENTIAL_GC (); 1590 AFTER_POTENTIAL_GC ();
1474 break; 1591 NEXT;
1475 1592
1476 case Bforward_word: 1593 CASE (Bforward_word):
1477 BEFORE_POTENTIAL_GC (); 1594 BEFORE_POTENTIAL_GC ();
1478 TOP = Fforward_word (TOP); 1595 TOP = Fforward_word (TOP);
1479 AFTER_POTENTIAL_GC (); 1596 AFTER_POTENTIAL_GC ();
1480 break; 1597 NEXT;
1481 1598
1482 case Bskip_chars_forward: 1599 CASE (Bskip_chars_forward):
1483 { 1600 {
1484 Lisp_Object v1; 1601 Lisp_Object v1;
1485 BEFORE_POTENTIAL_GC (); 1602 BEFORE_POTENTIAL_GC ();
1486 v1 = POP; 1603 v1 = POP;
1487 TOP = Fskip_chars_forward (TOP, v1); 1604 TOP = Fskip_chars_forward (TOP, v1);
1488 AFTER_POTENTIAL_GC (); 1605 AFTER_POTENTIAL_GC ();
1489 break; 1606 NEXT;
1490 } 1607 }
1491 1608
1492 case Bskip_chars_backward: 1609 CASE (Bskip_chars_backward):
1493 { 1610 {
1494 Lisp_Object v1; 1611 Lisp_Object v1;
1495 BEFORE_POTENTIAL_GC (); 1612 BEFORE_POTENTIAL_GC ();
1496 v1 = POP; 1613 v1 = POP;
1497 TOP = Fskip_chars_backward (TOP, v1); 1614 TOP = Fskip_chars_backward (TOP, v1);
1498 AFTER_POTENTIAL_GC (); 1615 AFTER_POTENTIAL_GC ();
1499 break; 1616 NEXT;
1500 } 1617 }
1501 1618
1502 case Bforward_line: 1619 CASE (Bforward_line):
1503 BEFORE_POTENTIAL_GC (); 1620 BEFORE_POTENTIAL_GC ();
1504 TOP = Fforward_line (TOP); 1621 TOP = Fforward_line (TOP);
1505 AFTER_POTENTIAL_GC (); 1622 AFTER_POTENTIAL_GC ();
1506 break; 1623 NEXT;
1507 1624
1508 case Bchar_syntax: 1625 CASE (Bchar_syntax):
1509 { 1626 {
1510 int c; 1627 int c;
1511 1628
@@ -1517,51 +1634,51 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
1517 MAKE_CHAR_MULTIBYTE (c); 1634 MAKE_CHAR_MULTIBYTE (c);
1518 XSETFASTINT (TOP, syntax_code_spec[(int) SYNTAX (c)]); 1635 XSETFASTINT (TOP, syntax_code_spec[(int) SYNTAX (c)]);
1519 } 1636 }
1520 break; 1637 NEXT;
1521 1638
1522 case Bbuffer_substring: 1639 CASE (Bbuffer_substring):
1523 { 1640 {
1524 Lisp_Object v1; 1641 Lisp_Object v1;
1525 BEFORE_POTENTIAL_GC (); 1642 BEFORE_POTENTIAL_GC ();
1526 v1 = POP; 1643 v1 = POP;
1527 TOP = Fbuffer_substring (TOP, v1); 1644 TOP = Fbuffer_substring (TOP, v1);
1528 AFTER_POTENTIAL_GC (); 1645 AFTER_POTENTIAL_GC ();
1529 break; 1646 NEXT;
1530 } 1647 }
1531 1648
1532 case Bdelete_region: 1649 CASE (Bdelete_region):
1533 { 1650 {
1534 Lisp_Object v1; 1651 Lisp_Object v1;
1535 BEFORE_POTENTIAL_GC (); 1652 BEFORE_POTENTIAL_GC ();
1536 v1 = POP; 1653 v1 = POP;
1537 TOP = Fdelete_region (TOP, v1); 1654 TOP = Fdelete_region (TOP, v1);
1538 AFTER_POTENTIAL_GC (); 1655 AFTER_POTENTIAL_GC ();
1539 break; 1656 NEXT;
1540 } 1657 }
1541 1658
1542 case Bnarrow_to_region: 1659 CASE (Bnarrow_to_region):
1543 { 1660 {
1544 Lisp_Object v1; 1661 Lisp_Object v1;
1545 BEFORE_POTENTIAL_GC (); 1662 BEFORE_POTENTIAL_GC ();
1546 v1 = POP; 1663 v1 = POP;
1547 TOP = Fnarrow_to_region (TOP, v1); 1664 TOP = Fnarrow_to_region (TOP, v1);
1548 AFTER_POTENTIAL_GC (); 1665 AFTER_POTENTIAL_GC ();
1549 break; 1666 NEXT;
1550 } 1667 }
1551 1668
1552 case Bwiden: 1669 CASE (Bwiden):
1553 BEFORE_POTENTIAL_GC (); 1670 BEFORE_POTENTIAL_GC ();
1554 PUSH (Fwiden ()); 1671 PUSH (Fwiden ());
1555 AFTER_POTENTIAL_GC (); 1672 AFTER_POTENTIAL_GC ();
1556 break; 1673 NEXT;
1557 1674
1558 case Bend_of_line: 1675 CASE (Bend_of_line):
1559 BEFORE_POTENTIAL_GC (); 1676 BEFORE_POTENTIAL_GC ();
1560 TOP = Fend_of_line (TOP); 1677 TOP = Fend_of_line (TOP);
1561 AFTER_POTENTIAL_GC (); 1678 AFTER_POTENTIAL_GC ();
1562 break; 1679 NEXT;
1563 1680
1564 case Bset_marker: 1681 CASE (Bset_marker):
1565 { 1682 {
1566 Lisp_Object v1, v2; 1683 Lisp_Object v1, v2;
1567 BEFORE_POTENTIAL_GC (); 1684 BEFORE_POTENTIAL_GC ();
@@ -1569,85 +1686,86 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
1569 v2 = POP; 1686 v2 = POP;
1570 TOP = Fset_marker (TOP, v2, v1); 1687 TOP = Fset_marker (TOP, v2, v1);
1571 AFTER_POTENTIAL_GC (); 1688 AFTER_POTENTIAL_GC ();
1572 break; 1689 NEXT;
1573 } 1690 }
1574 1691
1575 case Bmatch_beginning: 1692 CASE (Bmatch_beginning):
1576 BEFORE_POTENTIAL_GC (); 1693 BEFORE_POTENTIAL_GC ();
1577 TOP = Fmatch_beginning (TOP); 1694 TOP = Fmatch_beginning (TOP);
1578 AFTER_POTENTIAL_GC (); 1695 AFTER_POTENTIAL_GC ();
1579 break; 1696 NEXT;
1580 1697
1581 case Bmatch_end: 1698 CASE (Bmatch_end):
1582 BEFORE_POTENTIAL_GC (); 1699 BEFORE_POTENTIAL_GC ();
1583 TOP = Fmatch_end (TOP); 1700 TOP = Fmatch_end (TOP);
1584 AFTER_POTENTIAL_GC (); 1701 AFTER_POTENTIAL_GC ();
1585 break; 1702 NEXT;
1586 1703
1587 case Bupcase: 1704 CASE (Bupcase):
1588 BEFORE_POTENTIAL_GC (); 1705 BEFORE_POTENTIAL_GC ();
1589 TOP = Fupcase (TOP); 1706 TOP = Fupcase (TOP);
1590 AFTER_POTENTIAL_GC (); 1707 AFTER_POTENTIAL_GC ();
1591 break; 1708 NEXT;
1592 1709
1593 case Bdowncase: 1710 CASE (Bdowncase):
1594 BEFORE_POTENTIAL_GC (); 1711 BEFORE_POTENTIAL_GC ();
1595 TOP = Fdowncase (TOP); 1712 TOP = Fdowncase (TOP);
1596 AFTER_POTENTIAL_GC (); 1713 AFTER_POTENTIAL_GC ();
1597 break; 1714 NEXT;
1598 1715
1599 case Bstringeqlsign: 1716 CASE (Bstringeqlsign):
1600 { 1717 {
1601 Lisp_Object v1; 1718 Lisp_Object v1;
1602 BEFORE_POTENTIAL_GC (); 1719 BEFORE_POTENTIAL_GC ();
1603 v1 = POP; 1720 v1 = POP;
1604 TOP = Fstring_equal (TOP, v1); 1721 TOP = Fstring_equal (TOP, v1);
1605 AFTER_POTENTIAL_GC (); 1722 AFTER_POTENTIAL_GC ();
1606 break; 1723 NEXT;
1607 } 1724 }
1608 1725
1609 case Bstringlss: 1726 CASE (Bstringlss):
1610 { 1727 {
1611 Lisp_Object v1; 1728 Lisp_Object v1;
1612 BEFORE_POTENTIAL_GC (); 1729 BEFORE_POTENTIAL_GC ();
1613 v1 = POP; 1730 v1 = POP;
1614 TOP = Fstring_lessp (TOP, v1); 1731 TOP = Fstring_lessp (TOP, v1);
1615 AFTER_POTENTIAL_GC (); 1732 AFTER_POTENTIAL_GC ();
1616 break; 1733 NEXT;
1617 } 1734 }
1618 1735
1619 case Bequal: 1736 CASE (Bequal):
1620 { 1737 {
1621 Lisp_Object v1; 1738 Lisp_Object v1;
1622 v1 = POP; 1739 v1 = POP;
1623 TOP = Fequal (TOP, v1); 1740 TOP = Fequal (TOP, v1);
1624 break; 1741 NEXT;
1625 } 1742 }
1626 1743
1627 case Bnthcdr: 1744 CASE (Bnthcdr):
1628 { 1745 {
1629 Lisp_Object v1; 1746 Lisp_Object v1;
1630 BEFORE_POTENTIAL_GC (); 1747 BEFORE_POTENTIAL_GC ();
1631 v1 = POP; 1748 v1 = POP;
1632 TOP = Fnthcdr (TOP, v1); 1749 TOP = Fnthcdr (TOP, v1);
1633 AFTER_POTENTIAL_GC (); 1750 AFTER_POTENTIAL_GC ();
1634 break; 1751 NEXT;
1635 } 1752 }
1636 1753
1637 case Belt: 1754 CASE (Belt):
1638 { 1755 {
1639 Lisp_Object v1, v2; 1756 Lisp_Object v1, v2;
1640 if (CONSP (TOP)) 1757 if (CONSP (TOP))
1641 { 1758 {
1642 /* Exchange args and then do nth. */ 1759 /* Exchange args and then do nth. */
1760 EMACS_INT n;
1643 BEFORE_POTENTIAL_GC (); 1761 BEFORE_POTENTIAL_GC ();
1644 v2 = POP; 1762 v2 = POP;
1645 v1 = TOP; 1763 v1 = TOP;
1646 CHECK_NUMBER (v2); 1764 CHECK_NUMBER (v2);
1647 AFTER_POTENTIAL_GC (); 1765 AFTER_POTENTIAL_GC ();
1648 op = XINT (v2); 1766 n = XINT (v2);
1649 immediate_quit = 1; 1767 immediate_quit = 1;
1650 while (--op >= 0 && CONSP (v1)) 1768 while (--n >= 0 && CONSP (v1))
1651 v1 = XCDR (v1); 1769 v1 = XCDR (v1);
1652 immediate_quit = 0; 1770 immediate_quit = 0;
1653 TOP = CAR (v1); 1771 TOP = CAR (v1);
@@ -1659,87 +1777,91 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
1659 TOP = Felt (TOP, v1); 1777 TOP = Felt (TOP, v1);
1660 AFTER_POTENTIAL_GC (); 1778 AFTER_POTENTIAL_GC ();
1661 } 1779 }
1662 break; 1780 NEXT;
1663 } 1781 }
1664 1782
1665 case Bmember: 1783 CASE (Bmember):
1666 { 1784 {
1667 Lisp_Object v1; 1785 Lisp_Object v1;
1668 BEFORE_POTENTIAL_GC (); 1786 BEFORE_POTENTIAL_GC ();
1669 v1 = POP; 1787 v1 = POP;
1670 TOP = Fmember (TOP, v1); 1788 TOP = Fmember (TOP, v1);
1671 AFTER_POTENTIAL_GC (); 1789 AFTER_POTENTIAL_GC ();
1672 break; 1790 NEXT;
1673 } 1791 }
1674 1792
1675 case Bassq: 1793 CASE (Bassq):
1676 { 1794 {
1677 Lisp_Object v1; 1795 Lisp_Object v1;
1678 BEFORE_POTENTIAL_GC (); 1796 BEFORE_POTENTIAL_GC ();
1679 v1 = POP; 1797 v1 = POP;
1680 TOP = Fassq (TOP, v1); 1798 TOP = Fassq (TOP, v1);
1681 AFTER_POTENTIAL_GC (); 1799 AFTER_POTENTIAL_GC ();
1682 break; 1800 NEXT;
1683 } 1801 }
1684 1802
1685 case Bnreverse: 1803 CASE (Bnreverse):
1686 BEFORE_POTENTIAL_GC (); 1804 BEFORE_POTENTIAL_GC ();
1687 TOP = Fnreverse (TOP); 1805 TOP = Fnreverse (TOP);
1688 AFTER_POTENTIAL_GC (); 1806 AFTER_POTENTIAL_GC ();
1689 break; 1807 NEXT;
1690 1808
1691 case Bsetcar: 1809 CASE (Bsetcar):
1692 { 1810 {
1693 Lisp_Object v1; 1811 Lisp_Object v1;
1694 BEFORE_POTENTIAL_GC (); 1812 BEFORE_POTENTIAL_GC ();
1695 v1 = POP; 1813 v1 = POP;
1696 TOP = Fsetcar (TOP, v1); 1814 TOP = Fsetcar (TOP, v1);
1697 AFTER_POTENTIAL_GC (); 1815 AFTER_POTENTIAL_GC ();
1698 break; 1816 NEXT;
1699 } 1817 }
1700 1818
1701 case Bsetcdr: 1819 CASE (Bsetcdr):
1702 { 1820 {
1703 Lisp_Object v1; 1821 Lisp_Object v1;
1704 BEFORE_POTENTIAL_GC (); 1822 BEFORE_POTENTIAL_GC ();
1705 v1 = POP; 1823 v1 = POP;
1706 TOP = Fsetcdr (TOP, v1); 1824 TOP = Fsetcdr (TOP, v1);
1707 AFTER_POTENTIAL_GC (); 1825 AFTER_POTENTIAL_GC ();
1708 break; 1826 NEXT;
1709 } 1827 }
1710 1828
1711 case Bcar_safe: 1829 CASE (Bcar_safe):
1712 { 1830 {
1713 Lisp_Object v1; 1831 Lisp_Object v1;
1714 v1 = TOP; 1832 v1 = TOP;
1715 TOP = CAR_SAFE (v1); 1833 TOP = CAR_SAFE (v1);
1716 break; 1834 NEXT;
1717 } 1835 }
1718 1836
1719 case Bcdr_safe: 1837 CASE (Bcdr_safe):
1720 { 1838 {
1721 Lisp_Object v1; 1839 Lisp_Object v1;
1722 v1 = TOP; 1840 v1 = TOP;
1723 TOP = CDR_SAFE (v1); 1841 TOP = CDR_SAFE (v1);
1724 break; 1842 NEXT;
1725 } 1843 }
1726 1844
1727 case Bnconc: 1845 CASE (Bnconc):
1728 BEFORE_POTENTIAL_GC (); 1846 BEFORE_POTENTIAL_GC ();
1729 DISCARD (1); 1847 DISCARD (1);
1730 TOP = Fnconc (2, &TOP); 1848 TOP = Fnconc (2, &TOP);
1731 AFTER_POTENTIAL_GC (); 1849 AFTER_POTENTIAL_GC ();
1732 break; 1850 NEXT;
1733 1851
1734 case Bnumberp: 1852 CASE (Bnumberp):
1735 TOP = (NUMBERP (TOP) ? Qt : Qnil); 1853 TOP = (NUMBERP (TOP) ? Qt : Qnil);
1736 break; 1854 NEXT;
1737 1855
1738 case Bintegerp: 1856 CASE (Bintegerp):
1739 TOP = INTEGERP (TOP) ? Qt : Qnil; 1857 TOP = INTEGERP (TOP) ? Qt : Qnil;
1740 break; 1858 NEXT;
1741 1859
1742#ifdef BYTE_CODE_SAFE 1860#ifdef BYTE_CODE_SAFE
1861 /* These are intentionally written using 'case' syntax,
1862 because they are incompatible with the threaded
1863 interpreter. */
1864
1743 case Bset_mark: 1865 case Bset_mark:
1744 BEFORE_POTENTIAL_GC (); 1866 BEFORE_POTENTIAL_GC ();
1745 error ("set-mark is an obsolete bytecode"); 1867 error ("set-mark is an obsolete bytecode");
@@ -1752,49 +1874,49 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
1752 break; 1874 break;
1753#endif 1875#endif
1754 1876
1755 case 0: 1877 CASE_ABORT:
1756 /* Actually this is Bstack_ref with offset 0, but we use Bdup 1878 /* Actually this is Bstack_ref with offset 0, but we use Bdup
1757 for that instead. */ 1879 for that instead. */
1758 /* case Bstack_ref: */ 1880 /* CASE (Bstack_ref): */
1759 abort (); 1881 error ("Invalid byte opcode");
1760 1882
1761 /* Handy byte-codes for lexical binding. */ 1883 /* Handy byte-codes for lexical binding. */
1762 case Bstack_ref+1: 1884 CASE (Bstack_ref1):
1763 case Bstack_ref+2: 1885 CASE (Bstack_ref2):
1764 case Bstack_ref+3: 1886 CASE (Bstack_ref3):
1765 case Bstack_ref+4: 1887 CASE (Bstack_ref4):
1766 case Bstack_ref+5: 1888 CASE (Bstack_ref5):
1767 { 1889 {
1768 Lisp_Object *ptr = top - (op - Bstack_ref); 1890 Lisp_Object *ptr = top - (op - Bstack_ref);
1769 PUSH (*ptr); 1891 PUSH (*ptr);
1770 break; 1892 NEXT;
1771 } 1893 }
1772 case Bstack_ref+6: 1894 CASE (Bstack_ref6):
1773 { 1895 {
1774 Lisp_Object *ptr = top - (FETCH); 1896 Lisp_Object *ptr = top - (FETCH);
1775 PUSH (*ptr); 1897 PUSH (*ptr);
1776 break; 1898 NEXT;
1777 } 1899 }
1778 case Bstack_ref+7: 1900 CASE (Bstack_ref7):
1779 { 1901 {
1780 Lisp_Object *ptr = top - (FETCH2); 1902 Lisp_Object *ptr = top - (FETCH2);
1781 PUSH (*ptr); 1903 PUSH (*ptr);
1782 break; 1904 NEXT;
1783 } 1905 }
1784 case Bstack_set: 1906 CASE (Bstack_set):
1785 /* stack-set-0 = discard; stack-set-1 = discard-1-preserve-tos. */ 1907 /* stack-set-0 = discard; stack-set-1 = discard-1-preserve-tos. */
1786 { 1908 {
1787 Lisp_Object *ptr = top - (FETCH); 1909 Lisp_Object *ptr = top - (FETCH);
1788 *ptr = POP; 1910 *ptr = POP;
1789 break; 1911 NEXT;
1790 } 1912 }
1791 case Bstack_set2: 1913 CASE (Bstack_set2):
1792 { 1914 {
1793 Lisp_Object *ptr = top - (FETCH2); 1915 Lisp_Object *ptr = top - (FETCH2);
1794 *ptr = POP; 1916 *ptr = POP;
1795 break; 1917 NEXT;
1796 } 1918 }
1797 case BdiscardN: 1919 CASE (BdiscardN):
1798 op = FETCH; 1920 op = FETCH;
1799 if (op & 0x80) 1921 if (op & 0x80)
1800 { 1922 {
@@ -1802,23 +1924,24 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
1802 top[-op] = TOP; 1924 top[-op] = TOP;
1803 } 1925 }
1804 DISCARD (op); 1926 DISCARD (op);
1805 break; 1927 NEXT;
1806 1928
1807 case 255: 1929 CASE_DEFAULT
1808 default: 1930 CASE (Bconstant):
1809#ifdef BYTE_CODE_SAFE 1931#ifdef BYTE_CODE_SAFE
1810 if (op < Bconstant) 1932 if (op < Bconstant)
1811 { 1933 {
1812 abort (); 1934 emacs_abort ();
1813 } 1935 }
1814 if ((op -= Bconstant) >= const_length) 1936 if ((op -= Bconstant) >= const_length)
1815 { 1937 {
1816 abort (); 1938 emacs_abort ();
1817 } 1939 }
1818 PUSH (vectorp[op]); 1940 PUSH (vectorp[op]);
1819#else 1941#else
1820 PUSH (vectorp[op - Bconstant]); 1942 PUSH (vectorp[op - Bconstant]);
1821#endif 1943#endif
1944 NEXT;
1822 } 1945 }
1823 } 1946 }
1824 1947
@@ -1831,7 +1954,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
1831#ifdef BYTE_CODE_SAFE 1954#ifdef BYTE_CODE_SAFE
1832 error ("binding stack not balanced (serious byte compiler bug)"); 1955 error ("binding stack not balanced (serious byte compiler bug)");
1833#else 1956#else
1834 abort (); 1957 emacs_abort ();
1835#endif 1958#endif
1836 1959
1837 return result; 1960 return result;
@@ -1866,8 +1989,8 @@ integer, it is incremented each time that symbol's function is called. */);
1866 { 1989 {
1867 int i = 256; 1990 int i = 256;
1868 while (i--) 1991 while (i--)
1869 XVECTOR (Vbyte_code_meter)->contents[i] = 1992 ASET (Vbyte_code_meter, i,
1870 Fmake_vector (make_number (256), make_number (0)); 1993 Fmake_vector (make_number (256), make_number (0)));
1871 } 1994 }
1872#endif 1995#endif
1873} 1996}
generated by cgit v1.2.1 (git 2.18.0) at 2026-02-03 19:53:57 +0000