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;
#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 */
recorded value of `stack' here. */
if (!stack->top)
abort ();
-
+
for (obj = stack->bottom; obj <= stack->top; ++obj)
if (!XMARKBIT (*obj))
{
/* 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;
DEFUN ("byte-code", Fbyte_code, Sbyte_code, 3, 3, 0,
- "Function used internally in byte-compiled code.\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)
+ doc: /* Function used internally in byte-compiled code.
+The first argument, BYTESTR, is a string of byte code;
+the second, VECTOR, a vector of constants;
+the third, MAXDEPTH, the maximum stack depth used in this function.
+If the third argument is incorrect, Emacs may crash. */)
+ (bytestr, vector, maxdepth)
Lisp_Object bytestr, vector, maxdepth;
{
int count = specpdl_ptr - specpdl;
}
#endif
- CHECK_STRING (bytestr, 0);
+ CHECK_STRING (bytestr);
if (!VECTORP (vector))
vector = wrong_type_argument (Qvectorp, vector);
- CHECK_NUMBER (maxdepth, 2);
+ CHECK_NUMBER (maxdepth);
if (STRING_MULTIBYTE (bytestr))
/* BYTESTR must have been produced by Emacs 20.2 or the earlier
because they produced a raw 8-bit string for byte-code and now
such a byte-code string is loaded as multibyte while raw 8-bit
characters converted to multibyte form. Thus, now we must
- convert them back to the original unibyte form. */
+ convert them back to the originally intended unibyte form. */
bytestr = Fstring_as_unibyte (bytestr);
bytestr_length = STRING_BYTES (XSTRING (bytestr));
stack.byte_string = bytestr;
stack.pc = stack.byte_string_start = XSTRING (bytestr)->data;
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;
case Btemp_output_buffer_setup:
BEFORE_POTENTIAL_GC ();
- CHECK_STRING (TOP, 0);
+ CHECK_STRING (TOP);
temp_output_buffer_setup (XSTRING (TOP)->data);
AFTER_POTENTIAL_GC ();
TOP = Vstandard_output;
BEFORE_POTENTIAL_GC ();
v1 = POP;
v2 = TOP;
- CHECK_NUMBER (v2, 0);
+ CHECK_NUMBER (v2);
AFTER_POTENTIAL_GC ();
op = XINT (v2);
immediate_quit = 1;
Lisp_Object v1, v2;
BEFORE_POTENTIAL_GC ();
v2 = POP; v1 = TOP;
- CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v1, 0);
- CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v2, 0);
+ CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v1);
+ CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v2);
AFTER_POTENTIAL_GC ();
if (FLOATP (v1) || FLOATP (v2))
{
{
Lisp_Object v1;
BEFORE_POTENTIAL_GC ();
- XSETFASTINT (v1, current_column ());
+ XSETFASTINT (v1, (int) current_column ()); /* iftc */
AFTER_POTENTIAL_GC ();
PUSH (v1);
break;
case Bchar_syntax:
BEFORE_POTENTIAL_GC ();
- CHECK_NUMBER (TOP, 0);
+ CHECK_NUMBER (TOP);
AFTER_POTENTIAL_GC ();
XSETFASTINT (TOP, syntax_code_spec[(int) SYNTAX (XINT (TOP))]);
break;
BEFORE_POTENTIAL_GC ();
v2 = POP;
v1 = TOP;
- CHECK_NUMBER (v2, 0);
+ CHECK_NUMBER (v2);
AFTER_POTENTIAL_GC ();
op = XINT (v2);
immediate_quit = 1;
#else
abort ();
#endif
-
+
return result;
}
#ifdef BYTE_CODE_METER
DEFVAR_LISP ("byte-code-meter", &Vbyte_code_meter,
- "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.");
-
+ doc: /* A vector of vectors which holds a histogram of byte-code usage.
+\(aref (aref byte-code-meter 0) CODE) indicates how many times the byte
+opcode CODE has been executed.
+\(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,
- "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.");
+ doc: /* If non-nil, keep profiling information on byte code usage.
+The variable byte-code-meter indicates how often each byte opcode is used.
+If a symbol has a property named `byte-code-meter' whose value is an
+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));