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