Index: ChangeLog =================================================================== RCS file: /cvsroot/emacs/emacs/src/ChangeLog,v retrieving revision 1.3655 diff -u -r1.3655 ChangeLog --- ChangeLog 2 May 2004 18:47:57 -0000 1.3655 +++ ChangeLog 4 May 2004 01:04:13 -0000 @@ -1,3 +1,8 @@ +2004-05-03 Jaeyoun Chung + + * bytecode.c (Fbyte_code): theaded bytecode interpretation code added. + Define THREADED_CODE to enable computed goto based interpretation. + 2004-05-02 Eli Zaretskii * syntax.h (SET_RAW_SYNTAX_ENTRY, SYNTAX_ENTRY_INT): Avoid Index: bytecode.c =================================================================== RCS file: /cvsroot/emacs/emacs/src/bytecode.c,v retrieving revision 1.79 diff -u -r1.79 bytecode.c --- bytecode.c 11 Sep 2003 21:58:32 -0000 1.79 +++ bytecode.c 4 May 2004 01:04:14 -0000 @@ -55,6 +55,10 @@ /* #define BYTE_CODE_SAFE */ /* #define BYTE_CODE_METER */ +/* define THREADED_CODE to enable the gcc's computed goto based jump instead + * of while(1) switch bytecod dispatch */ +/* #define THREADED_CODE */ + #ifdef BYTE_CODE_METER @@ -91,10 +95,50 @@ /* Byte codes: */ #define Bvarref 010 +#define Bvarref0 010 +#define Bvarref1 011 +#define Bvarref2 012 +#define Bvarref3 013 +#define Bvarref4 014 +#define Bvarref5 015 +#define Bvarref6 016 +#define Bvarref7 017 #define Bvarset 020 +#define Bvarset0 020 +#define Bvarset1 021 +#define Bvarset2 022 +#define Bvarset3 023 +#define Bvarset4 024 +#define Bvarset5 025 +#define Bvarset6 026 +#define Bvarset7 027 #define Bvarbind 030 +#define Bvarbind0 030 +#define Bvarbind1 031 +#define Bvarbind2 032 +#define Bvarbind3 033 +#define Bvarbind4 034 +#define Bvarbind5 035 +#define Bvarbind6 036 +#define Bvarbind7 037 #define Bcall 040 +#define Bcall0 040 +#define Bcall1 041 +#define Bcall2 042 +#define Bcall3 043 +#define Bcall4 044 +#define Bcall5 045 +#define Bcall6 046 +#define Bcall7 047 #define Bunbind 050 +#define Bunbind0 050 +#define Bunbind1 051 +#define Bunbind2 052 +#define Bunbind3 053 +#define Bunbind4 054 +#define Bunbind5 055 +#define Bunbind6 056 +#define Bunbind7 057 #define Bnth 070 #define Bsymbolp 071 @@ -390,7 +434,6 @@ } \ } while (0) - DEFUN ("byte-code", Fbyte_code, Sbyte_code, 3, 3, 0, doc: /* Function used internally in byte-compiled code. The first argument, BYTESTR, is a string of byte code; @@ -417,6 +460,198 @@ Lisp_Object *top; Lisp_Object result; +#ifdef THREADED_CODE +# define OPCODE(X) lbl_ ##X +# define Next() goto *op_tbls[op = FETCH] +# define DEFAULT lbl_default + + static int op_inited = 0; + static void **op_tbls[256] = { +# define OPLABL(X) [X] = &&lbl_ ##X +OPLABL(Bvarref7), +OPLABL(Bvarref0), +OPLABL(Bvarref1), +OPLABL(Bvarref2), +OPLABL(Bvarref3), +OPLABL(Bvarref4), +OPLABL(Bvarref5), +OPLABL(Bvarref6), +OPLABL(Bgotoifnil), +OPLABL(Bcar), +OPLABL(Beq), +OPLABL(Bmemq), +OPLABL(Bcdr), +OPLABL(Bvarset0), +OPLABL(Bvarset1), +OPLABL(Bvarset2), +OPLABL(Bvarset3), +OPLABL(Bvarset4), +OPLABL(Bvarset5), +OPLABL(Bvarset7), +OPLABL(Bvarset6), +OPLABL(Bdup), +OPLABL(Bvarbind6), +OPLABL(Bvarbind7), +OPLABL(Bvarbind0), +OPLABL(Bvarbind1), +OPLABL(Bvarbind2), +OPLABL(Bvarbind3), +OPLABL(Bvarbind4), +OPLABL(Bvarbind5), +OPLABL(Bcall6), +OPLABL(Bcall7), +OPLABL(Bcall0), +OPLABL(Bcall1), +OPLABL(Bcall2), +OPLABL(Bcall3), +OPLABL(Bcall4), +OPLABL(Bcall5), +OPLABL(Bunbind6), +OPLABL(Bunbind7), +OPLABL(Bunbind0), +OPLABL(Bunbind1), +OPLABL(Bunbind2), +OPLABL(Bunbind3), +OPLABL(Bunbind4), +OPLABL(Bunbind5), +OPLABL(Bunbind_all), +OPLABL(Bgoto), +OPLABL(Bgotoifnonnil), +OPLABL(Bgotoifnilelsepop), +OPLABL(Bgotoifnonnilelsepop), +OPLABL(BRgoto), +OPLABL(BRgotoifnil), +OPLABL(BRgotoifnonnil), +OPLABL(BRgotoifnilelsepop), +OPLABL(BRgotoifnonnilelsepop), +OPLABL(Breturn), +OPLABL(Bdiscard), +OPLABL(Bconstant2), +OPLABL(Bsave_excursion), +OPLABL(Bsave_current_buffer), +OPLABL(Bsave_current_buffer_1), +OPLABL(Bsave_window_excursion), +OPLABL(Bsave_restriction), +OPLABL(Bcatch), +OPLABL(Bunwind_protect), +OPLABL(Bcondition_case), +OPLABL(Btemp_output_buffer_setup), +OPLABL(Btemp_output_buffer_show), +OPLABL(Bnth), +OPLABL(Bsymbolp), +OPLABL(Bconsp), +OPLABL(Bstringp), +OPLABL(Blistp), +OPLABL(Bnot), +OPLABL(Bcons), +OPLABL(Blist1), +OPLABL(Blist2), +OPLABL(Blist3), +OPLABL(Blist4), +OPLABL(BlistN), +OPLABL(Blength), +OPLABL(Baref), +OPLABL(Baset), +OPLABL(Bsymbol_value), +OPLABL(Bsymbol_function), +OPLABL(Bset), +OPLABL(Bfset), +OPLABL(Bget), +OPLABL(Bsubstring), +OPLABL(Bconcat2), +OPLABL(Bconcat3), +OPLABL(Bconcat4), +OPLABL(BconcatN), +OPLABL(Bsub1), +OPLABL(Badd1), +OPLABL(Beqlsign), +OPLABL(Bgtr), +OPLABL(Blss), +OPLABL(Bleq), +OPLABL(Bgeq), +OPLABL(Bdiff), +OPLABL(Bnegate), +OPLABL(Bplus), +OPLABL(Bmax), +OPLABL(Bmin), +OPLABL(Bmult), +OPLABL(Bquo), +OPLABL(Brem), +OPLABL(Bpoint), +OPLABL(Bgoto_char), +OPLABL(Binsert), +OPLABL(BinsertN), +OPLABL(Bpoint_max), +OPLABL(Bpoint_min), +OPLABL(Bchar_after), +OPLABL(Bfollowing_char), +OPLABL(Bpreceding_char), +OPLABL(Bcurrent_column), +OPLABL(Bindent_to), +OPLABL(Beolp), +OPLABL(Beobp), +OPLABL(Bbolp), +OPLABL(Bbobp), +OPLABL(Bcurrent_buffer), +OPLABL(Bset_buffer), +OPLABL(Binteractive_p), +OPLABL(Bforward_char), +OPLABL(Bforward_word), +OPLABL(Bskip_chars_forward), +OPLABL(Bskip_chars_backward), +OPLABL(Bforward_line), +OPLABL(Bchar_syntax), +OPLABL(Bbuffer_substring), +OPLABL(Bdelete_region), +OPLABL(Bnarrow_to_region), +OPLABL(Bwiden), +OPLABL(Bend_of_line), +OPLABL(Bset_marker), +OPLABL(Bmatch_beginning), +OPLABL(Bmatch_end), +OPLABL(Bupcase), +OPLABL(Bdowncase), +OPLABL(Bstringeqlsign), +OPLABL(Bstringlss), +OPLABL(Bequal), +OPLABL(Bnthcdr), +OPLABL(Belt), +OPLABL(Bmember), +OPLABL(Bassq), +OPLABL(Bnreverse), +OPLABL(Bsetcar), +OPLABL(Bsetcdr), +OPLABL(Bcar_safe), +OPLABL(Bcdr_safe), +OPLABL(Bnconc), +OPLABL(Bnumberp), +OPLABL(Bintegerp), +# ifdef BYTE_CODE_SAFE +OPLABL(Bset_mark), +OPLABL(Bscan_buffer), +# endif +OPLABL(0), +OPLABL(255), + +# undef OPLABL + }; + + if (!op_inited) { + int i; + + for (i = 0; i < sizeof (op_tbls)/sizeof(op_tbls[0]); ++i) + if (!op_tbls[i]) op_tbls[i] = &&lbl_default; + + op_inited = 1; + } + +#else +# define OPCODE(X) case X +# define Next() break +# define DEFAULT default +#endif /* THREADED_CODE */ + + #ifdef CHECK_FRAME_FONT { struct frame *f = SELECTED_FRAME (); @@ -457,6 +692,7 @@ stacke = stack.bottom - 1 + XFASTINT (maxdepth); #endif +#ifndef THREADED_CODE while (1) { #ifdef BYTE_CODE_SAFE @@ -476,22 +712,26 @@ switch (op) { - case Bvarref + 7: +#else + Next(); +#endif /* !THREADED_CODE */ + + OPCODE(Bvarref7): op = FETCH2; goto varref; - case Bvarref: - case Bvarref + 1: - case Bvarref + 2: - case Bvarref + 3: - case Bvarref + 4: - case Bvarref + 5: - op = op - Bvarref; + OPCODE(Bvarref0): + OPCODE(Bvarref1): + OPCODE(Bvarref2): + OPCODE(Bvarref3): + OPCODE(Bvarref4): + OPCODE(Bvarref5): + op = op - Bvarref0; goto varref; /* This seems to be the most frequently executed byte-code among the Bvarref's, so avoid a goto here. */ - case Bvarref+6: + OPCODE(Bvarref6): op = FETCH; varref: { @@ -515,10 +755,10 @@ AFTER_POTENTIAL_GC (); } PUSH (v2); - break; + Next(); } - case Bgotoifnil: + OPCODE(Bgotoifnil): MAYBE_GC (); op = FETCH2; if (NILP (POP)) @@ -527,9 +767,9 @@ CHECK_RANGE (op); stack.pc = stack.byte_string_start + op; } - break; + Next(); - case Bcar: + OPCODE(Bcar): { Lisp_Object v1; v1 = TOP; @@ -543,28 +783,28 @@ Fcar (wrong_type_argument (Qlistp, v1)); AFTER_POTENTIAL_GC (); } - break; + Next(); } - case Beq: + OPCODE(Beq): { Lisp_Object v1; v1 = POP; TOP = EQ (v1, TOP) ? Qt : Qnil; - break; + Next(); } - case Bmemq: + OPCODE(Bmemq): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fmemq (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bcdr: + OPCODE(Bcdr): { Lisp_Object v1; v1 = TOP; @@ -578,23 +818,23 @@ Fcdr (wrong_type_argument (Qlistp, v1)); AFTER_POTENTIAL_GC (); } - break; + Next(); } - case Bvarset: - case Bvarset+1: - case Bvarset+2: - case Bvarset+3: - case Bvarset+4: - case Bvarset+5: - op -= Bvarset; + OPCODE(Bvarset0): + OPCODE(Bvarset1): + OPCODE(Bvarset2): + OPCODE(Bvarset3): + OPCODE(Bvarset4): + OPCODE(Bvarset5): + op -= Bvarset0; goto varset; - case Bvarset+7: + OPCODE(Bvarset7): op = FETCH2; goto varset; - case Bvarset+6: + OPCODE(Bvarset6): op = FETCH; varset: { @@ -618,55 +858,55 @@ } } (void) POP; - break; + Next(); - case Bdup: + OPCODE(Bdup): { Lisp_Object v1; v1 = TOP; PUSH (v1); - break; + Next(); } /* ------------------ */ - case Bvarbind+6: + OPCODE(Bvarbind6): op = FETCH; goto varbind; - case Bvarbind+7: + OPCODE(Bvarbind7): op = FETCH2; goto varbind; - case Bvarbind: - case Bvarbind+1: - case Bvarbind+2: - case Bvarbind+3: - case Bvarbind+4: - case Bvarbind+5: - op -= Bvarbind; + OPCODE(Bvarbind0): + OPCODE(Bvarbind1): + OPCODE(Bvarbind2): + OPCODE(Bvarbind3): + OPCODE(Bvarbind4): + OPCODE(Bvarbind5): + op -= Bvarbind0; varbind: /* Specbind can signal and thus GC. */ BEFORE_POTENTIAL_GC (); specbind (vectorp[op], POP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bcall+6: + OPCODE(Bcall6): op = FETCH; goto docall; - case Bcall+7: + OPCODE(Bcall7): op = FETCH2; goto docall; - case Bcall: - case Bcall+1: - case Bcall+2: - case Bcall+3: - case Bcall+4: - case Bcall+5: - op -= Bcall; + OPCODE(Bcall0): + OPCODE(Bcall1): + OPCODE(Bcall2): + OPCODE(Bcall3): + OPCODE(Bcall4): + OPCODE(Bcall5): + op -= Bcall0; docall: { BEFORE_POTENTIAL_GC (); @@ -688,47 +928,47 @@ #endif TOP = Ffuncall (op + 1, &TOP); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bunbind+6: + OPCODE(Bunbind6): op = FETCH; goto dounbind; - case Bunbind+7: + OPCODE(Bunbind7): op = FETCH2; goto dounbind; - case Bunbind: - case Bunbind+1: - case Bunbind+2: - case Bunbind+3: - case Bunbind+4: - case Bunbind+5: - op -= Bunbind; + OPCODE(Bunbind0): + OPCODE(Bunbind1): + OPCODE(Bunbind2): + OPCODE(Bunbind3): + OPCODE(Bunbind4): + OPCODE(Bunbind5): + op -= Bunbind0; dounbind: BEFORE_POTENTIAL_GC (); unbind_to (SPECPDL_INDEX () - op, Qnil); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bunbind_all: + OPCODE(Bunbind_all): /* To unbind back to the beginning of this frame. Not used yet, but will be needed for tail-recursion elimination. */ BEFORE_POTENTIAL_GC (); unbind_to (count, Qnil); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bgoto: + OPCODE(Bgoto): MAYBE_GC (); BYTE_CODE_QUIT; op = FETCH2; /* pc = FETCH2 loses since FETCH2 contains pc++ */ CHECK_RANGE (op); stack.pc = stack.byte_string_start + op; - break; + Next(); - case Bgotoifnonnil: + OPCODE(Bgotoifnonnil): MAYBE_GC (); op = FETCH2; if (!NILP (POP)) @@ -737,9 +977,9 @@ CHECK_RANGE (op); stack.pc = stack.byte_string_start + op; } - break; + Next(); - case Bgotoifnilelsepop: + OPCODE(Bgotoifnilelsepop): MAYBE_GC (); op = FETCH2; if (NILP (TOP)) @@ -749,9 +989,9 @@ stack.pc = stack.byte_string_start + op; } else DISCARD (1); - break; + Next(); - case Bgotoifnonnilelsepop: + OPCODE(Bgotoifnonnilelsepop): MAYBE_GC (); op = FETCH2; if (!NILP (TOP)) @@ -761,15 +1001,15 @@ stack.pc = stack.byte_string_start + op; } else DISCARD (1); - break; + Next(); - case BRgoto: + OPCODE(BRgoto): MAYBE_GC (); BYTE_CODE_QUIT; stack.pc += (int) *stack.pc - 127; - break; + Next(); - case BRgotoifnil: + OPCODE(BRgotoifnil): MAYBE_GC (); if (NILP (POP)) { @@ -777,9 +1017,9 @@ stack.pc += (int) *stack.pc - 128; } stack.pc++; - break; + Next(); - case BRgotoifnonnil: + OPCODE(BRgotoifnonnil): MAYBE_GC (); if (!NILP (POP)) { @@ -787,9 +1027,9 @@ stack.pc += (int) *stack.pc - 128; } stack.pc++; - break; + Next(); - case BRgotoifnilelsepop: + OPCODE(BRgotoifnilelsepop): MAYBE_GC (); op = *stack.pc++; if (NILP (TOP)) @@ -798,9 +1038,9 @@ stack.pc += op - 128; } else DISCARD (1); - break; + Next(); - case BRgotoifnonnilelsepop: + OPCODE(BRgotoifnonnilelsepop): MAYBE_GC (); op = *stack.pc++; if (!NILP (TOP)) @@ -809,59 +1049,59 @@ stack.pc += op - 128; } else DISCARD (1); - break; + Next(); - case Breturn: + OPCODE(Breturn): result = POP; goto exit; - case Bdiscard: + OPCODE(Bdiscard): DISCARD (1); - break; + Next(); - case Bconstant2: + OPCODE(Bconstant2): PUSH (vectorp[FETCH2]); - break; + Next(); - case Bsave_excursion: + OPCODE(Bsave_excursion): record_unwind_protect (save_excursion_restore, save_excursion_save ()); - break; + Next(); - case Bsave_current_buffer: - case Bsave_current_buffer_1: + OPCODE(Bsave_current_buffer): + OPCODE(Bsave_current_buffer_1): record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ()); - break; + Next(); - case Bsave_window_excursion: + OPCODE(Bsave_window_excursion): BEFORE_POTENTIAL_GC (); TOP = Fsave_window_excursion (TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bsave_restriction: + OPCODE(Bsave_restriction): record_unwind_protect (save_restriction_restore, save_restriction_save ()); - break; + Next(); - case Bcatch: + OPCODE(Bcatch): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = internal_catch (TOP, Feval, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bunwind_protect: + OPCODE(Bunwind_protect): /* The function record_unwind_protect can GC. */ BEFORE_POTENTIAL_GC (); record_unwind_protect (Fprogn, POP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bcondition_case: + OPCODE(Bcondition_case): { Lisp_Object v1; v1 = POP; @@ -869,18 +1109,18 @@ BEFORE_POTENTIAL_GC (); TOP = Fcondition_case (Fcons (TOP, v1)); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Btemp_output_buffer_setup: + OPCODE(Btemp_output_buffer_setup): BEFORE_POTENTIAL_GC (); CHECK_STRING (TOP); temp_output_buffer_setup (SDATA (TOP)); AFTER_POTENTIAL_GC (); TOP = Vstandard_output; - break; + Next(); - case Btemp_output_buffer_show: + OPCODE(Btemp_output_buffer_show): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); @@ -890,10 +1130,10 @@ /* pop binding of standard-output */ unbind_to (SPECPDL_INDEX () - 1, Qnil); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bnth: + OPCODE(Bnth): { Lisp_Object v1, v2; BEFORE_POTENTIAL_GC (); @@ -928,173 +1168,173 @@ Fcar (wrong_type_argument (Qlistp, v1)); AFTER_POTENTIAL_GC (); } - break; + Next(); } - case Bsymbolp: + OPCODE(Bsymbolp): TOP = SYMBOLP (TOP) ? Qt : Qnil; - break; + Next(); - case Bconsp: + OPCODE(Bconsp): TOP = CONSP (TOP) ? Qt : Qnil; - break; + Next(); - case Bstringp: + OPCODE(Bstringp): TOP = STRINGP (TOP) ? Qt : Qnil; - break; + Next(); - case Blistp: + OPCODE(Blistp): TOP = CONSP (TOP) || NILP (TOP) ? Qt : Qnil; - break; + Next(); - case Bnot: + OPCODE(Bnot): TOP = NILP (TOP) ? Qt : Qnil; - break; + Next(); - case Bcons: + OPCODE(Bcons): { Lisp_Object v1; v1 = POP; TOP = Fcons (TOP, v1); - break; + Next(); } - case Blist1: + OPCODE(Blist1): TOP = Fcons (TOP, Qnil); - break; + Next(); - case Blist2: + OPCODE(Blist2): { Lisp_Object v1; v1 = POP; TOP = Fcons (TOP, Fcons (v1, Qnil)); - break; + Next(); } - case Blist3: + OPCODE(Blist3): DISCARD (2); TOP = Flist (3, &TOP); - break; + Next(); - case Blist4: + OPCODE(Blist4): DISCARD (3); TOP = Flist (4, &TOP); - break; + Next(); - case BlistN: + OPCODE(BlistN): op = FETCH; DISCARD (op - 1); TOP = Flist (op, &TOP); - break; + Next(); - case Blength: + OPCODE(Blength): BEFORE_POTENTIAL_GC (); TOP = Flength (TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Baref: + OPCODE(Baref): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Faref (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Baset: + OPCODE(Baset): { Lisp_Object v1, v2; BEFORE_POTENTIAL_GC (); v2 = POP; v1 = POP; TOP = Faset (TOP, v1, v2); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bsymbol_value: + OPCODE(Bsymbol_value): BEFORE_POTENTIAL_GC (); TOP = Fsymbol_value (TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bsymbol_function: + OPCODE(Bsymbol_function): BEFORE_POTENTIAL_GC (); TOP = Fsymbol_function (TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bset: + OPCODE(Bset): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fset (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bfset: + OPCODE(Bfset): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Ffset (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bget: + OPCODE(Bget): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fget (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bsubstring: + OPCODE(Bsubstring): { Lisp_Object v1, v2; BEFORE_POTENTIAL_GC (); v2 = POP; v1 = POP; TOP = Fsubstring (TOP, v1, v2); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bconcat2: + OPCODE(Bconcat2): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fconcat (2, &TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bconcat3: + OPCODE(Bconcat3): BEFORE_POTENTIAL_GC (); DISCARD (2); TOP = Fconcat (3, &TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bconcat4: + OPCODE(Bconcat4): BEFORE_POTENTIAL_GC (); DISCARD (3); TOP = Fconcat (4, &TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case BconcatN: + OPCODE(BconcatN): op = FETCH; BEFORE_POTENTIAL_GC (); DISCARD (op - 1); TOP = Fconcat (op, &TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bsub1: + OPCODE(Bsub1): { Lisp_Object v1; v1 = TOP; @@ -1109,10 +1349,10 @@ TOP = Fsub1 (v1); AFTER_POTENTIAL_GC (); } - break; + Next(); } - case Badd1: + OPCODE(Badd1): { Lisp_Object v1; v1 = TOP; @@ -1127,10 +1367,10 @@ TOP = Fadd1 (v1); AFTER_POTENTIAL_GC (); } - break; + Next(); } - case Beqlsign: + OPCODE(Beqlsign): { Lisp_Object v1, v2; BEFORE_POTENTIAL_GC (); @@ -1148,57 +1388,57 @@ } else TOP = (XINT (v1) == XINT (v2) ? Qt : Qnil); - break; + Next(); } - case Bgtr: + OPCODE(Bgtr): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fgtr (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Blss: + OPCODE(Blss): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Flss (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bleq: + OPCODE(Bleq): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fleq (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bgeq: + OPCODE(Bgeq): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fgeq (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bdiff: + OPCODE(Bdiff): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fminus (2, &TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bnegate: + OPCODE(Bnegate): { Lisp_Object v1; v1 = TOP; @@ -1213,258 +1453,258 @@ TOP = Fminus (1, &TOP); AFTER_POTENTIAL_GC (); } - break; + Next(); } - case Bplus: + OPCODE(Bplus): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fplus (2, &TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bmax: + OPCODE(Bmax): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fmax (2, &TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bmin: + OPCODE(Bmin): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fmin (2, &TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bmult: + OPCODE(Bmult): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Ftimes (2, &TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bquo: + OPCODE(Bquo): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fquo (2, &TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Brem: + OPCODE(Brem): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Frem (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bpoint: + OPCODE(Bpoint): { Lisp_Object v1; XSETFASTINT (v1, PT); PUSH (v1); - break; + Next(); } - case Bgoto_char: + OPCODE(Bgoto_char): BEFORE_POTENTIAL_GC (); TOP = Fgoto_char (TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Binsert: + OPCODE(Binsert): BEFORE_POTENTIAL_GC (); TOP = Finsert (1, &TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case BinsertN: + OPCODE(BinsertN): op = FETCH; BEFORE_POTENTIAL_GC (); DISCARD (op - 1); TOP = Finsert (op, &TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bpoint_max: + OPCODE(Bpoint_max): { Lisp_Object v1; XSETFASTINT (v1, ZV); PUSH (v1); - break; + Next(); } - case Bpoint_min: + OPCODE(Bpoint_min): { Lisp_Object v1; XSETFASTINT (v1, BEGV); PUSH (v1); - break; + Next(); } - case Bchar_after: + OPCODE(Bchar_after): BEFORE_POTENTIAL_GC (); TOP = Fchar_after (TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bfollowing_char: + OPCODE(Bfollowing_char): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = Ffollowing_char (); AFTER_POTENTIAL_GC (); PUSH (v1); - break; + Next(); } - case Bpreceding_char: + OPCODE(Bpreceding_char): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = Fprevious_char (); AFTER_POTENTIAL_GC (); PUSH (v1); - break; + Next(); } - case Bcurrent_column: + OPCODE(Bcurrent_column): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); XSETFASTINT (v1, (int) current_column ()); /* iftc */ AFTER_POTENTIAL_GC (); PUSH (v1); - break; + Next(); } - case Bindent_to: + OPCODE(Bindent_to): BEFORE_POTENTIAL_GC (); TOP = Findent_to (TOP, Qnil); AFTER_POTENTIAL_GC (); - break; + Next(); - case Beolp: + OPCODE(Beolp): PUSH (Feolp ()); - break; + Next(); - case Beobp: + OPCODE(Beobp): PUSH (Feobp ()); - break; + Next(); - case Bbolp: + OPCODE(Bbolp): PUSH (Fbolp ()); - break; + Next(); - case Bbobp: + OPCODE(Bbobp): PUSH (Fbobp ()); - break; + Next(); - case Bcurrent_buffer: + OPCODE(Bcurrent_buffer): PUSH (Fcurrent_buffer ()); - break; + Next(); - case Bset_buffer: + OPCODE(Bset_buffer): BEFORE_POTENTIAL_GC (); TOP = Fset_buffer (TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Binteractive_p: + OPCODE(Binteractive_p): PUSH (Finteractive_p ()); - break; + Next(); - case Bforward_char: + OPCODE(Bforward_char): BEFORE_POTENTIAL_GC (); TOP = Fforward_char (TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bforward_word: + OPCODE(Bforward_word): BEFORE_POTENTIAL_GC (); TOP = Fforward_word (TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bskip_chars_forward: + OPCODE(Bskip_chars_forward): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fskip_chars_forward (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bskip_chars_backward: + OPCODE(Bskip_chars_backward): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fskip_chars_backward (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bforward_line: + OPCODE(Bforward_line): BEFORE_POTENTIAL_GC (); TOP = Fforward_line (TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bchar_syntax: + OPCODE(Bchar_syntax): BEFORE_POTENTIAL_GC (); CHECK_NUMBER (TOP); AFTER_POTENTIAL_GC (); XSETFASTINT (TOP, syntax_code_spec[(int) SYNTAX (XINT (TOP))]); - break; + Next(); - case Bbuffer_substring: + OPCODE(Bbuffer_substring): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fbuffer_substring (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bdelete_region: + OPCODE(Bdelete_region): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fdelete_region (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bnarrow_to_region: + OPCODE(Bnarrow_to_region): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fnarrow_to_region (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bwiden: + OPCODE(Bwiden): BEFORE_POTENTIAL_GC (); PUSH (Fwiden ()); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bend_of_line: + OPCODE(Bend_of_line): BEFORE_POTENTIAL_GC (); TOP = Fend_of_line (TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bset_marker: + OPCODE(Bset_marker): { Lisp_Object v1, v2; BEFORE_POTENTIAL_GC (); @@ -1472,72 +1712,72 @@ v2 = POP; TOP = Fset_marker (TOP, v2, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bmatch_beginning: + OPCODE(Bmatch_beginning): BEFORE_POTENTIAL_GC (); TOP = Fmatch_beginning (TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bmatch_end: + OPCODE(Bmatch_end): BEFORE_POTENTIAL_GC (); TOP = Fmatch_end (TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bupcase: + OPCODE(Bupcase): BEFORE_POTENTIAL_GC (); TOP = Fupcase (TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bdowncase: + OPCODE(Bdowncase): BEFORE_POTENTIAL_GC (); TOP = Fdowncase (TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bstringeqlsign: + OPCODE(Bstringeqlsign): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fstring_equal (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bstringlss: + OPCODE(Bstringlss): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fstring_lessp (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bequal: + OPCODE(Bequal): { Lisp_Object v1; v1 = POP; TOP = Fequal (TOP, v1); - break; + Next(); } - case Bnthcdr: + OPCODE(Bnthcdr): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fnthcdr (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Belt: + OPCODE(Belt): { Lisp_Object v1, v2; if (CONSP (TOP)) @@ -1583,56 +1823,56 @@ TOP = Felt (TOP, v1); AFTER_POTENTIAL_GC (); } - break; + Next(); } - case Bmember: + OPCODE(Bmember): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fmember (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bassq: + OPCODE(Bassq): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fassq (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bnreverse: + OPCODE(Bnreverse): BEFORE_POTENTIAL_GC (); TOP = Fnreverse (TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bsetcar: + OPCODE(Bsetcar): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fsetcar (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bsetcdr: + OPCODE(Bsetcdr): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fsetcdr (TOP, v1); AFTER_POTENTIAL_GC (); - break; + Next(); } - case Bcar_safe: + OPCODE(Bcar_safe): { Lisp_Object v1; v1 = TOP; @@ -1640,10 +1880,10 @@ TOP = XCAR (v1); else TOP = Qnil; - break; + Next(); } - case Bcdr_safe: + OPCODE(Bcdr_safe): { Lisp_Object v1; v1 = TOP; @@ -1651,42 +1891,42 @@ TOP = XCDR (v1); else TOP = Qnil; - break; + Next(); } - case Bnconc: + OPCODE(Bnconc): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fnconc (2, &TOP); AFTER_POTENTIAL_GC (); - break; + Next(); - case Bnumberp: + OPCODE(Bnumberp): TOP = (NUMBERP (TOP) ? Qt : Qnil); - break; + Next(); - case Bintegerp: + OPCODE(Bintegerp): TOP = INTEGERP (TOP) ? Qt : Qnil; - break; + Next(); #ifdef BYTE_CODE_SAFE - case Bset_mark: + OPCODE(Bset_mark): BEFORE_POTENTIAL_GC (); error ("set-mark is an obsolete bytecode"); AFTER_POTENTIAL_GC (); - break; - case Bscan_buffer: + Next(); + OPCODE(Bscan_buffer): BEFORE_POTENTIAL_GC (); error ("scan-buffer is an obsolete bytecode"); AFTER_POTENTIAL_GC (); - break; + Next(); #endif - case 0: + OPCODE(0): abort (); - case 255: - default: + OPCODE(255): + DEFAULT: #ifdef BYTE_CODE_SAFE if (op < Bconstant) { @@ -1700,8 +1940,12 @@ #else PUSH (vectorp[op - Bconstant]); #endif + Next(); + +#ifndef THREADED_CODE } } +#endif /* !THREADED_CODE */ exit: