Use block statements in cases and declare v1 and v2

locally there.  Rearrange case statements so that thos most
frequently executed come first.  Avoid goto's in frequently
executed cases.

1 files changed, 519 insertions, 298 deletions

diff --git a/src/bytecode.c b/src/bytecode.c
index fb94cf8e1d7..57639d97972 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -225,6 +225,7 @@ Lisp_Object Qbytecode;
 #define Bconstant 0300
 #define CONSTANTLIM 0100
 
+
 /* Structure describing a value stack used during byte-code execution
    in Fbyte_code.  */
 
@@ -260,6 +261,7 @@ struct byte_stack
 
 struct byte_stack *byte_stack_list;
 
+
 /* Mark objects on byte_stack_list.  Called during GC.  */
 
 void
@@ -299,22 +301,20 @@ relocate_byte_pcs ()
       }
 }
 
-
 
 /* Fetch the next byte from the bytecode stream */
 
 #define FETCH *stack.pc++
 
-/* Fetch two bytes from the bytecode stream
- and make a 16-bit number out of them */
+/* Fetch two bytes from the bytecode stream and make a 16-bit number
+   out of them */
 
 #define FETCH2 (op = FETCH, op + (FETCH << 8))
 
-/* Push x onto the execution stack. */
-
-/* This used to be #define PUSH(x) (*++stackp = (x)) This oddity is
-   necessary because Alliant can't be bothered to compile the
-   preincrement operator properly, as of 4/91.  -JimB */
+/* Push x onto the execution stack.  This used to be #define PUSH(x)
+   (*++stackp = (x)) This oddity is necessary because Alliant can't be
+   bothered to compile the preincrement operator properly, as of 4/91.
+   -JimB */
 
 #define PUSH(x) (top++, *top = (x))
 
@@ -331,7 +331,7 @@ relocate_byte_pcs ()
 
 #define TOP (*top)
 
-/* Actions that must performed before and after calling a function
+/* Actions that must be performed before and after calling a function
    that might GC.  */
 
 #define BEFORE_POTENTIAL_GC()	stack.top = top
@@ -353,14 +353,14 @@ relocate_byte_pcs ()
 
 #ifdef BYTE_CODE_SAFE
 
-#define CHECK_RANGE(ARG)			\
+#define CHECK_RANGE(ARG) \
   if (ARG >= bytestr_length) abort ()
 
-#else
+#else /* not BYTE_CODE_SAFE */
 
 #define CHECK_RANGE(ARG)
 
-#endif
+#endif /* not BYTE_CODE_SAFE */
 
 
 DEFUN ("byte-code", Fbyte_code, Sbyte_code, 3, 3, 0,
@@ -378,8 +378,7 @@ If the third argument is incorrect, Emacs may crash.")
   int prev_op;
 #endif
   int op;
-  Lisp_Object v1, v2;
-  Lisp_Object *stackp;
+  /* Lisp_Object v1, v2; */
   Lisp_Object *vectorp = XVECTOR (vector)->contents;
 #ifdef BYTE_CODE_SAFE
   int const_length = XVECTOR (vector)->size;
@@ -388,6 +387,7 @@ If the third argument is incorrect, Emacs may crash.")
   int bytestr_length = STRING_BYTES (XSTRING (bytestr));
   struct byte_stack stack;
   Lisp_Object *top;
+  Lisp_Object result;
 
   CHECK_STRING (bytestr, 0);
   if (!VECTORP (vector))
@@ -423,38 +423,92 @@ If the third argument is incorrect, Emacs may crash.")
       prev_op = this_op;
       this_op = op = FETCH;
       METER_CODE (prev_op, op);
-      switch (op)
 #else
-      switch (op = FETCH)
+      op = FETCH;
 #endif
-	{
-	case Bvarref+6:
-	  op = FETCH;
-	  goto varref;
 
-	case Bvarref+7:
+      switch (op)
+	{
+	case Bvarref + 7:
 	  op = FETCH2;
 	  goto varref;
 
-	case Bvarref: case Bvarref+1: case Bvarref+2: case Bvarref+3:
-	case Bvarref+4: case Bvarref+5:
+	case Bvarref: 
+	case Bvarref + 1: 
+	case Bvarref + 2: 
+	case Bvarref + 3:
+	case Bvarref + 4: 
+	case Bvarref + 5:
 	  op = op - Bvarref;
+	  goto varref;
+
+	/* This seems to be the most frequently executed byte-code
+	   among the Bvarref's, so avoid a goto here.  */
+	case Bvarref+6:
+	  op = FETCH;
 	varref:
-	  v1 = vectorp[op];
-	  if (!SYMBOLP (v1))
-	    v2 = Fsymbol_value (v1);
-	  else
+	  {
+	    Lisp_Object v1, v2;
+
+	    v1 = vectorp[op];
+	    if (SYMBOLP (v1))
+	      {
+		v2 = XSYMBOL (v1)->value;
+		if (MISCP (v2) || EQ (v2, Qunbound))
+		  v2 = Fsymbol_value (v1);
+	      }
+	    else
+	      v2 = Fsymbol_value (v1);
+	    PUSH (v2);
+	    break;
+	  }
+
+	case Bgotoifnil:
+	  MAYBE_GC ();
+	  op = FETCH2;
+	  if (NILP (POP))
 	    {
-	      v2 = XSYMBOL (v1)->value;
-	      if (MISCP (v2) || EQ (v2, Qunbound))
-		v2 = Fsymbol_value (v1);
+	      QUIT;
+	      CHECK_RANGE (op);
+	      stack.pc = stack.byte_string_start + op;
 	    }
-	  PUSH (v2);
 	  break;
 
-	case Bvarset+6:
-	  op = FETCH;
-	  goto varset;
+	case Bcar:
+	  {
+	    Lisp_Object v1;
+	    v1 = TOP;
+	    if (CONSP (v1)) TOP = XCAR (v1);
+	    else if (NILP (v1)) TOP = Qnil;
+	    else Fcar (wrong_type_argument (Qlistp, v1));
+	    break;
+	  }
+
+	case Beq:
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = EQ (v1, TOP) ? Qt : Qnil;
+	    break;
+	  }
+
+	case Bmemq:
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = Fmemq (TOP, v1);
+	    break;
+	  }
+
+	case Bcdr:
+	  {
+	    Lisp_Object v1;
+	    v1 = TOP;
+	    if (CONSP (v1)) TOP = XCDR (v1);
+	    else if (NILP (v1)) TOP = Qnil;
+	    else Fcdr (wrong_type_argument (Qlistp, v1));
+	    break;
+	  }
 
 	case Bvarset+7:
 	  op = FETCH2;
@@ -463,10 +517,25 @@ If the third argument is incorrect, Emacs may crash.")
 	case Bvarset: case Bvarset+1: case Bvarset+2: case Bvarset+3:
 	case Bvarset+4: case Bvarset+5:
 	  op -= Bvarset;
+	  goto varset;
+
+	case Bvarset+6:
+	  op = FETCH;
 	varset:
-	  Fset (vectorp[op], POP);
+	  set_internal (vectorp[op], POP, 0);
+	  /* Fset (vectorp[op], POP); */
 	  break;
 
+	case Bdup:
+	  {
+	    Lisp_Object v1;
+	    v1 = TOP;
+	    PUSH (v1);
+	    break;
+	  }
+
+	/* ------------------ */
+
 	case Bvarbind+6:
 	  op = FETCH;
 	  goto varbind;
@@ -494,24 +563,28 @@ If the third argument is incorrect, Emacs may crash.")
 	case Bcall+4: case Bcall+5:
 	  op -= Bcall;
 	docall:
-	  DISCARD (op);
+	  {
+	    DISCARD (op);
 #ifdef BYTE_CODE_METER
-	  if (byte_metering_on && SYMBOLP (TOP))
-	    {
-	      v1 = TOP;
-	      v2 = Fget (v1, Qbyte_code_meter);
-	      if (INTEGERP (v2)
-		  && XINT (v2) != ((1<<VALBITS)-1))
-		{
-		  XSETINT (v2, XINT (v2) + 1);
-		  Fput (v1, Qbyte_code_meter, v2);
-		}
-	    }
+	    if (byte_metering_on && SYMBOLP (TOP))
+	      {
+		Lisp_Object v1, v2;
+
+		v1 = TOP;
+		v2 = Fget (v1, Qbyte_code_meter);
+		if (INTEGERP (v2)
+		    && XINT (v2) != ((1<<VALBITS)-1))
+		  {
+		    XSETINT (v2, XINT (v2) + 1);
+		    Fput (v1, Qbyte_code_meter, v2);
+		  }
+	      }
 #endif
-	  BEFORE_POTENTIAL_GC ();
-	  TOP = Ffuncall (op + 1, &TOP);
-	  AFTER_POTENTIAL_GC ();
-	  break;
+	    BEFORE_POTENTIAL_GC ();
+	    TOP = Ffuncall (op + 1, &TOP);
+	    AFTER_POTENTIAL_GC ();
+	    break;
+	  }
 
 	case Bunbind+6:
 	  op = FETCH;
@@ -546,17 +619,6 @@ If the third argument is incorrect, Emacs may crash.")
 	  stack.pc = stack.byte_string_start + op;
 	  break;
 
-	case Bgotoifnil:
-	  MAYBE_GC ();
-	  op = FETCH2;
-	  if (NILP (POP))
-	    {
-	      QUIT;
-	      CHECK_RANGE (op);
-	      stack.pc = stack.byte_string_start + op;
-	    }
-	  break;
-
 	case Bgotoifnonnil:
 	  MAYBE_GC ();
 	  op = FETCH2;
@@ -641,18 +703,13 @@ If the third argument is incorrect, Emacs may crash.")
 	  break;
 
 	case Breturn:
-	  v1 = POP;
+	  result = POP;
 	  goto exit;
 
 	case Bdiscard:
 	  DISCARD (1);
 	  break;
 
-	case Bdup:
-	  v1 = TOP;
-	  PUSH (v1);
-	  break;
-
 	case Bconstant2:
 	  PUSH (vectorp[FETCH2]);
 	  break;
@@ -667,7 +724,9 @@ If the third argument is incorrect, Emacs may crash.")
 	  break;
 
 	case Bsave_window_excursion:
+	  BEFORE_POTENTIAL_GC ();
 	  TOP = Fsave_window_excursion (TOP);
+	  AFTER_POTENTIAL_GC ();
 	  break;
 
 	case Bsave_restriction:
@@ -675,11 +734,15 @@ If the third argument is incorrect, Emacs may crash.")
 	  break;
 
 	case Bcatch:
-	  v1 = POP;
-	  BEFORE_POTENTIAL_GC ();
-	  TOP = internal_catch (TOP, Feval, v1);
-	  AFTER_POTENTIAL_GC ();
-	  break;
+	  {
+	    Lisp_Object v1;
+
+	    v1 = POP;
+	    BEFORE_POTENTIAL_GC ();
+	    TOP = internal_catch (TOP, Feval, v1);
+	    AFTER_POTENTIAL_GC ();
+	    break;
+	  }
 
 	case Bunwind_protect:
 	  record_unwind_protect (0, POP);
@@ -687,49 +750,62 @@ If the third argument is incorrect, Emacs may crash.")
 	  break;
 
 	case Bcondition_case:
-	  v1 = POP;
-	  v1 = Fcons (POP, v1);
-	  BEFORE_POTENTIAL_GC ();
-	  TOP = Fcondition_case (Fcons (TOP, v1));
-	  AFTER_POTENTIAL_GC ();
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    v1 = Fcons (POP, v1);
+	    BEFORE_POTENTIAL_GC ();
+	    TOP = Fcondition_case (Fcons (TOP, v1));
+	    AFTER_POTENTIAL_GC ();
+	    break;
+	  }
 
 	case Btemp_output_buffer_setup:
+	  BEFORE_POTENTIAL_GC ();
 	  temp_output_buffer_setup (XSTRING (TOP)->data);
+	  AFTER_POTENTIAL_GC ();
 	  TOP = Vstandard_output;
 	  break;
 
 	case Btemp_output_buffer_show:
-	  v1 = POP;
-	  temp_output_buffer_show (TOP);
-	  TOP = v1;
-	  /* pop binding of standard-output */
-	  BEFORE_POTENTIAL_GC ();
-	  unbind_to (specpdl_ptr - specpdl - 1, Qnil);
-	  AFTER_POTENTIAL_GC ();
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    BEFORE_POTENTIAL_GC ();
+	    temp_output_buffer_show (TOP);
+	    TOP = v1;
+	    /* pop binding of standard-output */
+	    unbind_to (specpdl_ptr - specpdl - 1, Qnil);
+	    AFTER_POTENTIAL_GC ();
+	    break;
+	  }
 
 	case Bnth:
-	  v1 = POP;
-	  v2 = TOP;
-	nth_entry:
-	  CHECK_NUMBER (v2, 0);
-	  op = XINT (v2);
-	  immediate_quit = 1;
-	  while (--op >= 0)
-	    {
-	      if (CONSP (v1))
-		v1 = XCDR (v1);
-	      else if (!NILP (v1))
-		{
-		  immediate_quit = 0;
-		  v1 = wrong_type_argument (Qlistp, v1);
-		  immediate_quit = 1;
-		  op++;
-		}
-	    }
-	  immediate_quit = 0;
-	  goto docar;
+	  {
+	    Lisp_Object v1, v2;
+	    v1 = POP;
+	    v2 = TOP;
+	    CHECK_NUMBER (v2, 0);
+	    op = XINT (v2);
+	    immediate_quit = 1;
+	    while (--op >= 0)
+	      {
+		if (CONSP (v1))
+		  v1 = XCDR (v1);
+		else if (!NILP (v1))
+		  {
+		    immediate_quit = 0;
+		    v1 = wrong_type_argument (Qlistp, v1);
+		    immediate_quit = 1;
+		    op++;
+		  }
+	      }
+	    immediate_quit = 0;
+	    if (CONSP (v1)) TOP = XCAR (v1);
+	    else if (NILP (v1)) TOP = Qnil;
+	    else Fcar (wrong_type_argument (Qlistp, v1));
+	    break;
+	  }
 
 	case Bsymbolp:
 	  TOP = SYMBOLP (TOP) ? Qt : Qnil;
@@ -747,48 +823,29 @@ If the third argument is incorrect, Emacs may crash.")
 	  TOP = CONSP (TOP) || NILP (TOP) ? Qt : Qnil;
 	  break;
 
-	case Beq:
-	  v1 = POP;
-	  TOP = EQ (v1, TOP) ? Qt : Qnil;
-	  break;
-
-	case Bmemq:
-	  v1 = POP;
-	  TOP = Fmemq (TOP, v1);
-	  break;
-
 	case Bnot:
 	  TOP = NILP (TOP) ? Qt : Qnil;
 	  break;
 
-	case Bcar:
-	  v1 = TOP;
-	docar:
-	  if (CONSP (v1)) TOP = XCAR (v1);
-	  else if (NILP (v1)) TOP = Qnil;
-	  else Fcar (wrong_type_argument (Qlistp, v1));
-	  break;
-
-	case Bcdr:
-	  v1 = TOP;
-	  if (CONSP (v1)) TOP = XCDR (v1);
-	  else if (NILP (v1)) TOP = Qnil;
-	  else Fcdr (wrong_type_argument (Qlistp, v1));
-	  break;
-
 	case Bcons:
-	  v1 = POP;
-	  TOP = Fcons (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = Fcons (TOP, v1);
+	    break;
+	  }
 
 	case Blist1:
 	  TOP = Fcons (TOP, Qnil);
 	  break;
 
 	case Blist2:
-	  v1 = POP;
-	  TOP = Fcons (TOP, Fcons (v1, Qnil));
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = Fcons (TOP, Fcons (v1, Qnil));
+	    break;
+	  }
 
 	case Blist3:
 	  DISCARD (2);
@@ -811,14 +868,20 @@ If the third argument is incorrect, Emacs may crash.")
 	  break;
 
 	case Baref:
-    	  v1 = POP;
-	  TOP = Faref (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = Faref (TOP, v1);
+	    break;
+	  }
 
 	case Baset:
-	  v2 = POP; v1 = POP;
-	  TOP = Faset (TOP, v1, v2);
-	  break;
+	  {
+	    Lisp_Object v1, v2;
+	    v2 = POP; v1 = POP;
+	    TOP = Faset (TOP, v1, v2);
+	    break;
+	  }
 
 	case Bsymbol_value:
 	  TOP = Fsymbol_value (TOP);
@@ -829,24 +892,36 @@ If the third argument is incorrect, Emacs may crash.")
 	  break;
 
 	case Bset:
-	  v1 = POP;
-	  TOP = Fset (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = Fset (TOP, v1);
+	    break;
+	  }
 
 	case Bfset:
-	  v1 = POP;
-	  TOP = Ffset (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = Ffset (TOP, v1);
+	    break;
+	  }
 
 	case Bget:
-	  v1 = POP;
-	  TOP = Fget (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = Fget (TOP, v1);
+	    break;
+	  }
 
 	case Bsubstring:
-	  v2 = POP; v1 = POP;
-	  TOP = Fsubstring (TOP, v1, v2);
-	  break;
+	  {
+	    Lisp_Object v1, v2;
+	    v2 = POP; v1 = POP;
+	    TOP = Fsubstring (TOP, v1, v2);
+	    break;
+	  }
 
 	case Bconcat2:
 	  DISCARD (1);
@@ -870,64 +945,85 @@ If the third argument is incorrect, Emacs may crash.")
 	  break;
 
 	case Bsub1:
-	  v1 = TOP;
-	  if (INTEGERP (v1))
-	    {
-	      XSETINT (v1, XINT (v1) - 1);
-	      TOP = v1;
-	    }
-	  else
-	    TOP = Fsub1 (v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = TOP;
+	    if (INTEGERP (v1))
+	      {
+		XSETINT (v1, XINT (v1) - 1);
+		TOP = v1;
+	      }
+	    else
+	      TOP = Fsub1 (v1);
+	    break;
+	  }
 
 	case Badd1:
-	  v1 = TOP;
-	  if (INTEGERP (v1))
-	    {
-	      XSETINT (v1, XINT (v1) + 1);
-	      TOP = v1;
-	    }
-	  else
-	    TOP = Fadd1 (v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = TOP;
+	    if (INTEGERP (v1))
+	      {
+		XSETINT (v1, XINT (v1) + 1);
+		TOP = v1;
+	      }
+	    else
+	      TOP = Fadd1 (v1);
+	    break;
+	  }
 
 	case Beqlsign:
-	  v2 = POP; v1 = TOP;
-	  CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v1, 0);
-	  CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v2, 0);
+	  {
+	    Lisp_Object v1, v2;
+	    v2 = POP; v1 = TOP;
+	    CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v1, 0);
+	    CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v2, 0);
 #ifdef LISP_FLOAT_TYPE
-	  if (FLOATP (v1) || FLOATP (v2))
-	    {
-	      double f1, f2;
-
-	      f1 = (FLOATP (v1) ? XFLOAT_DATA (v1) : XINT (v1));
-	      f2 = (FLOATP (v2) ? XFLOAT_DATA (v2) : XINT (v2));
-	      TOP = (f1 == f2 ? Qt : Qnil);
-	    }
-	  else
+	    if (FLOATP (v1) || FLOATP (v2))
+	      {
+		double f1, f2;
+
+		f1 = (FLOATP (v1) ? XFLOAT_DATA (v1) : XINT (v1));
+		f2 = (FLOATP (v2) ? XFLOAT_DATA (v2) : XINT (v2));
+		TOP = (f1 == f2 ? Qt : Qnil);
+	      }
+	    else
 #endif
-	    TOP = (XINT (v1) == XINT (v2) ? Qt : Qnil);
-	  break;
+	      TOP = (XINT (v1) == XINT (v2) ? Qt : Qnil);
+	    break;
+	  }
 
 	case Bgtr:
-	  v1 = POP;
-	  TOP = Fgtr (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = Fgtr (TOP, v1);
+	    break;
+	  }
 
 	case Blss:
-	  v1 = POP;
-	  TOP = Flss (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = Flss (TOP, v1);
+	    break;
+	  }
 
 	case Bleq:
-	  v1 = POP;
-	  TOP = Fleq (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = Fleq (TOP, v1);
+	    break;
+	  }
 
 	case Bgeq:
-	  v1 = POP;
-	  TOP = Fgeq (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = Fgeq (TOP, v1);
+	    break;
+	  }
 
 	case Bdiff:
 	  DISCARD (1);
@@ -935,15 +1031,18 @@ If the third argument is incorrect, Emacs may crash.")
 	  break;
 
 	case Bnegate:
-	  v1 = TOP;
-	  if (INTEGERP (v1))
-	    {
-	      XSETINT (v1, - XINT (v1));
-	      TOP = v1;
-	    }
-	  else
-	    TOP = Fminus (1, &TOP);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = TOP;
+	    if (INTEGERP (v1))
+	      {
+		XSETINT (v1, - XINT (v1));
+		TOP = v1;
+	      }
+	    else
+	      TOP = Fminus (1, &TOP);
+	    break;
+	  }
 
 	case Bplus:
 	  DISCARD (1);
@@ -971,60 +1070,89 @@ If the third argument is incorrect, Emacs may crash.")
 	  break;
 
 	case Brem:
-	  v1 = POP;
-	  TOP = Frem (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = Frem (TOP, v1);
+	    break;
+	  }
 
 	case Bpoint:
-	  XSETFASTINT (v1, PT);
-	  PUSH (v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    XSETFASTINT (v1, PT);
+	    PUSH (v1);
+	    break;
+	  }
 
 	case Bgoto_char:
+	  BEFORE_POTENTIAL_GC ();
 	  TOP = Fgoto_char (TOP);
+	  AFTER_POTENTIAL_GC ();
 	  break;
 
 	case Binsert:
+	  BEFORE_POTENTIAL_GC ();
 	  TOP = Finsert (1, &TOP);
+	  AFTER_POTENTIAL_GC ();
 	  break;
 
 	case BinsertN:
 	  op = FETCH;
 	  DISCARD (op - 1);
+	  BEFORE_POTENTIAL_GC ();
 	  TOP = Finsert (op, &TOP);
+	  AFTER_POTENTIAL_GC ();
 	  break;
 
 	case Bpoint_max:
-	  XSETFASTINT (v1, ZV);
-	  PUSH (v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    XSETFASTINT (v1, ZV);
+	    PUSH (v1);
+	    break;
+	  }
 
 	case Bpoint_min:
-	  XSETFASTINT (v1, BEGV);
-	  PUSH (v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    XSETFASTINT (v1, BEGV);
+	    PUSH (v1);
+	    break;
+	  }
 
 	case Bchar_after:
 	  TOP = Fchar_after (TOP);
 	  break;
 
 	case Bfollowing_char:
-	  v1 = Ffollowing_char ();
-	  PUSH (v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = Ffollowing_char ();
+	    PUSH (v1);
+	    break;
+	  }
 
 	case Bpreceding_char:
-	  v1 = Fprevious_char ();
-	  PUSH (v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = Fprevious_char ();
+	    PUSH (v1);
+	    break;
+	  }
 
 	case Bcurrent_column:
-	  XSETFASTINT (v1, current_column ());
-	  PUSH (v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    XSETFASTINT (v1, current_column ());
+	    PUSH (v1);
+	    break;
+	  }
 
 	case Bindent_to:
+	  BEFORE_POTENTIAL_GC ();
 	  TOP = Findent_to (TOP, Qnil);
+	  AFTER_POTENTIAL_GC ();
 	  break;
 
 	case Beolp:
@@ -1048,7 +1176,9 @@ If the third argument is incorrect, Emacs may crash.")
 	  break;
 
 	case Bset_buffer:
+	  BEFORE_POTENTIAL_GC ();
 	  TOP = Fset_buffer (TOP);
+	  AFTER_POTENTIAL_GC ();
 	  break;
 
 	case Binteractive_p:
@@ -1056,61 +1186,98 @@ If the third argument is incorrect, Emacs may crash.")
 	  break;
 
 	case Bforward_char:
+	  BEFORE_POTENTIAL_GC ();
 	  TOP = Fforward_char (TOP);
+	  AFTER_POTENTIAL_GC ();
 	  break;
 
 	case Bforward_word:
+	  BEFORE_POTENTIAL_GC ();
 	  TOP = Fforward_word (TOP);
+	  AFTER_POTENTIAL_GC ();
 	  break;
 
 	case Bskip_chars_forward:
-	  v1 = POP;
-	  TOP = Fskip_chars_forward (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    BEFORE_POTENTIAL_GC ();
+	    TOP = Fskip_chars_forward (TOP, v1);
+	    AFTER_POTENTIAL_GC ();
+	    break;
+	  }
 
 	case Bskip_chars_backward:
-	  v1 = POP;
-	  TOP = Fskip_chars_backward (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    BEFORE_POTENTIAL_GC ();
+	    TOP = Fskip_chars_backward (TOP, v1);
+	    AFTER_POTENTIAL_GC ();
+	    break;
+	  }
 
 	case Bforward_line:
+	  BEFORE_POTENTIAL_GC ();
 	  TOP = Fforward_line (TOP);
+	  AFTER_POTENTIAL_GC ();
 	  break;
 
 	case Bchar_syntax:
 	  CHECK_NUMBER (TOP, 0);
-	  XSETFASTINT (TOP,
-		       syntax_code_spec[(int) SYNTAX (XINT (TOP))]);
+	  XSETFASTINT (TOP, syntax_code_spec[(int) SYNTAX (XINT (TOP))]);
 	  break;
 
 	case Bbuffer_substring:
-	  v1 = POP;
-	  TOP = Fbuffer_substring (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    BEFORE_POTENTIAL_GC ();
+	    TOP = Fbuffer_substring (TOP, v1);
+	    AFTER_POTENTIAL_GC ();
+	    break;
+	  }
 
 	case Bdelete_region:
-	  v1 = POP;
-	  TOP = Fdelete_region (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    BEFORE_POTENTIAL_GC ();
+	    TOP = Fdelete_region (TOP, v1);
+	    AFTER_POTENTIAL_GC ();
+	    break;
+	  }
 
 	case Bnarrow_to_region:
-	  v1 = POP;
-	  TOP = Fnarrow_to_region (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    BEFORE_POTENTIAL_GC ();
+	    TOP = Fnarrow_to_region (TOP, v1);
+	    AFTER_POTENTIAL_GC ();
+	    break;
+	  }
 
 	case Bwiden:
+	  BEFORE_POTENTIAL_GC ();
 	  PUSH (Fwiden ());
+	  AFTER_POTENTIAL_GC ();
 	  break;
 
 	case Bend_of_line:
+	  BEFORE_POTENTIAL_GC ();
 	  TOP = Fend_of_line (TOP);
+	  AFTER_POTENTIAL_GC ();
 	  break;
 
 	case Bset_marker:
-	  v1 = POP;
-	  v2 = POP;
-	  TOP = Fset_marker (TOP, v2, v1);
-	  break;
+	  {
+	    Lisp_Object v1, v2;
+	    v1 = POP;
+	    v2 = POP;
+	    TOP = Fset_marker (TOP, v2, v1);
+	    break;
+	  }
 
 	case Bmatch_beginning:
 	  TOP = Fmatch_beginning (TOP);
@@ -1129,76 +1296,130 @@ If the third argument is incorrect, Emacs may crash.")
 	break;
 
 	case Bstringeqlsign:
-	  v1 = POP;
-	  TOP = Fstring_equal (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = Fstring_equal (TOP, v1);
+	    break;
+	  }
 
 	case Bstringlss:
-	  v1 = POP;
-	  TOP = Fstring_lessp (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = Fstring_lessp (TOP, v1);
+	    break;
+	  }
 
 	case Bequal:
-	  v1 = POP;
-	  TOP = Fequal (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = Fequal (TOP, v1);
+	    break;
+	  }
 
 	case Bnthcdr:
-	  v1 = POP;
-	  TOP = Fnthcdr (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = Fnthcdr (TOP, v1);
+	    break;
+	  }
 
 	case Belt:
-	  if (CONSP (TOP))
-	    {
-	      /* Exchange args and then do nth.  */
-	      v2 = POP;
-	      v1 = TOP;
-	      goto nth_entry;
-	    }
-	  v1 = POP;
-	  TOP = Felt (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1, v2;
+	    if (CONSP (TOP))
+	      {
+		/* Exchange args and then do nth.  */
+		v2 = POP;
+		v1 = TOP;
+		CHECK_NUMBER (v2, 0);
+		op = XINT (v2);
+		immediate_quit = 1;
+		while (--op >= 0)
+		  {
+		    if (CONSP (v1))
+		      v1 = XCDR (v1);
+		    else if (!NILP (v1))
+		      {
+			immediate_quit = 0;
+			v1 = wrong_type_argument (Qlistp, v1);
+			immediate_quit = 1;
+			op++;
+		      }
+		  }
+		immediate_quit = 0;
+		if (CONSP (v1)) TOP = XCAR (v1);
+		else if (NILP (v1)) TOP = Qnil;
+		else Fcar (wrong_type_argument (Qlistp, v1));
+	      }
+	    else
+	      {
+		v1 = POP;
+		TOP = Felt (TOP, v1);
+	      }
+	    break;
+	  }
 
 	case Bmember:
-	  v1 = POP;
-	  TOP = Fmember (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = Fmember (TOP, v1);
+	    break;
+	  }
 
 	case Bassq:
-	  v1 = POP;
-	  TOP = Fassq (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = Fassq (TOP, v1);
+	    break;
+	  }
 
 	case Bnreverse:
 	  TOP = Fnreverse (TOP);
 	  break;
 
 	case Bsetcar:
-	  v1 = POP;
-	  TOP = Fsetcar (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = Fsetcar (TOP, v1);
+	    break;
+	  }
 
 	case Bsetcdr:
-	  v1 = POP;
-	  TOP = Fsetcdr (TOP, v1);
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = POP;
+	    TOP = Fsetcdr (TOP, v1);
+	    break;
+	  }
 
 	case Bcar_safe:
-	  v1 = TOP;
-	  if (CONSP (v1))
-	    TOP = XCAR (v1);
-	  else
-	    TOP = Qnil;
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = TOP;
+	    if (CONSP (v1))
+	      TOP = XCAR (v1);
+	    else
+	      TOP = Qnil;
+	    break;
+	  }
 
 	case Bcdr_safe:
-	  v1 = TOP;
-	  if (CONSP (v1))
-	    TOP = XCDR (v1);
-	  else
-	    TOP = Qnil;
-	  break;
+	  {
+	    Lisp_Object v1;
+	    v1 = TOP;
+	    if (CONSP (v1))
+	      TOP = XCDR (v1);
+	    else
+	      TOP = Qnil;
+	    break;
+	  }
 
 	case Bnconc:
 	  DISCARD (1);
@@ -1247,7 +1468,7 @@ If the third argument is incorrect, Emacs may crash.")
     abort ();
 #endif
   
-  return v1;
+  return result;
 }
 
 void