1 /* Execution of byte code produced by bytecomp.el.
2 Copyright (C) 1985, 1986, 1987, 1988, 1993, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.
22 hacked on by jwz@lucid.com 17-jun-91
23 o added a compile-time switch to turn on simple sanity checking;
24 o put back the obsolete byte-codes for error-detection;
25 o added a new instruction, unbind_all, which I will use for
26 tail-recursion elimination;
27 o made temp_output_buffer_show be called with the right number
29 o made the new bytecodes be called with args in the right order;
30 o added metering support.
33 o added relative jump instructions;
34 o all conditionals now only do QUIT if they jump.
43 #ifdef CHECK_FRAME_FONT
49 * define BYTE_CODE_SAFE to enable some minor sanity checking (useful for
50 * debugging the byte compiler...)
52 * define BYTE_CODE_METER to enable generation of a byte-op usage histogram.
54 /* #define BYTE_CODE_SAFE */
55 /* #define BYTE_CODE_METER */
58 #ifdef BYTE_CODE_METER
60 Lisp_Object Vbyte_code_meter
, Qbyte_code_meter
;
63 #define METER_2(code1, code2) \
64 XFASTINT (XVECTOR (XVECTOR (Vbyte_code_meter)->contents[(code1)]) \
67 #define METER_1(code) METER_2 (0, (code))
69 #define METER_CODE(last_code, this_code) \
71 if (byte_metering_on) \
73 if (METER_1 (this_code) != ((1<<VALBITS)-1)) \
74 METER_1 (this_code)++; \
76 && METER_2 (last_code, this_code) != ((1<<VALBITS)-1))\
77 METER_2 (last_code, this_code)++; \
81 #else /* no BYTE_CODE_METER */
83 #define METER_CODE(last_code, this_code)
85 #endif /* no BYTE_CODE_METER */
88 Lisp_Object Qbytecode
;
116 #define Bsymbol_value 0112
117 #define Bsymbol_function 0113
121 #define Bsubstring 0117
122 #define Bconcat2 0120
123 #define Bconcat3 0121
124 #define Bconcat4 0122
127 #define Beqlsign 0125
140 /* Was Bmark in v17. */
141 #define Bsave_current_buffer 0141
142 #define Bgoto_char 0142
144 #define Bpoint_max 0144
145 #define Bpoint_min 0145
146 #define Bchar_after 0146
147 #define Bfollowing_char 0147
148 #define Bpreceding_char 0150
149 #define Bcurrent_column 0151
150 #define Bindent_to 0152
151 #define Bscan_buffer 0153 /* No longer generated as of v18 */
156 #define Bcurrent_buffer 0160
157 #define Bset_buffer 0161
158 #define Bsave_current_buffer_1 0162 /* Replacing Bsave_current_buffer. */
159 #define Bread_char 0162 /* No longer generated as of v19 */
160 #define Bset_mark 0163 /* this loser is no longer generated as of v18 */
161 #define Binteractive_p 0164 /* Needed since interactive-p takes unevalled args */
163 #define Bforward_char 0165
164 #define Bforward_word 0166
165 #define Bskip_chars_forward 0167
166 #define Bskip_chars_backward 0170
167 #define Bforward_line 0171
168 #define Bchar_syntax 0172
169 #define Bbuffer_substring 0173
170 #define Bdelete_region 0174
171 #define Bnarrow_to_region 0175
173 #define Bend_of_line 0177
175 #define Bconstant2 0201
177 #define Bgotoifnil 0203
178 #define Bgotoifnonnil 0204
179 #define Bgotoifnilelsepop 0205
180 #define Bgotoifnonnilelsepop 0206
182 #define Bdiscard 0210
185 #define Bsave_excursion 0212
186 #define Bsave_window_excursion 0213
187 #define Bsave_restriction 0214
190 #define Bunwind_protect 0216
191 #define Bcondition_case 0217
192 #define Btemp_output_buffer_setup 0220
193 #define Btemp_output_buffer_show 0221
195 #define Bunbind_all 0222
197 #define Bset_marker 0223
198 #define Bmatch_beginning 0224
199 #define Bmatch_end 0225
201 #define Bdowncase 0227
203 #define Bstringeqlsign 0230
204 #define Bstringlss 0231
210 #define Bnreverse 0237
213 #define Bcar_safe 0242
214 #define Bcdr_safe 0243
218 #define Bnumberp 0247
219 #define Bintegerp 0250
222 #define BRgotoifnil 0253
223 #define BRgotoifnonnil 0254
224 #define BRgotoifnilelsepop 0255
225 #define BRgotoifnonnilelsepop 0256
228 #define BconcatN 0260
229 #define BinsertN 0261
231 #define Bconstant 0300
232 #define CONSTANTLIM 0100
235 /* Structure describing a value stack used during byte-code execution
240 /* Program counter. This points into the byte_string below
241 and is relocated when that string is relocated. */
244 /* Top and bottom of stack. The bottom points to an area of memory
245 allocated with alloca in Fbyte_code. */
246 Lisp_Object
*top
, *bottom
;
248 /* The string containing the byte-code, and its current address.
249 Storing this here protects it from GC because mark_byte_stack
251 Lisp_Object byte_string
;
252 unsigned char *byte_string_start
;
254 /* The vector of constants used during byte-code execution. Storing
255 this here protects it from GC because mark_byte_stack marks it. */
256 Lisp_Object constants
;
258 /* Next entry in byte_stack_list. */
259 struct byte_stack
*next
;
262 /* A list of currently active byte-code execution value stacks.
263 Fbyte_code adds an entry to the head of this list before it starts
264 processing byte-code, and it removed the entry again when it is
265 done. Signalling an error truncates the list analoguous to
268 struct byte_stack
*byte_stack_list
;
271 /* Mark objects on byte_stack_list. Called during GC. */
276 struct byte_stack
*stack
;
279 for (stack
= byte_stack_list
; stack
; stack
= stack
->next
)
281 /* If STACK->top is null here, this means there's an opcode in
282 Fbyte_code that wasn't expected to GC, but did. To find out
283 which opcode this is, record the value of `stack', and walk
284 up the stack in a debugger, stopping in frames of Fbyte_code.
285 The culprit is found in the frame of Fbyte_code where the
286 address of its local variable `stack' is equal to the
287 recorded value of `stack' here. */
291 for (obj
= stack
->bottom
; obj
<= stack
->top
; ++obj
)
292 if (!XMARKBIT (*obj
))
298 if (!XMARKBIT (stack
->byte_string
))
300 mark_object (&stack
->byte_string
);
301 XMARK (stack
->byte_string
);
304 if (!XMARKBIT (stack
->constants
))
306 mark_object (&stack
->constants
);
307 XMARK (stack
->constants
);
313 /* Unmark objects in the stacks on byte_stack_list. Relocate program
314 counters. Called when GC has completed. */
319 struct byte_stack
*stack
;
322 for (stack
= byte_stack_list
; stack
; stack
= stack
->next
)
324 for (obj
= stack
->bottom
; obj
<= stack
->top
; ++obj
)
327 XUNMARK (stack
->byte_string
);
328 XUNMARK (stack
->constants
);
330 if (stack
->byte_string_start
!= XSTRING (stack
->byte_string
)->data
)
332 int offset
= stack
->pc
- stack
->byte_string_start
;
333 stack
->byte_string_start
= XSTRING (stack
->byte_string
)->data
;
334 stack
->pc
= stack
->byte_string_start
+ offset
;
340 /* Fetch the next byte from the bytecode stream */
342 #define FETCH *stack.pc++
344 /* Fetch two bytes from the bytecode stream and make a 16-bit number
347 #define FETCH2 (op = FETCH, op + (FETCH << 8))
349 /* Push x onto the execution stack. This used to be #define PUSH(x)
350 (*++stackp = (x)) This oddity is necessary because Alliant can't be
351 bothered to compile the preincrement operator properly, as of 4/91.
354 #define PUSH(x) (top++, *top = (x))
356 /* Pop a value off the execution stack. */
360 /* Discard n values from the execution stack. */
362 #define DISCARD(n) (top -= (n))
364 /* Get the value which is at the top of the execution stack, but don't
369 /* Actions that must be performed before and after calling a function
372 #define BEFORE_POTENTIAL_GC() stack.top = top
373 #define AFTER_POTENTIAL_GC() stack.top = NULL
375 /* Garbage collect if we have consed enough since the last time.
376 We do this at every branch, to avoid loops that never GC. */
379 if (consing_since_gc > gc_cons_threshold) \
381 BEFORE_POTENTIAL_GC (); \
382 Fgarbage_collect (); \
383 AFTER_POTENTIAL_GC (); \
387 /* Check for jumping out of range. */
389 #ifdef BYTE_CODE_SAFE
391 #define CHECK_RANGE(ARG) \
392 if (ARG >= bytestr_length) abort ()
394 #else /* not BYTE_CODE_SAFE */
396 #define CHECK_RANGE(ARG)
398 #endif /* not BYTE_CODE_SAFE */
400 /* A version of the QUIT macro which makes sure that the stack top is
401 set before signaling `quit'. */
403 #define BYTE_CODE_QUIT \
405 if (!NILP (Vquit_flag) && NILP (Vinhibit_quit)) \
408 BEFORE_POTENTIAL_GC (); \
409 Fsignal (Qquit, Qnil); \
414 DEFUN ("byte-code", Fbyte_code
, Sbyte_code
, 3, 3, 0,
415 "Function used internally in byte-compiled code.\n\
416 The first argument, BYTESTR, is a string of byte code;\n\
417 the second, VECTOR, a vector of constants;\n\
418 the third, MAXDEPTH, the maximum stack depth used in this function.\n\
419 If the third argument is incorrect, Emacs may crash.")
420 (bytestr
, vector
, maxdepth
)
421 Lisp_Object bytestr
, vector
, maxdepth
;
423 int count
= specpdl_ptr
- specpdl
;
424 #ifdef BYTE_CODE_METER
429 /* Lisp_Object v1, v2; */
430 Lisp_Object
*vectorp
;
431 #ifdef BYTE_CODE_SAFE
432 int const_length
= XVECTOR (vector
)->size
;
436 struct byte_stack stack
;
440 #ifdef CHECK_FRAME_FONT
442 struct frame
*f
= SELECTED_FRAME ();
444 && FRAME_FONT (f
)->direction
!= 0
445 && FRAME_FONT (f
)->direction
!= 1)
450 CHECK_STRING (bytestr
, 0);
451 if (!VECTORP (vector
))
452 vector
= wrong_type_argument (Qvectorp
, vector
);
453 CHECK_NUMBER (maxdepth
, 2);
455 if (STRING_MULTIBYTE (bytestr
))
456 /* BYTESTR must have been produced by Emacs 20.2 or the earlier
457 because they produced a raw 8-bit string for byte-code and now
458 such a byte-code string is loaded as multibyte while raw 8-bit
459 characters converted to multibyte form. Thus, now we must
460 convert them back to the original unibyte form. */
461 bytestr
= Fstring_as_unibyte (bytestr
);
463 bytestr_length
= STRING_BYTES (XSTRING (bytestr
));
464 vectorp
= XVECTOR (vector
)->contents
;
466 stack
.byte_string
= bytestr
;
467 stack
.pc
= stack
.byte_string_start
= XSTRING (bytestr
)->data
;
468 stack
.constants
= vector
;
469 stack
.bottom
= (Lisp_Object
*) alloca (XFASTINT (maxdepth
)
470 * sizeof (Lisp_Object
));
471 top
= stack
.bottom
- 1;
473 stack
.next
= byte_stack_list
;
474 byte_stack_list
= &stack
;
476 #ifdef BYTE_CODE_SAFE
477 stacke
= stack
.bottom
- 1 + XFASTINT (maxdepth
);
482 #ifdef BYTE_CODE_SAFE
485 else if (top
< stack
.bottom
- 1)
489 #ifdef BYTE_CODE_METER
491 this_op
= op
= FETCH
;
492 METER_CODE (prev_op
, op
);
512 /* This seems to be the most frequently executed byte-code
513 among the Bvarref's, so avoid a goto here. */
523 v2
= XSYMBOL (v1
)->value
;
524 if (MISCP (v2
) || EQ (v2
, Qunbound
))
526 BEFORE_POTENTIAL_GC ();
527 v2
= Fsymbol_value (v1
);
528 AFTER_POTENTIAL_GC ();
533 BEFORE_POTENTIAL_GC ();
534 v2
= Fsymbol_value (v1
);
535 AFTER_POTENTIAL_GC ();
548 stack
.pc
= stack
.byte_string_start
+ op
;
562 BEFORE_POTENTIAL_GC ();
563 Fcar (wrong_type_argument (Qlistp
, v1
));
564 AFTER_POTENTIAL_GC ();
573 TOP
= EQ (v1
, TOP
) ? Qt
: Qnil
;
580 BEFORE_POTENTIAL_GC ();
582 TOP
= Fmemq (TOP
, v1
);
583 AFTER_POTENTIAL_GC ();
597 BEFORE_POTENTIAL_GC ();
598 Fcdr (wrong_type_argument (Qlistp
, v1
));
599 AFTER_POTENTIAL_GC ();
621 Lisp_Object sym
, val
;
626 /* Inline the most common case. */
628 && !EQ (val
, Qunbound
)
629 && !MISCP (XSYMBOL (sym
)->value
)
630 /* I think this should either be checked in the byte
631 compiler, or there should be a flag indicating that
632 a symbol might be constant in Lisp_Symbol, instead
633 of checking this here over and over again. --gerd. */
636 && !(XSYMBOL (sym
)->name
->data
[0] == ':'
637 && EQ (XSYMBOL (sym
)->obarray
, initial_obarray
)
639 XSYMBOL (sym
)->value
= val
;
642 BEFORE_POTENTIAL_GC ();
643 set_internal (sym
, val
, current_buffer
, 0);
644 AFTER_POTENTIAL_GC ();
658 /* ------------------ */
676 /* Specbind can signal and thus GC. */
677 BEFORE_POTENTIAL_GC ();
678 specbind (vectorp
[op
], POP
);
679 AFTER_POTENTIAL_GC ();
699 BEFORE_POTENTIAL_GC ();
701 #ifdef BYTE_CODE_METER
702 if (byte_metering_on
&& SYMBOLP (TOP
))
707 v2
= Fget (v1
, Qbyte_code_meter
);
709 && XINT (v2
) != ((1<<VALBITS
)-1))
711 XSETINT (v2
, XINT (v2
) + 1);
712 Fput (v1
, Qbyte_code_meter
, v2
);
716 TOP
= Ffuncall (op
+ 1, &TOP
);
717 AFTER_POTENTIAL_GC ();
737 BEFORE_POTENTIAL_GC ();
738 unbind_to (specpdl_ptr
- specpdl
- op
, Qnil
);
739 AFTER_POTENTIAL_GC ();
743 /* To unbind back to the beginning of this frame. Not used yet,
744 but will be needed for tail-recursion elimination. */
745 BEFORE_POTENTIAL_GC ();
746 unbind_to (count
, Qnil
);
747 AFTER_POTENTIAL_GC ();
753 op
= FETCH2
; /* pc = FETCH2 loses since FETCH2 contains pc++ */
755 stack
.pc
= stack
.byte_string_start
+ op
;
765 stack
.pc
= stack
.byte_string_start
+ op
;
769 case Bgotoifnilelsepop
:
776 stack
.pc
= stack
.byte_string_start
+ op
;
781 case Bgotoifnonnilelsepop
:
788 stack
.pc
= stack
.byte_string_start
+ op
;
796 stack
.pc
+= (int) *stack
.pc
- 127;
804 stack
.pc
+= (int) *stack
.pc
- 128;
814 stack
.pc
+= (int) *stack
.pc
- 128;
819 case BRgotoifnilelsepop
:
825 stack
.pc
+= op
- 128;
830 case BRgotoifnonnilelsepop
:
836 stack
.pc
+= op
- 128;
850 PUSH (vectorp
[FETCH2
]);
853 case Bsave_excursion
:
854 record_unwind_protect (save_excursion_restore
,
855 save_excursion_save ());
858 case Bsave_current_buffer
:
859 case Bsave_current_buffer_1
:
860 record_unwind_protect (set_buffer_if_live
, Fcurrent_buffer ());
863 case Bsave_window_excursion
:
864 BEFORE_POTENTIAL_GC ();
865 TOP
= Fsave_window_excursion (TOP
);
866 AFTER_POTENTIAL_GC ();
869 case Bsave_restriction
:
870 record_unwind_protect (save_restriction_restore
,
871 save_restriction_save ());
877 BEFORE_POTENTIAL_GC ();
879 TOP
= internal_catch (TOP
, Feval
, v1
);
880 AFTER_POTENTIAL_GC ();
884 case Bunwind_protect
:
885 /* The function record_unwind_protect can GC. */
886 BEFORE_POTENTIAL_GC ();
887 record_unwind_protect (0, POP
);
888 AFTER_POTENTIAL_GC ();
889 (specpdl_ptr
- 1)->symbol
= Qnil
;
892 case Bcondition_case
:
896 v1
= Fcons (POP
, v1
);
897 BEFORE_POTENTIAL_GC ();
898 TOP
= Fcondition_case (Fcons (TOP
, v1
));
899 AFTER_POTENTIAL_GC ();
903 case Btemp_output_buffer_setup
:
904 BEFORE_POTENTIAL_GC ();
905 CHECK_STRING (TOP
, 0);
906 temp_output_buffer_setup (XSTRING (TOP
)->data
);
907 AFTER_POTENTIAL_GC ();
908 TOP
= Vstandard_output
;
911 case Btemp_output_buffer_show
:
914 BEFORE_POTENTIAL_GC ();
916 temp_output_buffer_show (TOP
);
918 /* pop binding of standard-output */
919 unbind_to (specpdl_ptr
- specpdl
- 1, Qnil
);
920 AFTER_POTENTIAL_GC ();
927 BEFORE_POTENTIAL_GC ();
930 CHECK_NUMBER (v2
, 0);
931 AFTER_POTENTIAL_GC ();
941 BEFORE_POTENTIAL_GC ();
942 v1
= wrong_type_argument (Qlistp
, v1
);
943 AFTER_POTENTIAL_GC ();
955 BEFORE_POTENTIAL_GC ();
956 Fcar (wrong_type_argument (Qlistp
, v1
));
957 AFTER_POTENTIAL_GC ();
963 TOP
= SYMBOLP (TOP
) ? Qt
: Qnil
;
967 TOP
= CONSP (TOP
) ? Qt
: Qnil
;
971 TOP
= STRINGP (TOP
) ? Qt
: Qnil
;
975 TOP
= CONSP (TOP
) || NILP (TOP
) ? Qt
: Qnil
;
979 TOP
= NILP (TOP
) ? Qt
: Qnil
;
986 TOP
= Fcons (TOP
, v1
);
991 TOP
= Fcons (TOP
, Qnil
);
998 TOP
= Fcons (TOP
, Fcons (v1
, Qnil
));
1004 TOP
= Flist (3, &TOP
);
1009 TOP
= Flist (4, &TOP
);
1015 TOP
= Flist (op
, &TOP
);
1019 BEFORE_POTENTIAL_GC ();
1020 TOP
= Flength (TOP
);
1021 AFTER_POTENTIAL_GC ();
1027 BEFORE_POTENTIAL_GC ();
1029 TOP
= Faref (TOP
, v1
);
1030 AFTER_POTENTIAL_GC ();
1037 BEFORE_POTENTIAL_GC ();
1039 TOP
= Faset (TOP
, v1
, v2
);
1040 AFTER_POTENTIAL_GC ();
1045 BEFORE_POTENTIAL_GC ();
1046 TOP
= Fsymbol_value (TOP
);
1047 AFTER_POTENTIAL_GC ();
1050 case Bsymbol_function
:
1051 BEFORE_POTENTIAL_GC ();
1052 TOP
= Fsymbol_function (TOP
);
1053 AFTER_POTENTIAL_GC ();
1059 BEFORE_POTENTIAL_GC ();
1061 TOP
= Fset (TOP
, v1
);
1062 AFTER_POTENTIAL_GC ();
1069 BEFORE_POTENTIAL_GC ();
1071 TOP
= Ffset (TOP
, v1
);
1072 AFTER_POTENTIAL_GC ();
1079 BEFORE_POTENTIAL_GC ();
1081 TOP
= Fget (TOP
, v1
);
1082 AFTER_POTENTIAL_GC ();
1089 BEFORE_POTENTIAL_GC ();
1091 TOP
= Fsubstring (TOP
, v1
, v2
);
1092 AFTER_POTENTIAL_GC ();
1097 BEFORE_POTENTIAL_GC ();
1099 TOP
= Fconcat (2, &TOP
);
1100 AFTER_POTENTIAL_GC ();
1104 BEFORE_POTENTIAL_GC ();
1106 TOP
= Fconcat (3, &TOP
);
1107 AFTER_POTENTIAL_GC ();
1111 BEFORE_POTENTIAL_GC ();
1113 TOP
= Fconcat (4, &TOP
);
1114 AFTER_POTENTIAL_GC ();
1119 BEFORE_POTENTIAL_GC ();
1121 TOP
= Fconcat (op
, &TOP
);
1122 AFTER_POTENTIAL_GC ();
1131 XSETINT (v1
, XINT (v1
) - 1);
1145 XSETINT (v1
, XINT (v1
) + 1);
1150 BEFORE_POTENTIAL_GC ();
1152 AFTER_POTENTIAL_GC ();
1160 BEFORE_POTENTIAL_GC ();
1162 CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v1
, 0);
1163 CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v2
, 0);
1164 AFTER_POTENTIAL_GC ();
1165 if (FLOATP (v1
) || FLOATP (v2
))
1169 f1
= (FLOATP (v1
) ? XFLOAT_DATA (v1
) : XINT (v1
));
1170 f2
= (FLOATP (v2
) ? XFLOAT_DATA (v2
) : XINT (v2
));
1171 TOP
= (f1
== f2
? Qt
: Qnil
);
1174 TOP
= (XINT (v1
) == XINT (v2
) ? Qt
: Qnil
);
1181 BEFORE_POTENTIAL_GC ();
1183 TOP
= Fgtr (TOP
, v1
);
1184 AFTER_POTENTIAL_GC ();
1191 BEFORE_POTENTIAL_GC ();
1193 TOP
= Flss (TOP
, v1
);
1194 AFTER_POTENTIAL_GC ();
1201 BEFORE_POTENTIAL_GC ();
1203 TOP
= Fleq (TOP
, v1
);
1204 AFTER_POTENTIAL_GC ();
1211 BEFORE_POTENTIAL_GC ();
1213 TOP
= Fgeq (TOP
, v1
);
1214 AFTER_POTENTIAL_GC ();
1219 BEFORE_POTENTIAL_GC ();
1221 TOP
= Fminus (2, &TOP
);
1222 AFTER_POTENTIAL_GC ();
1231 XSETINT (v1
, - XINT (v1
));
1236 BEFORE_POTENTIAL_GC ();
1237 TOP
= Fminus (1, &TOP
);
1238 AFTER_POTENTIAL_GC ();
1244 BEFORE_POTENTIAL_GC ();
1246 TOP
= Fplus (2, &TOP
);
1247 AFTER_POTENTIAL_GC ();
1251 BEFORE_POTENTIAL_GC ();
1253 TOP
= Fmax (2, &TOP
);
1254 AFTER_POTENTIAL_GC ();
1258 BEFORE_POTENTIAL_GC ();
1260 TOP
= Fmin (2, &TOP
);
1261 AFTER_POTENTIAL_GC ();
1265 BEFORE_POTENTIAL_GC ();
1267 TOP
= Ftimes (2, &TOP
);
1268 AFTER_POTENTIAL_GC ();
1272 BEFORE_POTENTIAL_GC ();
1274 TOP
= Fquo (2, &TOP
);
1275 AFTER_POTENTIAL_GC ();
1281 BEFORE_POTENTIAL_GC ();
1283 TOP
= Frem (TOP
, v1
);
1284 AFTER_POTENTIAL_GC ();
1291 XSETFASTINT (v1
, PT
);
1297 BEFORE_POTENTIAL_GC ();
1298 TOP
= Fgoto_char (TOP
);
1299 AFTER_POTENTIAL_GC ();
1303 BEFORE_POTENTIAL_GC ();
1304 TOP
= Finsert (1, &TOP
);
1305 AFTER_POTENTIAL_GC ();
1310 BEFORE_POTENTIAL_GC ();
1312 TOP
= Finsert (op
, &TOP
);
1313 AFTER_POTENTIAL_GC ();
1319 XSETFASTINT (v1
, ZV
);
1327 XSETFASTINT (v1
, BEGV
);
1333 BEFORE_POTENTIAL_GC ();
1334 TOP
= Fchar_after (TOP
);
1335 AFTER_POTENTIAL_GC ();
1338 case Bfollowing_char
:
1341 BEFORE_POTENTIAL_GC ();
1342 v1
= Ffollowing_char ();
1343 AFTER_POTENTIAL_GC ();
1348 case Bpreceding_char
:
1351 BEFORE_POTENTIAL_GC ();
1352 v1
= Fprevious_char ();
1353 AFTER_POTENTIAL_GC ();
1358 case Bcurrent_column
:
1361 BEFORE_POTENTIAL_GC ();
1362 XSETFASTINT (v1
, current_column ());
1363 AFTER_POTENTIAL_GC ();
1369 BEFORE_POTENTIAL_GC ();
1370 TOP
= Findent_to (TOP
, Qnil
);
1371 AFTER_POTENTIAL_GC ();
1390 case Bcurrent_buffer
:
1391 PUSH (Fcurrent_buffer ());
1395 BEFORE_POTENTIAL_GC ();
1396 TOP
= Fset_buffer (TOP
);
1397 AFTER_POTENTIAL_GC ();
1400 case Binteractive_p
:
1401 PUSH (Finteractive_p ());
1405 BEFORE_POTENTIAL_GC ();
1406 TOP
= Fforward_char (TOP
);
1407 AFTER_POTENTIAL_GC ();
1411 BEFORE_POTENTIAL_GC ();
1412 TOP
= Fforward_word (TOP
);
1413 AFTER_POTENTIAL_GC ();
1416 case Bskip_chars_forward
:
1419 BEFORE_POTENTIAL_GC ();
1421 TOP
= Fskip_chars_forward (TOP
, v1
);
1422 AFTER_POTENTIAL_GC ();
1426 case Bskip_chars_backward
:
1429 BEFORE_POTENTIAL_GC ();
1431 TOP
= Fskip_chars_backward (TOP
, v1
);
1432 AFTER_POTENTIAL_GC ();
1437 BEFORE_POTENTIAL_GC ();
1438 TOP
= Fforward_line (TOP
);
1439 AFTER_POTENTIAL_GC ();
1443 BEFORE_POTENTIAL_GC ();
1444 CHECK_NUMBER (TOP
, 0);
1445 AFTER_POTENTIAL_GC ();
1446 XSETFASTINT (TOP
, syntax_code_spec
[(int) SYNTAX (XINT (TOP
))]);
1449 case Bbuffer_substring
:
1452 BEFORE_POTENTIAL_GC ();
1454 TOP
= Fbuffer_substring (TOP
, v1
);
1455 AFTER_POTENTIAL_GC ();
1459 case Bdelete_region
:
1462 BEFORE_POTENTIAL_GC ();
1464 TOP
= Fdelete_region (TOP
, v1
);
1465 AFTER_POTENTIAL_GC ();
1469 case Bnarrow_to_region
:
1472 BEFORE_POTENTIAL_GC ();
1474 TOP
= Fnarrow_to_region (TOP
, v1
);
1475 AFTER_POTENTIAL_GC ();
1480 BEFORE_POTENTIAL_GC ();
1482 AFTER_POTENTIAL_GC ();
1486 BEFORE_POTENTIAL_GC ();
1487 TOP
= Fend_of_line (TOP
);
1488 AFTER_POTENTIAL_GC ();
1494 BEFORE_POTENTIAL_GC ();
1497 TOP
= Fset_marker (TOP
, v2
, v1
);
1498 AFTER_POTENTIAL_GC ();
1502 case Bmatch_beginning
:
1503 BEFORE_POTENTIAL_GC ();
1504 TOP
= Fmatch_beginning (TOP
);
1505 AFTER_POTENTIAL_GC ();
1509 BEFORE_POTENTIAL_GC ();
1510 TOP
= Fmatch_end (TOP
);
1511 AFTER_POTENTIAL_GC ();
1515 BEFORE_POTENTIAL_GC ();
1516 TOP
= Fupcase (TOP
);
1517 AFTER_POTENTIAL_GC ();
1521 BEFORE_POTENTIAL_GC ();
1522 TOP
= Fdowncase (TOP
);
1523 AFTER_POTENTIAL_GC ();
1526 case Bstringeqlsign
:
1529 BEFORE_POTENTIAL_GC ();
1531 TOP
= Fstring_equal (TOP
, v1
);
1532 AFTER_POTENTIAL_GC ();
1539 BEFORE_POTENTIAL_GC ();
1541 TOP
= Fstring_lessp (TOP
, v1
);
1542 AFTER_POTENTIAL_GC ();
1550 TOP
= Fequal (TOP
, v1
);
1557 BEFORE_POTENTIAL_GC ();
1559 TOP
= Fnthcdr (TOP
, v1
);
1560 AFTER_POTENTIAL_GC ();
1569 /* Exchange args and then do nth. */
1570 BEFORE_POTENTIAL_GC ();
1573 CHECK_NUMBER (v2
, 0);
1574 AFTER_POTENTIAL_GC ();
1581 else if (!NILP (v1
))
1584 BEFORE_POTENTIAL_GC ();
1585 v1
= wrong_type_argument (Qlistp
, v1
);
1586 AFTER_POTENTIAL_GC ();
1598 BEFORE_POTENTIAL_GC ();
1599 Fcar (wrong_type_argument (Qlistp
, v1
));
1600 AFTER_POTENTIAL_GC ();
1605 BEFORE_POTENTIAL_GC ();
1607 TOP
= Felt (TOP
, v1
);
1608 AFTER_POTENTIAL_GC ();
1616 BEFORE_POTENTIAL_GC ();
1618 TOP
= Fmember (TOP
, v1
);
1619 AFTER_POTENTIAL_GC ();
1626 BEFORE_POTENTIAL_GC ();
1628 TOP
= Fassq (TOP
, v1
);
1629 AFTER_POTENTIAL_GC ();
1634 BEFORE_POTENTIAL_GC ();
1635 TOP
= Fnreverse (TOP
);
1636 AFTER_POTENTIAL_GC ();
1642 BEFORE_POTENTIAL_GC ();
1644 TOP
= Fsetcar (TOP
, v1
);
1645 AFTER_POTENTIAL_GC ();
1652 BEFORE_POTENTIAL_GC ();
1654 TOP
= Fsetcdr (TOP
, v1
);
1655 AFTER_POTENTIAL_GC ();
1682 BEFORE_POTENTIAL_GC ();
1684 TOP
= Fnconc (2, &TOP
);
1685 AFTER_POTENTIAL_GC ();
1689 TOP
= (NUMBERP (TOP
) ? Qt
: Qnil
);
1693 TOP
= INTEGERP (TOP
) ? Qt
: Qnil
;
1696 #ifdef BYTE_CODE_SAFE
1698 BEFORE_POTENTIAL_GC ();
1699 error ("set-mark is an obsolete bytecode");
1700 AFTER_POTENTIAL_GC ();
1703 BEFORE_POTENTIAL_GC ();
1704 error ("scan-buffer is an obsolete bytecode");
1705 AFTER_POTENTIAL_GC ();
1714 #ifdef BYTE_CODE_SAFE
1719 if ((op
-= Bconstant
) >= const_length
)
1725 PUSH (vectorp
[op
- Bconstant
]);
1732 byte_stack_list
= byte_stack_list
->next
;
1734 /* Binds and unbinds are supposed to be compiled balanced. */
1735 if (specpdl_ptr
- specpdl
!= count
)
1736 #ifdef BYTE_CODE_SAFE
1737 error ("binding stack not balanced (serious byte compiler bug)");
1748 Qbytecode
= intern ("byte-code");
1749 staticpro (&Qbytecode
);
1751 defsubr (&Sbyte_code
);
1753 #ifdef BYTE_CODE_METER
1755 DEFVAR_LISP ("byte-code-meter", &Vbyte_code_meter
,
1756 "A vector of vectors which holds a histogram of byte-code usage.\n\
1757 (aref (aref byte-code-meter 0) CODE) indicates how many times the byte\n\
1758 opcode CODE has been executed.\n\
1759 (aref (aref byte-code-meter CODE1) CODE2), where CODE1 is not 0,\n\
1760 indicates how many times the byte opcodes CODE1 and CODE2 have been\n\
1761 executed in succession.");
1762 DEFVAR_BOOL ("byte-metering-on", &byte_metering_on
,
1763 "If non-nil, keep profiling information on byte code usage.\n\
1764 The variable byte-code-meter indicates how often each byte opcode is used.\n\
1765 If a symbol has a property named `byte-code-meter' whose value is an\n\
1766 integer, it is incremented each time that symbol's function is called.");
1768 byte_metering_on
= 0;
1769 Vbyte_code_meter
= Fmake_vector (make_number (256), make_number (0));
1770 Qbyte_code_meter
= intern ("byte-code-meter");
1771 staticpro (&Qbyte_code_meter
);
1775 XVECTOR (Vbyte_code_meter
)->contents
[i
] =
1776 Fmake_vector (make_number (256), make_number (0));