/* Execution of byte code produced by bytecomp.el.
- Copyright (C) 1985, 1986, 1987, 1988, 1992 Free Software Foundation, Inc.
+ Copyright (C) 1985, 1986, 1987, 1988, 1993 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
+the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Emacs is distributed in the hope that it will be useful,
You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
-hacked on by jwz 17-jun-91
+hacked on by jwz@lucid.com 17-jun-91
o added a compile-time switch to turn on simple sanity checking;
o put back the obsolete byte-codes for error-detection;
- o put back fset, symbol-function, and read-char because I don't
- see any reason for them to have been removed;
o added a new instruction, unbind_all, which I will use for
tail-recursion elimination;
- o made temp_output_buffer_show() be called with the right number
+ o made temp_output_buffer_show be called with the right number
of args;
o made the new bytecodes be called with args in the right order;
o added metering support.
o all conditionals now only do QUIT if they jump.
*/
-
-#include "config.h"
+#include <config.h>
#include "lisp.h"
#include "buffer.h"
+#include "charset.h"
#include "syntax.h"
-/* Define this to enable some minor sanity checking
- (useful for debugging the byte compiler...)
- */
-#define BYTE_CODE_SAFE
-
-/* Define this to enable generation of a histogram of byte-op usage.
+/*
+ * define BYTE_CODE_SAFE to enable some minor sanity checking (useful for
+ * debugging the byte compiler...)
+ *
+ * define BYTE_CODE_METER to enable generation of a byte-op usage histogram.
*/
-#define BYTE_CODE_METER
+/* #define BYTE_CODE_SAFE */
+/* #define BYTE_CODE_METER */
\f
#ifdef BYTE_CODE_METER
-Lisp_Object Vbyte_code_meter;
+Lisp_Object Vbyte_code_meter, Qbyte_code_meter;
int byte_metering_on;
-# define METER_2(code1,code2) \
+#define METER_2(code1, code2) \
XFASTINT (XVECTOR (XVECTOR (Vbyte_code_meter)->contents[(code1)]) \
->contents[(code2)])
-# define METER_1(code) METER_2 (0,(code))
-
-# define METER_CODE(last_code, this_code) { \
- if (byte_metering_on) { \
- if (METER_1 (this_code) != ((1<<VALBITS)-1)) \
- METER_1 (this_code) ++; \
- if (last_code && \
- METER_2 (last_code,this_code) != ((1<<VALBITS)-1)) \
- METER_2 (last_code,this_code) ++; \
- } \
- }
+#define METER_1(code) METER_2 (0, (code))
+
+#define METER_CODE(last_code, this_code) \
+{ \
+ if (byte_metering_on) \
+ { \
+ if (METER_1 (this_code) != ((1<<VALBITS)-1)) \
+ METER_1 (this_code)++; \
+ if (last_code \
+ && METER_2 (last_code, this_code) != ((1<<VALBITS)-1))\
+ METER_2 (last_code, this_code)++; \
+ } \
+}
-#else /* ! BYTE_CODE_METER */
+#else /* no BYTE_CODE_METER */
-# define meter_code(last_code, this_code)
+#define METER_CODE(last_code, this_code)
-#endif
+#endif /* no BYTE_CODE_METER */
\f
Lisp_Object Qbytecode;
#define Baref 0110
#define Baset 0111
#define Bsymbol_value 0112
-#define Bsymbol_function 0113 /* no longer generated as of v19 */
+#define Bsymbol_function 0113
#define Bset 0114
-#define Bfset 0115 /* no longer generated as of v19 */
+#define Bfset 0115
#define Bget 0116
#define Bsubstring 0117
#define Bconcat2 0120
#define Bmult 0137
#define Bpoint 0140
-#define Bmark 0141 /* no longer generated as of v18 */
+/* Was Bmark in v17. */
+#define Bsave_current_buffer 0141
#define Bgoto_char 0142
#define Binsert 0143
#define Bpoint_max 0144
#define Bbobp 0157
#define Bcurrent_buffer 0160
#define Bset_buffer 0161
-#define Bread_char 0162
+#define Bsave_current_buffer_1 0162 /* Replacing Bsave_current_buffer. */
+#define Bread_char 0162 /* No longer generated as of v19 */
#define Bset_mark 0163 /* this loser is no longer generated as of v18 */
#define Binteractive_p 0164 /* Needed since interactive-p takes unevalled args */
#define Bdelete_region 0174
#define Bnarrow_to_region 0175
#define Bwiden 0176
+#define Bend_of_line 0177
#define Bconstant2 0201
#define Bgoto 0202
#define Bunbind_all 0222
+#define Bset_marker 0223
+#define Bmatch_beginning 0224
+#define Bmatch_end 0225
+#define Bupcase 0226
+#define Bdowncase 0227
+
#define Bstringeqlsign 0230
#define Bstringlss 0231
#define Bequal 0232
#define Bnumberp 0247
#define Bintegerp 0250
+#define BRgoto 0252
+#define BRgotoifnil 0253
+#define BRgotoifnonnil 0254
+#define BRgotoifnilelsepop 0255
+#define BRgotoifnonnilelsepop 0256
+
+#define BlistN 0257
+#define BconcatN 0260
+#define BinsertN 0261
+
#define Bconstant 0300
#define CONSTANTLIM 0100
+
+\f
+/* Structure describing a value stack used during byte-code execution
+ in Fbyte_code. */
+
+struct byte_stack
+{
+ /* Program counter. This points into the byte_string below
+ and is relocated when that string is relocated. */
+ unsigned char *pc;
+
+ /* Top and bottom of stack. The bottom points to an area of memory
+ allocated with alloca in Fbyte_code. */
+ Lisp_Object *top, *bottom;
+
+ /* The string containing the byte-code, and its current address.
+ Storing this here protects it from GC because mark_byte_stack
+ marks it. */
+ Lisp_Object byte_string;
+ unsigned char *byte_string_start;
+
+ /* The vector of constants used during byte-code execution. Storing
+ this here protects it from GC because mark_byte_stack marks it. */
+ Lisp_Object constants;
+
+ /* Next entry in byte_stack_list. */
+ struct byte_stack *next;
+};
+
+/* A list of currently active byte-code execution value stacks.
+ Fbyte_code adds an entry to the head of this list before it starts
+ processing byte-code, and it removed the entry again when it is
+ done. Signalling an error truncates the list analoguous to
+ gcprolist. */
+
+struct byte_stack *byte_stack_list;
+
+\f
+/* Mark objects on byte_stack_list. Called during GC. */
+
+void
+mark_byte_stack ()
+{
+ struct byte_stack *stack;
+ Lisp_Object *obj;
+
+ for (stack = byte_stack_list; stack; stack = stack->next)
+ {
+ if (!stack->top)
+ abort ();
+
+ for (obj = stack->bottom; obj <= stack->top; ++obj)
+ if (!XMARKBIT (*obj))
+ {
+ mark_object (obj);
+ XMARK (*obj);
+ }
+
+ if (!XMARKBIT (stack->byte_string))
+ {
+ mark_object (&stack->byte_string);
+ XMARK (stack->byte_string);
+ }
+
+ if (!XMARKBIT (stack->constants))
+ {
+ mark_object (&stack->constants);
+ XMARK (stack->constants);
+ }
+ }
+}
+
+
+/* Unmark objects in the stacks on byte_stack_list. Relocate program
+ counters. Called when GC has completed. */
+
+void
+unmark_byte_stack ()
+{
+ struct byte_stack *stack;
+ Lisp_Object *obj;
+
+ for (stack = byte_stack_list; stack; stack = stack->next)
+ {
+ for (obj = stack->bottom; obj <= stack->top; ++obj)
+ XUNMARK (*obj);
+
+ XUNMARK (stack->byte_string);
+ XUNMARK (stack->constants);
+
+ if (stack->byte_string_start != XSTRING (stack->byte_string)->data)
+ {
+ int offset = stack->pc - stack->byte_string_start;
+ stack->byte_string_start = XSTRING (stack->byte_string)->data;
+ stack->pc = stack->byte_string_start + offset;
+ }
+ }
+}
+
\f
/* Fetch the next byte from the bytecode stream */
-#define FETCH *pc++
+#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. */
+/* 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 */
-/* 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) (stackp++, *stackp = (x))
+#define PUSH(x) (top++, *top = (x))
/* Pop a value off the execution stack. */
-#define POP (*stackp--)
+#define POP (*top--)
/* Discard n values from the execution stack. */
-#define DISCARD(n) (stackp -= (n))
+#define DISCARD(n) (top -= (n))
-/* Get the value which is at the top of the execution stack, but don't pop it. */
+/* Get the value which is at the top of the execution stack, but don't
+ pop it. */
+
+#define TOP (*top)
+
+/* Actions that must be performed before and after calling a function
+ that might GC. */
+
+#define BEFORE_POTENTIAL_GC() stack.top = top
+#define AFTER_POTENTIAL_GC() stack.top = NULL
+
+/* Garbage collect if we have consed enough since the last time.
+ We do this at every branch, to avoid loops that never GC. */
+
+#define MAYBE_GC() \
+ if (consing_since_gc > gc_cons_threshold) \
+ { \
+ BEFORE_POTENTIAL_GC (); \
+ Fgarbage_collect (); \
+ AFTER_POTENTIAL_GC (); \
+ } \
+ else
+
+/* Check for jumping out of range. */
+
+#ifdef BYTE_CODE_SAFE
+
+#define CHECK_RANGE(ARG) \
+ if (ARG >= bytestr_length) abort ()
+
+#else /* not BYTE_CODE_SAFE */
+
+#define CHECK_RANGE(ARG)
+
+#endif /* not BYTE_CODE_SAFE */
-#define TOP (*stackp)
DEFUN ("byte-code", Fbyte_code, Sbyte_code, 3, 3, 0,
"Function used internally in byte-compiled code.\n\
-The first argument is a string of byte code; the second, a vector of constants;\n\
-the third, the maximum stack depth used in this function.\n\
+The first argument, BYTESTR, is a string of byte code;\n\
+the second, VECTOR, a vector of constants;\n\
+the third, MAXDEPTH, the maximum stack depth used in this function.\n\
If the third argument is incorrect, Emacs may crash.")
(bytestr, vector, maxdepth)
Lisp_Object bytestr, vector, maxdepth;
{
- struct gcpro gcpro1, gcpro2, gcpro3;
int count = specpdl_ptr - specpdl;
#ifdef BYTE_CODE_METER
int this_op = 0;
int prev_op;
#endif
- register int op;
- unsigned char *pc;
- Lisp_Object *stack;
- register Lisp_Object *stackp;
- Lisp_Object *stacke;
- register Lisp_Object v1, v2;
- register Lisp_Object *vectorp = XVECTOR (vector)->contents;
+ int op;
+ /* Lisp_Object v1, v2; */
+ Lisp_Object *vectorp = XVECTOR (vector)->contents;
#ifdef BYTE_CODE_SAFE
- register int const_length = XVECTOR (vector)->size;
+ int const_length = XVECTOR (vector)->size;
+ Lisp_Object *stacke;
#endif
- /* Copy of BYTESTR, saved so we can tell if BYTESTR was relocated. */
- Lisp_Object string_saved;
- /* Cached address of beginning of string,
- valid if BYTESTR equals STRING_SAVED. */
- register unsigned char *strbeg;
+ int bytestr_length = STRING_BYTES (XSTRING (bytestr));
+ struct byte_stack stack;
+ Lisp_Object *top;
+ Lisp_Object result;
CHECK_STRING (bytestr, 0);
- if (XTYPE (vector) != Lisp_Vector)
+ if (!VECTORP (vector))
vector = wrong_type_argument (Qvectorp, vector);
CHECK_NUMBER (maxdepth, 2);
- stackp = (Lisp_Object *) alloca (XFASTINT (maxdepth) * sizeof (Lisp_Object));
- bzero (stackp, XFASTINT (maxdepth) * sizeof (Lisp_Object));
- GCPRO3 (bytestr, vector, *stackp);
- gcpro3.nvars = XFASTINT (maxdepth);
-
- --stackp;
- stack = stackp;
- stacke = stackp + XFASTINT (maxdepth);
-
- /* Initialize the saved pc-pointer for fetching from the string. */
- string_saved = bytestr;
- pc = XSTRING (string_saved)->data;
+ stack.byte_string = bytestr;
+ stack.pc = stack.byte_string_start = XSTRING (bytestr)->data;
+ stack.constants = vector;
+ stack.bottom = (Lisp_Object *) alloca (XFASTINT (maxdepth)
+ * sizeof (Lisp_Object));
+ top = stack.bottom - 1;
+ stack.top = NULL;
+ stack.next = byte_stack_list;
+ byte_stack_list = &stack;
+#ifdef BYTE_CODE_SAFE
+ stacke = stack.bottom - 1 + XFASTINT (maxdepth);
+#endif
+
while (1)
{
#ifdef BYTE_CODE_SAFE
- if (stackp > stacke)
- error (
- "Stack overflow in byte code (byte compiler bug), pc = %d, depth = %d",
- pc - XSTRING (string_saved)->data, stacke - stackp);
- if (stackp < stack)
- error ("Stack underflow in byte code (byte compiler bug), pc = %d",
- pc - XSTRING (string_saved)->data);
+ if (top > stacke)
+ abort ();
+ else if (top < stack.bottom - 1)
+ abort ();
#endif
- if (string_saved != bytestr)
- {
- pc = pc - XSTRING (string_saved)->data + XSTRING (bytestr)->data;
- string_saved = bytestr;
- }
-
#ifdef BYTE_CODE_METER
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 (XTYPE (v1) != Lisp_Symbol)
- v2 = Fsymbol_value (v1);
- else
- {
- v2 = XSYMBOL (v1)->value;
-#ifdef SWITCH_ENUM_BUG
- switch ((int) XTYPE (v2))
-#else
- switch (XTYPE (v2))
-#endif
- {
- case Lisp_Symbol:
- if (!EQ (v2, Qunbound))
- break;
- case Lisp_Intfwd:
- case Lisp_Boolfwd:
- case Lisp_Objfwd:
- case Lisp_Buffer_Local_Value:
- case Lisp_Some_Buffer_Local_Value:
- case Lisp_Buffer_Objfwd:
- case Lisp_Void:
+ {
+ 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))
+ {
+ 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
+ {
+ BEFORE_POTENTIAL_GC ();
+ Fcar (wrong_type_argument (Qlistp, v1));
+ AFTER_POTENTIAL_GC ();
+ }
+ 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
+ {
+ BEFORE_POTENTIAL_GC ();
+ Fcdr (wrong_type_argument (Qlistp, v1));
+ AFTER_POTENTIAL_GC ();
+ }
+ break;
+ }
case Bvarset+7:
op = FETCH2;
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, current_buffer, 0);
+ /* Fset (vectorp[op], POP); */
break;
+ case Bdup:
+ {
+ Lisp_Object v1;
+ v1 = TOP;
+ PUSH (v1);
+ break;
+ }
+
+ /* ------------------ */
+
case Bvarbind+6:
op = FETCH;
goto varbind;
op = FETCH2;
goto varbind;
- case Bvarbind: case Bvarbind+1: case Bvarbind+2: case Bvarbind+3:
- case Bvarbind+4: case Bvarbind+5:
+ case Bvarbind:
+ case Bvarbind+1:
+ case Bvarbind+2:
+ case Bvarbind+3:
+ case Bvarbind+4:
+ case Bvarbind+5:
op -= Bvarbind;
varbind:
specbind (vectorp[op], POP);
op = FETCH2;
goto docall;
- case Bcall: case Bcall+1: case Bcall+2: case Bcall+3:
- case Bcall+4: case Bcall+5:
+ case Bcall:
+ case Bcall+1:
+ case Bcall+2:
+ case Bcall+3:
+ case Bcall+4:
+ case Bcall+5:
op -= Bcall;
docall:
- DISCARD(op);
- TOP = Ffuncall (op + 1, &TOP);
- break;
+ {
+ BEFORE_POTENTIAL_GC ();
+ DISCARD (op);
+#ifdef BYTE_CODE_METER
+ 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
+ TOP = Ffuncall (op + 1, &TOP);
+ AFTER_POTENTIAL_GC ();
+ break;
+ }
case Bunbind+6:
op = FETCH;
op = FETCH2;
goto dounbind;
- case Bunbind: case Bunbind+1: case Bunbind+2: case Bunbind+3:
- case Bunbind+4: case Bunbind+5:
+ case Bunbind:
+ case Bunbind+1:
+ case Bunbind+2:
+ case Bunbind+3:
+ case Bunbind+4:
+ case Bunbind+5:
op -= Bunbind;
dounbind:
+ BEFORE_POTENTIAL_GC ();
unbind_to (specpdl_ptr - specpdl - op, Qnil);
+ AFTER_POTENTIAL_GC ();
break;
case Bunbind_all:
/* To unbind back to the beginning of this frame. Not used yet,
- but wil be needed for tail-recursion elimination.
- */
+ but will be needed for tail-recursion elimination. */
+ BEFORE_POTENTIAL_GC ();
unbind_to (count, Qnil);
+ AFTER_POTENTIAL_GC ();
break;
case Bgoto:
+ MAYBE_GC ();
QUIT;
op = FETCH2; /* pc = FETCH2 loses since FETCH2 contains pc++ */
- pc = XSTRING (string_saved)->data + op;
+ CHECK_RANGE (op);
+ stack.pc = stack.byte_string_start + op;
break;
- case Bgotoifnil:
+ case Bgotoifnonnil:
+ MAYBE_GC ();
op = FETCH2;
- if (NILP (POP))
+ if (!NILP (POP))
{
QUIT;
- pc = XSTRING (string_saved)->data + op;
+ CHECK_RANGE (op);
+ stack.pc = stack.byte_string_start + op;
}
break;
- case Bgotoifnonnil:
+ case Bgotoifnilelsepop:
+ MAYBE_GC ();
op = FETCH2;
- if (!NILP (POP))
+ if (NILP (TOP))
{
QUIT;
- pc = XSTRING (string_saved)->data + op;
+ CHECK_RANGE (op);
+ stack.pc = stack.byte_string_start + op;
}
+ else DISCARD (1);
break;
- case Bgotoifnilelsepop:
+ case Bgotoifnonnilelsepop:
+ MAYBE_GC ();
op = FETCH2;
+ if (!NILP (TOP))
+ {
+ QUIT;
+ CHECK_RANGE (op);
+ stack.pc = stack.byte_string_start + op;
+ }
+ else DISCARD (1);
+ break;
+
+ case BRgoto:
+ MAYBE_GC ();
+ QUIT;
+ stack.pc += (int) *stack.pc - 127;
+ break;
+
+ case BRgotoifnil:
+ MAYBE_GC ();
+ if (NILP (POP))
+ {
+ QUIT;
+ stack.pc += (int) *stack.pc - 128;
+ }
+ stack.pc++;
+ break;
+
+ case BRgotoifnonnil:
+ MAYBE_GC ();
+ if (!NILP (POP))
+ {
+ QUIT;
+ stack.pc += (int) *stack.pc - 128;
+ }
+ stack.pc++;
+ break;
+
+ case BRgotoifnilelsepop:
+ MAYBE_GC ();
+ op = *stack.pc++;
if (NILP (TOP))
{
QUIT;
- pc = XSTRING (string_saved)->data + op;
+ stack.pc += op - 128;
}
- else DISCARD(1);
+ else DISCARD (1);
break;
- case Bgotoifnonnilelsepop:
- op = FETCH2;
+ case BRgotoifnonnilelsepop:
+ MAYBE_GC ();
+ op = *stack.pc++;
if (!NILP (TOP))
{
QUIT;
- pc = XSTRING (string_saved)->data + op;
+ stack.pc += op - 128;
}
- else DISCARD(1);
+ else DISCARD (1);
break;
case Breturn:
- v1 = POP;
+ result = POP;
goto exit;
case Bdiscard:
- DISCARD(1);
- break;
-
- case Bdup:
- v1 = TOP;
- PUSH (v1);
+ DISCARD (1);
break;
case Bconstant2:
break;
case Bsave_excursion:
- record_unwind_protect (save_excursion_restore, save_excursion_save ());
+ record_unwind_protect (save_excursion_restore,
+ save_excursion_save ());
+ break;
+
+ case Bsave_current_buffer:
+ case Bsave_current_buffer_1:
+ record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
break;
case Bsave_window_excursion:
+ BEFORE_POTENTIAL_GC ();
TOP = Fsave_window_excursion (TOP);
+ AFTER_POTENTIAL_GC ();
break;
case Bsave_restriction:
- record_unwind_protect (save_restriction_restore, save_restriction_save ());
+ record_unwind_protect (save_restriction_restore,
+ save_restriction_save ());
break;
case Bcatch:
- v1 = POP;
- TOP = internal_catch (TOP, Feval, v1);
- 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);
break;
case Bcondition_case:
- v1 = POP;
- v1 = Fcons (POP, v1);
- TOP = Fcondition_case (Fcons (TOP, v1));
- 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, Qnil);
- TOP = v1;
- /* pop binding of standard-output */
- unbind_to (specpdl_ptr - specpdl - 1, Qnil);
- 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 = XCONS (v1)->cdr;
- 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;
+ BEFORE_POTENTIAL_GC ();
+ CHECK_NUMBER (v2, 0);
+ AFTER_POTENTIAL_GC ();
+ op = XINT (v2);
+ immediate_quit = 1;
+ while (--op >= 0)
+ {
+ if (CONSP (v1))
+ v1 = XCDR (v1);
+ else if (!NILP (v1))
+ {
+ immediate_quit = 0;
+ BEFORE_POTENTIAL_GC ();
+ v1 = wrong_type_argument (Qlistp, v1);
+ AFTER_POTENTIAL_GC ();
+ immediate_quit = 1;
+ op++;
+ }
+ }
+ immediate_quit = 0;
+ if (CONSP (v1))
+ TOP = XCAR (v1);
+ else if (NILP (v1))
+ TOP = Qnil;
+ else
+ {
+ BEFORE_POTENTIAL_GC ();
+ Fcar (wrong_type_argument (Qlistp, v1));
+ AFTER_POTENTIAL_GC ();
+ }
+ break;
+ }
case Bsymbolp:
- TOP = XTYPE (TOP) == Lisp_Symbol ? Qt : Qnil;
+ TOP = SYMBOLP (TOP) ? Qt : Qnil;
break;
case Bconsp:
break;
case Bstringp:
- TOP = XTYPE (TOP) == Lisp_String ? Qt : Qnil;
+ TOP = STRINGP (TOP) ? Qt : Qnil;
break;
case Blistp:
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 = XCONS (v1)->car;
- else if (NILP (v1)) TOP = Qnil;
- else Fcar (wrong_type_argument (Qlistp, v1));
- break;
-
- case Bcdr:
- v1 = TOP;
- if (CONSP (v1)) TOP = XCONS (v1)->cdr;
- 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);
+ DISCARD (2);
TOP = Flist (3, &TOP);
break;
case Blist4:
- DISCARD(3);
+ DISCARD (3);
TOP = Flist (4, &TOP);
break;
+ case BlistN:
+ op = FETCH;
+ DISCARD (op - 1);
+ TOP = Flist (op, &TOP);
+ break;
+
case Blength:
TOP = Flength (TOP);
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);
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;
+ BEFORE_POTENTIAL_GC ();
+ TOP = Fsubstring (TOP, v1, v2);
+ AFTER_POTENTIAL_GC ();
+ break;
+ }
case Bconcat2:
- DISCARD(1);
+ DISCARD (1);
TOP = Fconcat (2, &TOP);
break;
case Bconcat3:
- DISCARD(2);
+ DISCARD (2);
TOP = Fconcat (3, &TOP);
break;
case Bconcat4:
- DISCARD(3);
+ DISCARD (3);
TOP = Fconcat (4, &TOP);
break;
- case Bsub1:
- v1 = TOP;
- if (XTYPE (v1) == Lisp_Int)
- {
- XSETINT (v1, XINT (v1) - 1);
- TOP = v1;
- }
- else
- TOP = Fsub1 (v1);
+ case BconcatN:
+ op = FETCH;
+ DISCARD (op - 1);
+ TOP = Fconcat (op, &TOP);
break;
+ case Bsub1:
+ {
+ 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 (XTYPE (v1) == Lisp_Int)
- {
- 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);
- TOP = (XFLOATINT (v1) == XFLOATINT (v2)) ? Qt : Qnil;
- break;
+ {
+ Lisp_Object v1, v2;
+ v2 = POP; v1 = TOP;
+ BEFORE_POTENTIAL_GC ();
+ CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v1, 0);
+ CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v2, 0);
+ AFTER_POTENTIAL_GC ();
+ 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
+ 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);
+ DISCARD (1);
TOP = Fminus (2, &TOP);
break;
case Bnegate:
- v1 = TOP;
- if (XTYPE (v1) == Lisp_Int)
- {
- 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);
+ DISCARD (1);
TOP = Fplus (2, &TOP);
break;
case Bmax:
- DISCARD(1);
+ DISCARD (1);
TOP = Fmax (2, &TOP);
break;
case Bmin:
- DISCARD(1);
+ DISCARD (1);
TOP = Fmin (2, &TOP);
break;
case Bmult:
- DISCARD(1);
+ DISCARD (1);
TOP = Ftimes (2, &TOP);
break;
case Bquo:
- DISCARD(1);
+ DISCARD (1);
TOP = Fquo (2, &TOP);
break;
case Brem:
- v1 = POP;
- /* This had args in the wrong order. -- jwz */
- TOP = Frem (TOP, v1);
- break;
+ {
+ Lisp_Object v1;
+ v1 = POP;
+ TOP = Frem (TOP, v1);
+ break;
+ }
case Bpoint:
- XFASTINT (v1) = point;
- 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 Bpoint_max:
- XFASTINT (v1) = ZV;
- PUSH (v1);
+ case BinsertN:
+ op = FETCH;
+ BEFORE_POTENTIAL_GC ();
+ DISCARD (op - 1);
+ TOP = Finsert (op, &TOP);
+ AFTER_POTENTIAL_GC ();
break;
+ case Bpoint_max:
+ {
+ Lisp_Object v1;
+ XSETFASTINT (v1, ZV);
+ PUSH (v1);
+ break;
+ }
+
case Bpoint_min:
- XFASTINT (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:
- XFASTINT (v1) = PT == ZV ? 0 : FETCH_CHAR (point);
- PUSH (v1);
- break;
+ {
+ Lisp_Object v1;
+ v1 = Ffollowing_char ();
+ PUSH (v1);
+ break;
+ }
case Bpreceding_char:
- XFASTINT (v1) = point <= BEGV ? 0 : FETCH_CHAR (point - 1);
- PUSH (v1);
- break;
+ {
+ Lisp_Object v1;
+ v1 = Fprevious_char ();
+ PUSH (v1);
+ break;
+ }
case Bcurrent_column:
- XFASTINT (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:
break;
case Bset_buffer:
+ BEFORE_POTENTIAL_GC ();
TOP = Fset_buffer (TOP);
- break;
-
- case Bread_char:
- PUSH (Fread_char ());
- QUIT;
+ AFTER_POTENTIAL_GC ();
break;
case Binteractive_p:
break;
case Bforward_char:
- /* This was wrong! --jwz */
+ BEFORE_POTENTIAL_GC ();
TOP = Fforward_char (TOP);
+ AFTER_POTENTIAL_GC ();
break;
case Bforward_word:
- /* This was wrong! --jwz */
+ BEFORE_POTENTIAL_GC ();
TOP = Fforward_word (TOP);
+ AFTER_POTENTIAL_GC ();
break;
case Bskip_chars_forward:
- /* This was wrong! --jwz */
- 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:
- /* This was wrong! --jwz */
- 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:
- /* This was wrong! --jwz */
+ BEFORE_POTENTIAL_GC ();
TOP = Fforward_line (TOP);
+ AFTER_POTENTIAL_GC ();
break;
case Bchar_syntax:
+ BEFORE_POTENTIAL_GC ();
CHECK_NUMBER (TOP, 0);
- XFASTINT (TOP) = syntax_code_spec[(int) SYNTAX (0xFF & XINT (TOP))];
+ AFTER_POTENTIAL_GC ();
+ 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;
- /* This had args in the wrong order. -- jwz */
- 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;
- /* This had args in the wrong order. -- jwz */
- 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 Bstringeqlsign:
- v1 = POP;
- /* This had args in the wrong order. -- jwz */
- TOP = Fstring_equal (TOP, v1);
+ case Bend_of_line:
+ BEFORE_POTENTIAL_GC ();
+ TOP = Fend_of_line (TOP);
+ AFTER_POTENTIAL_GC ();
break;
- case Bstringlss:
- v1 = POP;
- /* This had args in the wrong order. -- jwz */
- TOP = Fstring_lessp (TOP, v1);
+ case Bset_marker:
+ {
+ Lisp_Object v1, v2;
+ v1 = POP;
+ v2 = POP;
+ TOP = Fset_marker (TOP, v2, v1);
+ break;
+ }
+
+ case Bmatch_beginning:
+ TOP = Fmatch_beginning (TOP);
break;
- case Bequal:
- v1 = POP;
- /* This had args in the wrong order. -- jwz */
- TOP = Fequal (TOP, v1);
+ case Bmatch_end:
+ TOP = Fmatch_end (TOP);
break;
- case Bnthcdr:
- v1 = POP;
- /* This had args in the wrong order. -- jwz */
- TOP = Fnthcdr (TOP, v1);
+ case Bupcase:
+ TOP = Fupcase (TOP);
break;
+ case Bdowncase:
+ TOP = Fdowncase (TOP);
+ break;
+
+ case Bstringeqlsign:
+ {
+ Lisp_Object v1;
+ v1 = POP;
+ TOP = Fstring_equal (TOP, v1);
+ break;
+ }
+
+ case Bstringlss:
+ {
+ Lisp_Object v1;
+ v1 = POP;
+ TOP = Fstring_lessp (TOP, v1);
+ break;
+ }
+
+ case Bequal:
+ {
+ Lisp_Object v1;
+ v1 = POP;
+ TOP = Fequal (TOP, v1);
+ break;
+ }
+
+ case Bnthcdr:
+ {
+ Lisp_Object v1;
+ v1 = POP;
+ TOP = Fnthcdr (TOP, v1);
+ break;
+ }
+
case Belt:
- if (XTYPE (TOP) == Lisp_Cons)
- {
- /* 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;
+ BEFORE_POTENTIAL_GC ();
+ CHECK_NUMBER (v2, 0);
+ AFTER_POTENTIAL_GC ();
+ op = XINT (v2);
+ immediate_quit = 1;
+ while (--op >= 0)
+ {
+ if (CONSP (v1))
+ v1 = XCDR (v1);
+ else if (!NILP (v1))
+ {
+ immediate_quit = 0;
+ BEFORE_POTENTIAL_GC ();
+ v1 = wrong_type_argument (Qlistp, v1);
+ AFTER_POTENTIAL_GC ();
+ immediate_quit = 1;
+ op++;
+ }
+ }
+ immediate_quit = 0;
+ if (CONSP (v1))
+ TOP = XCAR (v1);
+ else if (NILP (v1))
+ TOP = Qnil;
+ else
+ {
+ BEFORE_POTENTIAL_GC ();
+ Fcar (wrong_type_argument (Qlistp, v1));
+ AFTER_POTENTIAL_GC ();
+ }
+ }
+ else
+ {
+ v1 = POP;
+ TOP = Felt (TOP, v1);
+ }
+ break;
+ }
case Bmember:
- v1 = POP;
- /* This had args in the wrong order. -- jwz */
- TOP = Fmember (TOP, v1);
- break;
+ {
+ Lisp_Object v1;
+ v1 = POP;
+ TOP = Fmember (TOP, v1);
+ break;
+ }
case Bassq:
- v1 = POP;
- /* This had args in the wrong order. -- jwz */
- 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;
- /* This had args in the wrong order. -- jwz */
- TOP = Fsetcar (TOP, v1);
- break;
+ {
+ Lisp_Object v1;
+ v1 = POP;
+ TOP = Fsetcar (TOP, v1);
+ break;
+ }
case Bsetcdr:
- v1 = POP;
- /* This had args in the wrong order. -- jwz */
- TOP = Fsetcdr (TOP, v1);
- break;
+ {
+ Lisp_Object v1;
+ v1 = POP;
+ TOP = Fsetcdr (TOP, v1);
+ break;
+ }
case Bcar_safe:
- v1 = TOP;
- if (XTYPE (v1) == Lisp_Cons)
- TOP = XCONS (v1)->car;
- 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 (XTYPE (v1) == Lisp_Cons)
- TOP = XCONS (v1)->cdr;
- else
- TOP = Qnil;
- break;
+ {
+ Lisp_Object v1;
+ v1 = TOP;
+ if (CONSP (v1))
+ TOP = XCDR (v1);
+ else
+ TOP = Qnil;
+ break;
+ }
case Bnconc:
- DISCARD(1);
+ DISCARD (1);
TOP = Fnconc (2, &TOP);
break;
case Bnumberp:
- TOP = (XTYPE (TOP) == Lisp_Int || XTYPE (TOP) == Lisp_Float
- ? Qt : Qnil);
+ TOP = (NUMBERP (TOP) ? Qt : Qnil);
break;
case Bintegerp:
- TOP = XTYPE (TOP) == Lisp_Int ? Qt : Qnil;
+ TOP = INTEGERP (TOP) ? Qt : Qnil;
break;
#ifdef BYTE_CODE_SAFE
case Bset_mark:
+ BEFORE_POTENTIAL_GC ();
error ("set-mark is an obsolete bytecode");
+ AFTER_POTENTIAL_GC ();
break;
case Bscan_buffer:
+ BEFORE_POTENTIAL_GC ();
error ("scan-buffer is an obsolete bytecode");
- break;
- case Bmark:
- error("mark is an obsolete bytecode");
+ AFTER_POTENTIAL_GC ();
break;
#endif
+ case 0:
+ abort ();
+
+ case 255:
default:
#ifdef BYTE_CODE_SAFE
if (op < Bconstant)
- error ("unknown bytecode %d (byte compiler bug)", op);
+ {
+ abort ();
+ }
if ((op -= Bconstant) >= const_length)
- error ("no constant number %d (byte compiler bug)", op);
+ {
+ abort ();
+ }
PUSH (vectorp[op]);
#else
PUSH (vectorp[op - Bconstant]);
}
exit:
- UNGCPRO;
+
+ byte_stack_list = byte_stack_list->next;
+
/* Binds and unbinds are supposed to be compiled balanced. */
if (specpdl_ptr - specpdl != count)
#ifdef BYTE_CODE_SAFE
#else
abort ();
#endif
- return v1;
+
+ return result;
}
+void
syms_of_bytecode ()
{
Qbytecode = intern ("byte-code");
#ifdef BYTE_CODE_METER
DEFVAR_LISP ("byte-code-meter", &Vbyte_code_meter,
- "a vector of vectors which holds a histogram of byte-code usage.");
- DEFVAR_BOOL ("byte-metering-on", &byte_metering_on, "");
+ "A vector of vectors which holds a histogram of byte-code usage.\n\
+(aref (aref byte-code-meter 0) CODE) indicates how many times the byte\n\
+opcode CODE has been executed.\n\
+(aref (aref byte-code-meter CODE1) CODE2), where CODE1 is not 0,\n\
+indicates how many times the byte opcodes CODE1 and CODE2 have been\n\
+executed in succession.");
+ DEFVAR_BOOL ("byte-metering-on", &byte_metering_on,
+ "If non-nil, keep profiling information on byte code usage.\n\
+The variable byte-code-meter indicates how often each byte opcode is used.\n\
+If a symbol has a property named `byte-code-meter' whose value is an\n\
+integer, it is incremented each time that symbol's function is called.");
byte_metering_on = 0;
- Vbyte_code_meter = Fmake_vector(make_number(256), make_number(0));
-
+ Vbyte_code_meter = Fmake_vector (make_number (256), make_number (0));
+ Qbyte_code_meter = intern ("byte-code-meter");
+ staticpro (&Qbyte_code_meter);
{
int i = 256;
while (i--)
- XVECTOR(Vbyte_code_meter)->contents[i] =
- Fmake_vector(make_number(256), make_number(0));
+ XVECTOR (Vbyte_code_meter)->contents[i] =
+ Fmake_vector (make_number (256), make_number (0));
}
#endif
}
HCoop / bpt / emacs.git / blobdiff