/* Execution of byte code produced by bytecomp.el.
- Copyright (C) 1985, 1986, 1987, 1988, 1993, 2000, 2001
+ Copyright (C) 1985, 1986, 1987, 1988, 1993, 2000, 2001, 2002, 2003
Free Software Foundation, Inc.
This file is part of GNU Emacs.
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 added a new instruction, unbind_all, which I will use for
+ 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
of args;
#include "buffer.h"
#include "character.h"
#include "syntax.h"
+#include "window.h"
#ifdef CHECK_FRAME_FONT
#include "frame.h"
#endif
/*
- * define BYTE_CODE_SAFE to enable some minor sanity checking (useful for
+ * 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 to enable generation of a byte-op usage histogram.
*/
/* #define BYTE_CODE_SAFE */
/* #define BYTE_CODE_METER */
{
/* Program counter. This points into the byte_string below
and is relocated when that string is relocated. */
- unsigned char *pc;
+ const unsigned char *pc;
/* Top and bottom of stack. The bottom points to an area of memory
allocated with alloca in Fbyte_code. */
Storing this here protects it from GC because mark_byte_stack
marks it. */
Lisp_Object byte_string;
- unsigned char *byte_string_start;
+ const 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. */
recorded value of `stack' here. */
if (!stack->top)
abort ();
-
+
for (obj = stack->bottom; obj <= stack->top; ++obj)
if (!XMARKBIT (*obj))
{
- mark_object (obj);
+ mark_object (*obj);
XMARK (*obj);
}
if (!XMARKBIT (stack->byte_string))
{
- mark_object (&stack->byte_string);
+ mark_object (stack->byte_string);
XMARK (stack->byte_string);
}
if (!XMARKBIT (stack->constants))
{
- mark_object (&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
+void
unmark_byte_stack ()
{
struct byte_stack *stack;
XUNMARK (stack->byte_string);
XUNMARK (stack->constants);
- if (stack->byte_string_start != XSTRING (stack->byte_string)->data)
+ if (stack->byte_string_start != SDATA (stack->byte_string))
{
int offset = stack->pc - stack->byte_string_start;
- stack->byte_string_start = XSTRING (stack->byte_string)->data;
+ stack->byte_string_start = SDATA (stack->byte_string);
stack->pc = stack->byte_string_start + offset;
}
}
(bytestr, vector, maxdepth)
Lisp_Object bytestr, vector, maxdepth;
{
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
#ifdef BYTE_CODE_METER
int this_op = 0;
int prev_op;
convert them back to the originally intended unibyte form. */
bytestr = Fstring_as_unibyte (bytestr);
- bytestr_length = STRING_BYTES (XSTRING (bytestr));
+ bytestr_length = SBYTES (bytestr);
vectorp = XVECTOR (vector)->contents;
stack.byte_string = bytestr;
- stack.pc = stack.byte_string_start = XSTRING (bytestr)->data;
+ stack.pc = stack.byte_string_start = SDATA (bytestr);
stack.constants = vector;
- stack.bottom = (Lisp_Object *) alloca (XFASTINT (maxdepth)
+ stack.bottom = (Lisp_Object *) alloca (XFASTINT (maxdepth)
* sizeof (Lisp_Object));
top = stack.bottom - 1;
stack.top = NULL;
#ifdef BYTE_CODE_SAFE
stacke = stack.bottom - 1 + XFASTINT (maxdepth);
#endif
-
+
while (1)
{
#ifdef BYTE_CODE_SAFE
op = FETCH2;
goto varref;
- case Bvarref:
- case Bvarref + 1:
- case Bvarref + 2:
+ case Bvarref:
+ case Bvarref + 1:
+ case Bvarref + 2:
case Bvarref + 3:
- case Bvarref + 4:
+ case Bvarref + 4:
case Bvarref + 5:
op = op - Bvarref;
goto varref;
varset:
{
Lisp_Object sym, val;
-
+
sym = vectorp[op];
val = TOP;
AFTER_POTENTIAL_GC ();
}
}
- POP;
+ (void) POP;
break;
case Bdup:
op -= Bunbind;
dounbind:
BEFORE_POTENTIAL_GC ();
- unbind_to (specpdl_ptr - specpdl - op, Qnil);
+ unbind_to (SPECPDL_INDEX () - op, Qnil);
AFTER_POTENTIAL_GC ();
break;
case Bunwind_protect:
/* The function record_unwind_protect can GC. */
BEFORE_POTENTIAL_GC ();
- record_unwind_protect (0, POP);
+ record_unwind_protect (Fprogn, POP);
AFTER_POTENTIAL_GC ();
- (specpdl_ptr - 1)->symbol = Qnil;
break;
case Bcondition_case:
case Btemp_output_buffer_setup:
BEFORE_POTENTIAL_GC ();
CHECK_STRING (TOP);
- temp_output_buffer_setup (XSTRING (TOP)->data);
+ temp_output_buffer_setup (SDATA (TOP));
AFTER_POTENTIAL_GC ();
TOP = Vstandard_output;
break;
temp_output_buffer_show (TOP);
TOP = v1;
/* pop binding of standard-output */
- unbind_to (specpdl_ptr - specpdl - 1, Qnil);
+ unbind_to (SPECPDL_INDEX () - 1, Qnil);
AFTER_POTENTIAL_GC ();
break;
}
TOP = v1;
}
else
- TOP = Fsub1 (v1);
+ {
+ BEFORE_POTENTIAL_GC ();
+ TOP = Fsub1 (v1);
+ AFTER_POTENTIAL_GC ();
+ }
break;
}
{
Lisp_Object v1;
BEFORE_POTENTIAL_GC ();
- XSETFASTINT (v1, current_column ());
+ XSETFASTINT (v1, (int) current_column ()); /* iftc */
AFTER_POTENTIAL_GC ();
PUSH (v1);
break;
if (NILP (current_buffer->enable_multibyte_characters))
MAKE_CHAR_MULTIBYTE (c);
XSETFASTINT (TOP, syntax_code_spec[(int) SYNTAX (c)]);
- }
+ }
break;
case Bbuffer_substring:
byte_stack_list = byte_stack_list->next;
/* Binds and unbinds are supposed to be compiled balanced. */
- if (specpdl_ptr - specpdl != count)
+ if (SPECPDL_INDEX () != count)
#ifdef BYTE_CODE_SAFE
error ("binding stack not balanced (serious byte compiler bug)");
#else
abort ();
#endif
-
+
return result;
}
\(aref (aref byte-code-meter CODE1) CODE2), where CODE1 is not 0,
indicates how many times the byte opcodes CODE1 and CODE2 have been
executed in succession. */);
-
+
DEFVAR_BOOL ("byte-metering-on", &byte_metering_on,
doc: /* If non-nil, keep profiling information on byte code usage.
The variable byte-code-meter indicates how often each byte opcode is used.