HCoop / bpt / emacs.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* lisp/emacs-lisp/byte-lexbind.el: Delete.
[bpt/emacs.git] / src / bytecode.c
1 /* Execution of byte code produced by bytecomp.el.
2 Copyright (C) 1985-1988, 1993, 2000-2011 Free Software Foundation, Inc.
3
4 This file is part of GNU Emacs.
5
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
10
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
18
19 /*
20 hacked on by jwz@lucid.com 17-jun-91
21 o added a compile-time switch to turn on simple sanity checking;
22 o put back the obsolete byte-codes for error-detection;
23 o added a new instruction, unbind_all, which I will use for
24 tail-recursion elimination;
25 o made temp_output_buffer_show be called with the right number
26 of args;
27 o made the new bytecodes be called with args in the right order;
28 o added metering support.
29
30 by Hallvard:
31 o added relative jump instructions;
32 o all conditionals now only do QUIT if they jump.
33 */
34
35 #include <config.h>
36 #include <setjmp.h>
37 #include "lisp.h"
38 #include "buffer.h"
39 #include "character.h"
40 #include "syntax.h"
41 #include "window.h"
42
43 #ifdef CHECK_FRAME_FONT
44 #include "frame.h"
45 #include "xterm.h"
46 #endif
47
48 /*
49 * define BYTE_CODE_SAFE to enable some minor sanity checking (useful for
50 * debugging the byte compiler...)
51 *
52 * define BYTE_CODE_METER to enable generation of a byte-op usage histogram.
53 */
54 /* #define BYTE_CODE_SAFE */
55 /* #define BYTE_CODE_METER */
56
57 \f
58 #ifdef BYTE_CODE_METER
59
60 Lisp_Object Qbyte_code_meter;
61 #define METER_2(code1, code2) \
62 XFASTINT (XVECTOR (XVECTOR (Vbyte_code_meter)->contents[(code1)]) \
63 ->contents[(code2)])
64
65 #define METER_1(code) METER_2 (0, (code))
66
67 #define METER_CODE(last_code, this_code) \
68 { \
69 if (byte_metering_on) \
70 { \
71 if (METER_1 (this_code) < MOST_POSITIVE_FIXNUM) \
72 METER_1 (this_code)++; \
73 if (last_code \
74 && METER_2 (last_code, this_code) < MOST_POSITIVE_FIXNUM) \
75 METER_2 (last_code, this_code)++; \
76 } \
77 }
78
79 #else /* no BYTE_CODE_METER */
80
81 #define METER_CODE(last_code, this_code)
82
83 #endif /* no BYTE_CODE_METER */
84 \f
85
86 Lisp_Object Qbytecode;
87 extern Lisp_Object Qand_optional, Qand_rest;
88
89 /* Byte codes: */
90
91 #define Bstack_ref 0
92 #define Bvarref 010
93 #define Bvarset 020
94 #define Bvarbind 030
95 #define Bcall 040
96 #define Bunbind 050
97
98 #define Bnth 070
99 #define Bsymbolp 071
100 #define Bconsp 072
101 #define Bstringp 073
102 #define Blistp 074
103 #define Beq 075
104 #define Bmemq 076
105 #define Bnot 077
106 #define Bcar 0100
107 #define Bcdr 0101
108 #define Bcons 0102
109 #define Blist1 0103
110 #define Blist2 0104
111 #define Blist3 0105
112 #define Blist4 0106
113 #define Blength 0107
114 #define Baref 0110
115 #define Baset 0111
116 #define Bsymbol_value 0112
117 #define Bsymbol_function 0113
118 #define Bset 0114
119 #define Bfset 0115
120 #define Bget 0116
121 #define Bsubstring 0117
122 #define Bconcat2 0120
123 #define Bconcat3 0121
124 #define Bconcat4 0122
125 #define Bsub1 0123
126 #define Badd1 0124
127 #define Beqlsign 0125
128 #define Bgtr 0126
129 #define Blss 0127
130 #define Bleq 0130
131 #define Bgeq 0131
132 #define Bdiff 0132
133 #define Bnegate 0133
134 #define Bplus 0134
135 #define Bmax 0135
136 #define Bmin 0136
137 #define Bmult 0137
138
139 #define Bpoint 0140
140 /* Was Bmark in v17. */
141 #define Bsave_current_buffer 0141
142 #define Bgoto_char 0142
143 #define Binsert 0143
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 */
152 #define Beolp 0154
153 #define Beobp 0155
154 #define Bbolp 0156
155 #define Bbobp 0157
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 */
162
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
172 #define Bwiden 0176
173 #define Bend_of_line 0177
174
175 #define Bconstant2 0201
176 #define Bgoto 0202
177 #define Bgotoifnil 0203
178 #define Bgotoifnonnil 0204
179 #define Bgotoifnilelsepop 0205
180 #define Bgotoifnonnilelsepop 0206
181 #define Breturn 0207
182 #define Bdiscard 0210
183 #define Bdup 0211
184
185 #define Bsave_excursion 0212
186 #define Bsave_window_excursion 0213
187 #define Bsave_restriction 0214
188 #define Bcatch 0215
189
190 #define Bunwind_protect 0216
191 #define Bcondition_case 0217
192 #define Btemp_output_buffer_setup 0220
193 #define Btemp_output_buffer_show 0221
194
195 #define Bunbind_all 0222
196
197 #define Bset_marker 0223
198 #define Bmatch_beginning 0224
199 #define Bmatch_end 0225
200 #define Bupcase 0226
201 #define Bdowncase 0227
202
203 #define Bstringeqlsign 0230
204 #define Bstringlss 0231
205 #define Bequal 0232
206 #define Bnthcdr 0233
207 #define Belt 0234
208 #define Bmember 0235
209 #define Bassq 0236
210 #define Bnreverse 0237
211 #define Bsetcar 0240
212 #define Bsetcdr 0241
213 #define Bcar_safe 0242
214 #define Bcdr_safe 0243
215 #define Bnconc 0244
216 #define Bquo 0245
217 #define Brem 0246
218 #define Bnumberp 0247
219 #define Bintegerp 0250
220
221 #define BRgoto 0252
222 #define BRgotoifnil 0253
223 #define BRgotoifnonnil 0254
224 #define BRgotoifnilelsepop 0255
225 #define BRgotoifnonnilelsepop 0256
226
227 #define BlistN 0257
228 #define BconcatN 0260
229 #define BinsertN 0261
230
231 /* Bstack_ref is code 0. */
232 #define Bstack_set 0262
233 #define Bstack_set2 0263
234 #define BdiscardN 0266
235
236 #define Bconstant 0300
237 #define CONSTANTLIM 0100
238
239 \f
240 /* Structure describing a value stack used during byte-code execution
241 in Fbyte_code. */
242
243 struct byte_stack
244 {
245 /* Program counter. This points into the byte_string below
246 and is relocated when that string is relocated. */
247 const unsigned char *pc;
248
249 /* Top and bottom of stack. The bottom points to an area of memory
250 allocated with alloca in Fbyte_code. */
251 Lisp_Object *top, *bottom;
252
253 /* The string containing the byte-code, and its current address.
254 Storing this here protects it from GC because mark_byte_stack
255 marks it. */
256 Lisp_Object byte_string;
257 const unsigned char *byte_string_start;
258
259 /* The vector of constants used during byte-code execution. Storing
260 this here protects it from GC because mark_byte_stack marks it. */
261 Lisp_Object constants;
262
263 /* Next entry in byte_stack_list. */
264 struct byte_stack *next;
265 };
266
267 /* A list of currently active byte-code execution value stacks.
268 Fbyte_code adds an entry to the head of this list before it starts
269 processing byte-code, and it removed the entry again when it is
270 done. Signalling an error truncates the list analoguous to
271 gcprolist. */
272
273 struct byte_stack *byte_stack_list;
274
275 \f
276 /* Mark objects on byte_stack_list. Called during GC. */
277
278 void
279 mark_byte_stack (void)
280 {
281 struct byte_stack *stack;
282 Lisp_Object *obj;
283
284 for (stack = byte_stack_list; stack; stack = stack->next)
285 {
286 /* If STACK->top is null here, this means there's an opcode in
287 Fbyte_code that wasn't expected to GC, but did. To find out
288 which opcode this is, record the value of `stack', and walk
289 up the stack in a debugger, stopping in frames of Fbyte_code.
290 The culprit is found in the frame of Fbyte_code where the
291 address of its local variable `stack' is equal to the
292 recorded value of `stack' here. */
293 eassert (stack->top);
294
295 for (obj = stack->bottom; obj <= stack->top; ++obj)
296 mark_object (*obj);
297
298 mark_object (stack->byte_string);
299 mark_object (stack->constants);
300 }
301 }
302
303
304 /* Unmark objects in the stacks on byte_stack_list. Relocate program
305 counters. Called when GC has completed. */
306
307 void
308 unmark_byte_stack (void)
309 {
310 struct byte_stack *stack;
311
312 for (stack = byte_stack_list; stack; stack = stack->next)
313 {
314 if (stack->byte_string_start != SDATA (stack->byte_string))
315 {
316 int offset = stack->pc - stack->byte_string_start;
317 stack->byte_string_start = SDATA (stack->byte_string);
318 stack->pc = stack->byte_string_start + offset;
319 }
320 }
321 }
322
323 \f
324 /* Fetch the next byte from the bytecode stream */
325
326 #define FETCH *stack.pc++
327
328 /* Fetch two bytes from the bytecode stream and make a 16-bit number
329 out of them */
330
331 #define FETCH2 (op = FETCH, op + (FETCH << 8))
332
333 /* Push x onto the execution stack. This used to be #define PUSH(x)
334 (*++stackp = (x)) This oddity is necessary because Alliant can't be
335 bothered to compile the preincrement operator properly, as of 4/91.
336 -JimB */
337
338 #define PUSH(x) (top++, *top = (x))
339
340 /* Pop a value off the execution stack. */
341
342 #define POP (*top--)
343
344 /* Discard n values from the execution stack. */
345
346 #define DISCARD(n) (top -= (n))
347
348 /* Get the value which is at the top of the execution stack, but don't
349 pop it. */
350
351 #define TOP (*top)
352
353 /* Actions that must be performed before and after calling a function
354 that might GC. */
355
356 #define BEFORE_POTENTIAL_GC() stack.top = top
357 #define AFTER_POTENTIAL_GC() stack.top = NULL
358
359 /* Garbage collect if we have consed enough since the last time.
360 We do this at every branch, to avoid loops that never GC. */
361
362 #define MAYBE_GC() \
363 if (consing_since_gc > gc_cons_threshold \
364 && consing_since_gc > gc_relative_threshold) \
365 { \
366 BEFORE_POTENTIAL_GC (); \
367 Fgarbage_collect (); \
368 AFTER_POTENTIAL_GC (); \
369 } \
370 else
371
372 /* Check for jumping out of range. */
373
374 #ifdef BYTE_CODE_SAFE
375
376 #define CHECK_RANGE(ARG) \
377 if (ARG >= bytestr_length) abort ()
378
379 #else /* not BYTE_CODE_SAFE */
380
381 #define CHECK_RANGE(ARG)
382
383 #endif /* not BYTE_CODE_SAFE */
384
385 /* A version of the QUIT macro which makes sure that the stack top is
386 set before signaling `quit'. */
387
388 #define BYTE_CODE_QUIT \
389 do { \
390 if (!NILP (Vquit_flag) && NILP (Vinhibit_quit)) \
391 { \
392 Lisp_Object flag = Vquit_flag; \
393 Vquit_flag = Qnil; \
394 BEFORE_POTENTIAL_GC (); \
395 if (EQ (Vthrow_on_input, flag)) \
396 Fthrow (Vthrow_on_input, Qt); \
397 Fsignal (Qquit, Qnil); \
398 AFTER_POTENTIAL_GC (); \
399 } \
400 ELSE_PENDING_SIGNALS \
401 } while (0)
402
403
404 DEFUN ("byte-code", Fbyte_code, Sbyte_code, 3, MANY, 0,
405 doc: /* Function used internally in byte-compiled code.
406 The first argument, BYTESTR, is a string of byte code;
407 the second, VECTOR, a vector of constants;
408 the third, MAXDEPTH, the maximum stack depth used in this function.
409 If the third argument is incorrect, Emacs may crash.
410
411 If ARGS-TEMPLATE is specified, it is an argument list specification,
412 according to which any remaining arguments are pushed on the stack
413 before executing BYTESTR.
414
415 usage: (byte-code BYTESTR VECTOR MAXDEP &optional ARGS-TEMPLATE &rest ARGS) */)
416 (int nargs, Lisp_Object *args)
417 {
418 Lisp_Object args_tmpl = nargs >= 4 ? args[3] : Qnil;
419 int pnargs = nargs >= 4 ? nargs - 4 : 0;
420 Lisp_Object *pargs = nargs >= 4 ? args + 4 : 0;
421 return exec_byte_code (args[0], args[1], args[2], args_tmpl, pnargs, pargs);
422 }
423
424 /* Execute the byte-code in BYTESTR. VECTOR is the constant vector, and
425 MAXDEPTH is the maximum stack depth used (if MAXDEPTH is incorrect,
426 emacs may crash!). If ARGS_TEMPLATE is non-nil, it should be a lisp
427 argument list (including &rest, &optional, etc.), and ARGS, of size
428 NARGS, should be a vector of the actual arguments. The arguments in
429 ARGS are pushed on the stack according to ARGS_TEMPLATE before
430 executing BYTESTR. */
431
432 Lisp_Object
433 exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
434 Lisp_Object args_template, int nargs, Lisp_Object *args)
435 {
436 int count = SPECPDL_INDEX ();
437 #ifdef BYTE_CODE_METER
438 int this_op = 0;
439 int prev_op;
440 #endif
441 int op;
442 /* Lisp_Object v1, v2; */
443 Lisp_Object *vectorp;
444 #ifdef BYTE_CODE_SAFE
445 int const_length = XVECTOR (vector)->size;
446 Lisp_Object *stacke;
447 #endif
448 int bytestr_length;
449 struct byte_stack stack;
450 Lisp_Object *top;
451 Lisp_Object result;
452
453 #if 0 /* CHECK_FRAME_FONT */
454 {
455 struct frame *f = SELECTED_FRAME ();
456 if (FRAME_X_P (f)
457 && FRAME_FONT (f)->direction != 0
458 && FRAME_FONT (f)->direction != 1)
459 abort ();
460 }
461 #endif
462
463 CHECK_STRING (bytestr);
464 CHECK_VECTOR (vector);
465 CHECK_NUMBER (maxdepth);
466
467 if (STRING_MULTIBYTE (bytestr))
468 /* BYTESTR must have been produced by Emacs 20.2 or the earlier
469 because they produced a raw 8-bit string for byte-code and now
470 such a byte-code string is loaded as multibyte while raw 8-bit
471 characters converted to multibyte form. Thus, now we must
472 convert them back to the originally intended unibyte form. */
473 bytestr = Fstring_as_unibyte (bytestr);
474
475 bytestr_length = SBYTES (bytestr);
476 vectorp = XVECTOR (vector)->contents;
477
478 stack.byte_string = bytestr;
479 stack.pc = stack.byte_string_start = SDATA (bytestr);
480 stack.constants = vector;
481 stack.bottom = (Lisp_Object *) alloca (XFASTINT (maxdepth)
482 * sizeof (Lisp_Object));
483 top = stack.bottom - 1;
484 stack.top = NULL;
485 stack.next = byte_stack_list;
486 byte_stack_list = &stack;
487
488 #ifdef BYTE_CODE_SAFE
489 stacke = stack.bottom - 1 + XFASTINT (maxdepth);
490 #endif
491
492 if (! NILP (args_template))
493 /* We should push some arguments on the stack. */
494 {
495 Lisp_Object at;
496 int pushed = 0, optional = 0;
497
498 for (at = args_template; CONSP (at); at = XCDR (at))
499 if (EQ (XCAR (at), Qand_optional))
500 optional = 1;
501 else if (EQ (XCAR (at), Qand_rest))
502 {
503 PUSH (Flist (nargs, args));
504 pushed = nargs;
505 at = Qnil;
506 break;
507 }
508 else if (pushed < nargs)
509 {
510 PUSH (*args++);
511 pushed++;
512 }
513 else if (optional)
514 PUSH (Qnil);
515 else
516 break;
517
518 if (pushed != nargs || !NILP (at))
519 Fsignal (Qwrong_number_of_arguments,
520 Fcons (args_template, Fcons (make_number (nargs), Qnil)));
521 }
522
523 while (1)
524 {
525 #ifdef BYTE_CODE_SAFE
526 if (top > stacke)
527 abort ();
528 else if (top < stack.bottom - 1)
529 abort ();
530 #endif
531
532 #ifdef BYTE_CODE_METER
533 prev_op = this_op;
534 this_op = op = FETCH;
535 METER_CODE (prev_op, op);
536 #else
537 op = FETCH;
538 #endif
539
540 switch (op)
541 {
542 case Bvarref + 7:
543 op = FETCH2;
544 goto varref;
545
546 case Bvarref:
547 case Bvarref + 1:
548 case Bvarref + 2:
549 case Bvarref + 3:
550 case Bvarref + 4:
551 case Bvarref + 5:
552 op = op - Bvarref;
553 goto varref;
554
555 /* This seems to be the most frequently executed byte-code
556 among the Bvarref's, so avoid a goto here. */
557 case Bvarref+6:
558 op = FETCH;
559 varref:
560 {
561 Lisp_Object v1, v2;
562
563 v1 = vectorp[op];
564 if (SYMBOLP (v1))
565 {
566 if (XSYMBOL (v1)->redirect != SYMBOL_PLAINVAL
567 || (v2 = SYMBOL_VAL (XSYMBOL (v1)),
568 EQ (v2, Qunbound)))
569 {
570 BEFORE_POTENTIAL_GC ();
571 v2 = Fsymbol_value (v1);
572 AFTER_POTENTIAL_GC ();
573 }
574 }
575 else
576 {
577 BEFORE_POTENTIAL_GC ();
578 v2 = Fsymbol_value (v1);
579 AFTER_POTENTIAL_GC ();
580 }
581 PUSH (v2);
582 break;
583 }
584
585 case Bgotoifnil:
586 {
587 Lisp_Object v1;
588 MAYBE_GC ();
589 op = FETCH2;
590 v1 = POP;
591 if (NILP (v1))
592 {
593 BYTE_CODE_QUIT;
594 CHECK_RANGE (op);
595 stack.pc = stack.byte_string_start + op;
596 }
597 break;
598 }
599
600 case Bcar:
601 {
602 Lisp_Object v1;
603 v1 = TOP;
604 TOP = CAR (v1);
605 break;
606 }
607
608 case Beq:
609 {
610 Lisp_Object v1;
611 v1 = POP;
612 TOP = EQ (v1, TOP) ? Qt : Qnil;
613 break;
614 }
615
616 case Bmemq:
617 {
618 Lisp_Object v1;
619 BEFORE_POTENTIAL_GC ();
620 v1 = POP;
621 TOP = Fmemq (TOP, v1);
622 AFTER_POTENTIAL_GC ();
623 break;
624 }
625
626 case Bcdr:
627 {
628 Lisp_Object v1;
629 v1 = TOP;
630 TOP = CDR (v1);
631 break;
632 }
633
634 case Bvarset:
635 case Bvarset+1:
636 case Bvarset+2:
637 case Bvarset+3:
638 case Bvarset+4:
639 case Bvarset+5:
640 op -= Bvarset;
641 goto varset;
642
643 case Bvarset+7:
644 op = FETCH2;
645 goto varset;
646
647 case Bvarset+6:
648 op = FETCH;
649 varset:
650 {
651 Lisp_Object sym, val;
652
653 sym = vectorp[op];
654 val = TOP;
655
656 /* Inline the most common case. */
657 if (SYMBOLP (sym)
658 && !EQ (val, Qunbound)
659 && !XSYMBOL (sym)->redirect
660 && !SYMBOL_CONSTANT_P (sym))
661 XSYMBOL (sym)->val.value = val;
662 else
663 {
664 BEFORE_POTENTIAL_GC ();
665 set_internal (sym, val, Qnil, 0);
666 AFTER_POTENTIAL_GC ();
667 }
668 }
669 (void) POP;
670 break;
671
672 case Bdup:
673 {
674 Lisp_Object v1;
675 v1 = TOP;
676 PUSH (v1);
677 break;
678 }
679
680 /* ------------------ */
681
682 case Bvarbind+6:
683 op = FETCH;
684 goto varbind;
685
686 case Bvarbind+7:
687 op = FETCH2;
688 goto varbind;
689
690 case Bvarbind:
691 case Bvarbind+1:
692 case Bvarbind+2:
693 case Bvarbind+3:
694 case Bvarbind+4:
695 case Bvarbind+5:
696 op -= Bvarbind;
697 varbind:
698 /* Specbind can signal and thus GC. */
699 BEFORE_POTENTIAL_GC ();
700 specbind (vectorp[op], POP);
701 AFTER_POTENTIAL_GC ();
702 break;
703
704 case Bcall+6:
705 op = FETCH;
706 goto docall;
707
708 case Bcall+7:
709 op = FETCH2;
710 goto docall;
711
712 case Bcall:
713 case Bcall+1:
714 case Bcall+2:
715 case Bcall+3:
716 case Bcall+4:
717 case Bcall+5:
718 op -= Bcall;
719 docall:
720 {
721 BEFORE_POTENTIAL_GC ();
722 DISCARD (op);
723 #ifdef BYTE_CODE_METER
724 if (byte_metering_on && SYMBOLP (TOP))
725 {
726 Lisp_Object v1, v2;
727
728 v1 = TOP;
729 v2 = Fget (v1, Qbyte_code_meter);
730 if (INTEGERP (v2)
731 && XINT (v2) < MOST_POSITIVE_FIXNUM)
732 {
733 XSETINT (v2, XINT (v2) + 1);
734 Fput (v1, Qbyte_code_meter, v2);
735 }
736 }
737 #endif
738 TOP = Ffuncall (op + 1, &TOP);
739 AFTER_POTENTIAL_GC ();
740 break;
741 }
742
743 case Bunbind+6:
744 op = FETCH;
745 goto dounbind;
746
747 case Bunbind+7:
748 op = FETCH2;
749 goto dounbind;
750
751 case Bunbind:
752 case Bunbind+1:
753 case Bunbind+2:
754 case Bunbind+3:
755 case Bunbind+4:
756 case Bunbind+5:
757 op -= Bunbind;
758 dounbind:
759 BEFORE_POTENTIAL_GC ();
760 unbind_to (SPECPDL_INDEX () - op, Qnil);
761 AFTER_POTENTIAL_GC ();
762 break;
763
764 case Bunbind_all:
765 /* To unbind back to the beginning of this frame. Not used yet,
766 but will be needed for tail-recursion elimination. */
767 BEFORE_POTENTIAL_GC ();
768 unbind_to (count, Qnil);
769 AFTER_POTENTIAL_GC ();
770 break;
771
772 case Bgoto:
773 MAYBE_GC ();
774 BYTE_CODE_QUIT;
775 op = FETCH2; /* pc = FETCH2 loses since FETCH2 contains pc++ */
776 CHECK_RANGE (op);
777 stack.pc = stack.byte_string_start + op;
778 break;
779
780 case Bgotoifnonnil:
781 {
782 Lisp_Object v1;
783 MAYBE_GC ();
784 op = FETCH2;
785 v1 = POP;
786 if (!NILP (v1))
787 {
788 BYTE_CODE_QUIT;
789 CHECK_RANGE (op);
790 stack.pc = stack.byte_string_start + op;
791 }
792 break;
793 }
794
795 case Bgotoifnilelsepop:
796 MAYBE_GC ();
797 op = FETCH2;
798 if (NILP (TOP))
799 {
800 BYTE_CODE_QUIT;
801 CHECK_RANGE (op);
802 stack.pc = stack.byte_string_start + op;
803 }
804 else DISCARD (1);
805 break;
806
807 case Bgotoifnonnilelsepop:
808 MAYBE_GC ();
809 op = FETCH2;
810 if (!NILP (TOP))
811 {
812 BYTE_CODE_QUIT;
813 CHECK_RANGE (op);
814 stack.pc = stack.byte_string_start + op;
815 }
816 else DISCARD (1);
817 break;
818
819 case BRgoto:
820 MAYBE_GC ();
821 BYTE_CODE_QUIT;
822 stack.pc += (int) *stack.pc - 127;
823 break;
824
825 case BRgotoifnil:
826 {
827 Lisp_Object v1;
828 MAYBE_GC ();
829 v1 = POP;
830 if (NILP (v1))
831 {
832 BYTE_CODE_QUIT;
833 stack.pc += (int) *stack.pc - 128;
834 }
835 stack.pc++;
836 break;
837 }
838
839 case BRgotoifnonnil:
840 {
841 Lisp_Object v1;
842 MAYBE_GC ();
843 v1 = POP;
844 if (!NILP (v1))
845 {
846 BYTE_CODE_QUIT;
847 stack.pc += (int) *stack.pc - 128;
848 }
849 stack.pc++;
850 break;
851 }
852
853 case BRgotoifnilelsepop:
854 MAYBE_GC ();
855 op = *stack.pc++;
856 if (NILP (TOP))
857 {
858 BYTE_CODE_QUIT;
859 stack.pc += op - 128;
860 }
861 else DISCARD (1);
862 break;
863
864 case BRgotoifnonnilelsepop:
865 MAYBE_GC ();
866 op = *stack.pc++;
867 if (!NILP (TOP))
868 {
869 BYTE_CODE_QUIT;
870 stack.pc += op - 128;
871 }
872 else DISCARD (1);
873 break;
874
875 case Breturn:
876 result = POP;
877 goto exit;
878
879 case Bdiscard:
880 DISCARD (1);
881 break;
882
883 case Bconstant2:
884 PUSH (vectorp[FETCH2]);
885 break;
886
887 case Bsave_excursion:
888 record_unwind_protect (save_excursion_restore,
889 save_excursion_save ());
890 break;
891
892 case Bsave_current_buffer:
893 case Bsave_current_buffer_1:
894 record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
895 break;
896
897 case Bsave_window_excursion:
898 BEFORE_POTENTIAL_GC ();
899 TOP = Fsave_window_excursion (TOP); /* FIXME: lexbind */
900 AFTER_POTENTIAL_GC ();
901 break;
902
903 case Bsave_restriction:
904 record_unwind_protect (save_restriction_restore,
905 save_restriction_save ());
906 break;
907
908 case Bcatch:
909 {
910 Lisp_Object v1;
911 BEFORE_POTENTIAL_GC ();
912 v1 = POP;
913 TOP = internal_catch (TOP, eval_sub, v1); /* FIXME: lexbind */
914 AFTER_POTENTIAL_GC ();
915 break;
916 }
917
918 case Bunwind_protect:
919 record_unwind_protect (Fprogn, POP); /* FIXME: lexbind */
920 break;
921
922 case Bcondition_case:
923 {
924 Lisp_Object handlers, body;
925 handlers = POP;
926 body = POP;
927 BEFORE_POTENTIAL_GC ();
928 TOP = internal_lisp_condition_case (TOP, body, handlers); /* FIXME: lexbind */
929 AFTER_POTENTIAL_GC ();
930 break;
931 }
932
933 case Btemp_output_buffer_setup:
934 BEFORE_POTENTIAL_GC ();
935 CHECK_STRING (TOP);
936 temp_output_buffer_setup (SSDATA (TOP));
937 AFTER_POTENTIAL_GC ();
938 TOP = Vstandard_output;
939 break;
940
941 case Btemp_output_buffer_show:
942 {
943 Lisp_Object v1;
944 BEFORE_POTENTIAL_GC ();
945 v1 = POP;
946 temp_output_buffer_show (TOP);
947 TOP = v1;
948 /* pop binding of standard-output */
949 unbind_to (SPECPDL_INDEX () - 1, Qnil);
950 AFTER_POTENTIAL_GC ();
951 break;
952 }
953
954 case Bnth:
955 {
956 Lisp_Object v1, v2;
957 BEFORE_POTENTIAL_GC ();
958 v1 = POP;
959 v2 = TOP;
960 CHECK_NUMBER (v2);
961 AFTER_POTENTIAL_GC ();
962 op = XINT (v2);
963 immediate_quit = 1;
964 while (--op >= 0 && CONSP (v1))
965 v1 = XCDR (v1);
966 immediate_quit = 0;
967 TOP = CAR (v1);
968 break;
969 }
970
971 case Bsymbolp:
972 TOP = SYMBOLP (TOP) ? Qt : Qnil;
973 break;
974
975 case Bconsp:
976 TOP = CONSP (TOP) ? Qt : Qnil;
977 break;
978
979 case Bstringp:
980 TOP = STRINGP (TOP) ? Qt : Qnil;
981 break;
982
983 case Blistp:
984 TOP = CONSP (TOP) || NILP (TOP) ? Qt : Qnil;
985 break;
986
987 case Bnot:
988 TOP = NILP (TOP) ? Qt : Qnil;
989 break;
990
991 case Bcons:
992 {
993 Lisp_Object v1;
994 v1 = POP;
995 TOP = Fcons (TOP, v1);
996 break;
997 }
998
999 case Blist1:
1000 TOP = Fcons (TOP, Qnil);
1001 break;
1002
1003 case Blist2:
1004 {
1005 Lisp_Object v1;
1006 v1 = POP;
1007 TOP = Fcons (TOP, Fcons (v1, Qnil));
1008 break;
1009 }
1010
1011 case Blist3:
1012 DISCARD (2);
1013 TOP = Flist (3, &TOP);
1014 break;
1015
1016 case Blist4:
1017 DISCARD (3);
1018 TOP = Flist (4, &TOP);
1019 break;
1020
1021 case BlistN:
1022 op = FETCH;
1023 DISCARD (op - 1);
1024 TOP = Flist (op, &TOP);
1025 break;
1026
1027 case Blength:
1028 BEFORE_POTENTIAL_GC ();
1029 TOP = Flength (TOP);
1030 AFTER_POTENTIAL_GC ();
1031 break;
1032
1033 case Baref:
1034 {
1035 Lisp_Object v1;
1036 BEFORE_POTENTIAL_GC ();
1037 v1 = POP;
1038 TOP = Faref (TOP, v1);
1039 AFTER_POTENTIAL_GC ();
1040 break;
1041 }
1042
1043 case Baset:
1044 {
1045 Lisp_Object v1, v2;
1046 BEFORE_POTENTIAL_GC ();
1047 v2 = POP; v1 = POP;
1048 TOP = Faset (TOP, v1, v2);
1049 AFTER_POTENTIAL_GC ();
1050 break;
1051 }
1052
1053 case Bsymbol_value:
1054 BEFORE_POTENTIAL_GC ();
1055 TOP = Fsymbol_value (TOP);
1056 AFTER_POTENTIAL_GC ();
1057 break;
1058
1059 case Bsymbol_function:
1060 BEFORE_POTENTIAL_GC ();
1061 TOP = Fsymbol_function (TOP);
1062 AFTER_POTENTIAL_GC ();
1063 break;
1064
1065 case Bset:
1066 {
1067 Lisp_Object v1;
1068 BEFORE_POTENTIAL_GC ();
1069 v1 = POP;
1070 TOP = Fset (TOP, v1);
1071 AFTER_POTENTIAL_GC ();
1072 break;
1073 }
1074
1075 case Bfset:
1076 {
1077 Lisp_Object v1;
1078 BEFORE_POTENTIAL_GC ();
1079 v1 = POP;
1080 TOP = Ffset (TOP, v1);
1081 AFTER_POTENTIAL_GC ();
1082 break;
1083 }
1084
1085 case Bget:
1086 {
1087 Lisp_Object v1;
1088 BEFORE_POTENTIAL_GC ();
1089 v1 = POP;
1090 TOP = Fget (TOP, v1);
1091 AFTER_POTENTIAL_GC ();
1092 break;
1093 }
1094
1095 case Bsubstring:
1096 {
1097 Lisp_Object v1, v2;
1098 BEFORE_POTENTIAL_GC ();
1099 v2 = POP; v1 = POP;
1100 TOP = Fsubstring (TOP, v1, v2);
1101 AFTER_POTENTIAL_GC ();
1102 break;
1103 }
1104
1105 case Bconcat2:
1106 BEFORE_POTENTIAL_GC ();
1107 DISCARD (1);
1108 TOP = Fconcat (2, &TOP);
1109 AFTER_POTENTIAL_GC ();
1110 break;
1111
1112 case Bconcat3:
1113 BEFORE_POTENTIAL_GC ();
1114 DISCARD (2);
1115 TOP = Fconcat (3, &TOP);
1116 AFTER_POTENTIAL_GC ();
1117 break;
1118
1119 case Bconcat4:
1120 BEFORE_POTENTIAL_GC ();
1121 DISCARD (3);
1122 TOP = Fconcat (4, &TOP);
1123 AFTER_POTENTIAL_GC ();
1124 break;
1125
1126 case BconcatN:
1127 op = FETCH;
1128 BEFORE_POTENTIAL_GC ();
1129 DISCARD (op - 1);
1130 TOP = Fconcat (op, &TOP);
1131 AFTER_POTENTIAL_GC ();
1132 break;
1133
1134 case Bsub1:
1135 {
1136 Lisp_Object v1;
1137 v1 = TOP;
1138 if (INTEGERP (v1))
1139 {
1140 XSETINT (v1, XINT (v1) - 1);
1141 TOP = v1;
1142 }
1143 else
1144 {
1145 BEFORE_POTENTIAL_GC ();
1146 TOP = Fsub1 (v1);
1147 AFTER_POTENTIAL_GC ();
1148 }
1149 break;
1150 }
1151
1152 case Badd1:
1153 {
1154 Lisp_Object v1;
1155 v1 = TOP;
1156 if (INTEGERP (v1))
1157 {
1158 XSETINT (v1, XINT (v1) + 1);
1159 TOP = v1;
1160 }
1161 else
1162 {
1163 BEFORE_POTENTIAL_GC ();
1164 TOP = Fadd1 (v1);
1165 AFTER_POTENTIAL_GC ();
1166 }
1167 break;
1168 }
1169
1170 case Beqlsign:
1171 {
1172 Lisp_Object v1, v2;
1173 BEFORE_POTENTIAL_GC ();
1174 v2 = POP; v1 = TOP;
1175 CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v1);
1176 CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v2);
1177 AFTER_POTENTIAL_GC ();
1178 if (FLOATP (v1) || FLOATP (v2))
1179 {
1180 double f1, f2;
1181
1182 f1 = (FLOATP (v1) ? XFLOAT_DATA (v1) : XINT (v1));
1183 f2 = (FLOATP (v2) ? XFLOAT_DATA (v2) : XINT (v2));
1184 TOP = (f1 == f2 ? Qt : Qnil);
1185 }
1186 else
1187 TOP = (XINT (v1) == XINT (v2) ? Qt : Qnil);
1188 break;
1189 }
1190
1191 case Bgtr:
1192 {
1193 Lisp_Object v1;
1194 BEFORE_POTENTIAL_GC ();
1195 v1 = POP;
1196 TOP = Fgtr (TOP, v1);
1197 AFTER_POTENTIAL_GC ();
1198 break;
1199 }
1200
1201 case Blss:
1202 {
1203 Lisp_Object v1;
1204 BEFORE_POTENTIAL_GC ();
1205 v1 = POP;
1206 TOP = Flss (TOP, v1);
1207 AFTER_POTENTIAL_GC ();
1208 break;
1209 }
1210
1211 case Bleq:
1212 {
1213 Lisp_Object v1;
1214 BEFORE_POTENTIAL_GC ();
1215 v1 = POP;
1216 TOP = Fleq (TOP, v1);
1217 AFTER_POTENTIAL_GC ();
1218 break;
1219 }
1220
1221 case Bgeq:
1222 {
1223 Lisp_Object v1;
1224 BEFORE_POTENTIAL_GC ();
1225 v1 = POP;
1226 TOP = Fgeq (TOP, v1);
1227 AFTER_POTENTIAL_GC ();
1228 break;
1229 }
1230
1231 case Bdiff:
1232 BEFORE_POTENTIAL_GC ();
1233 DISCARD (1);
1234 TOP = Fminus (2, &TOP);
1235 AFTER_POTENTIAL_GC ();
1236 break;
1237
1238 case Bnegate:
1239 {
1240 Lisp_Object v1;
1241 v1 = TOP;
1242 if (INTEGERP (v1))
1243 {
1244 XSETINT (v1, - XINT (v1));
1245 TOP = v1;
1246 }
1247 else
1248 {
1249 BEFORE_POTENTIAL_GC ();
1250 TOP = Fminus (1, &TOP);
1251 AFTER_POTENTIAL_GC ();
1252 }
1253 break;
1254 }
1255
1256 case Bplus:
1257 BEFORE_POTENTIAL_GC ();
1258 DISCARD (1);
1259 TOP = Fplus (2, &TOP);
1260 AFTER_POTENTIAL_GC ();
1261 break;
1262
1263 case Bmax:
1264 BEFORE_POTENTIAL_GC ();
1265 DISCARD (1);
1266 TOP = Fmax (2, &TOP);
1267 AFTER_POTENTIAL_GC ();
1268 break;
1269
1270 case Bmin:
1271 BEFORE_POTENTIAL_GC ();
1272 DISCARD (1);
1273 TOP = Fmin (2, &TOP);
1274 AFTER_POTENTIAL_GC ();
1275 break;
1276
1277 case Bmult:
1278 BEFORE_POTENTIAL_GC ();
1279 DISCARD (1);
1280 TOP = Ftimes (2, &TOP);
1281 AFTER_POTENTIAL_GC ();
1282 break;
1283
1284 case Bquo:
1285 BEFORE_POTENTIAL_GC ();
1286 DISCARD (1);
1287 TOP = Fquo (2, &TOP);
1288 AFTER_POTENTIAL_GC ();
1289 break;
1290
1291 case Brem:
1292 {
1293 Lisp_Object v1;
1294 BEFORE_POTENTIAL_GC ();
1295 v1 = POP;
1296 TOP = Frem (TOP, v1);
1297 AFTER_POTENTIAL_GC ();
1298 break;
1299 }
1300
1301 case Bpoint:
1302 {
1303 Lisp_Object v1;
1304 XSETFASTINT (v1, PT);
1305 PUSH (v1);
1306 break;
1307 }
1308
1309 case Bgoto_char:
1310 BEFORE_POTENTIAL_GC ();
1311 TOP = Fgoto_char (TOP);
1312 AFTER_POTENTIAL_GC ();
1313 break;
1314
1315 case Binsert:
1316 BEFORE_POTENTIAL_GC ();
1317 TOP = Finsert (1, &TOP);
1318 AFTER_POTENTIAL_GC ();
1319 break;
1320
1321 case BinsertN:
1322 op = FETCH;
1323 BEFORE_POTENTIAL_GC ();
1324 DISCARD (op - 1);
1325 TOP = Finsert (op, &TOP);
1326 AFTER_POTENTIAL_GC ();
1327 break;
1328
1329 case Bpoint_max:
1330 {
1331 Lisp_Object v1;
1332 XSETFASTINT (v1, ZV);
1333 PUSH (v1);
1334 break;
1335 }
1336
1337 case Bpoint_min:
1338 {
1339 Lisp_Object v1;
1340 XSETFASTINT (v1, BEGV);
1341 PUSH (v1);
1342 break;
1343 }
1344
1345 case Bchar_after:
1346 BEFORE_POTENTIAL_GC ();
1347 TOP = Fchar_after (TOP);
1348 AFTER_POTENTIAL_GC ();
1349 break;
1350
1351 case Bfollowing_char:
1352 {
1353 Lisp_Object v1;
1354 BEFORE_POTENTIAL_GC ();
1355 v1 = Ffollowing_char ();
1356 AFTER_POTENTIAL_GC ();
1357 PUSH (v1);
1358 break;
1359 }
1360
1361 case Bpreceding_char:
1362 {
1363 Lisp_Object v1;
1364 BEFORE_POTENTIAL_GC ();
1365 v1 = Fprevious_char ();
1366 AFTER_POTENTIAL_GC ();
1367 PUSH (v1);
1368 break;
1369 }
1370
1371 case Bcurrent_column:
1372 {
1373 Lisp_Object v1;
1374 BEFORE_POTENTIAL_GC ();
1375 XSETFASTINT (v1, (int) current_column ()); /* iftc */
1376 AFTER_POTENTIAL_GC ();
1377 PUSH (v1);
1378 break;
1379 }
1380
1381 case Bindent_to:
1382 BEFORE_POTENTIAL_GC ();
1383 TOP = Findent_to (TOP, Qnil);
1384 AFTER_POTENTIAL_GC ();
1385 break;
1386
1387 case Beolp:
1388 PUSH (Feolp ());
1389 break;
1390
1391 case Beobp:
1392 PUSH (Feobp ());
1393 break;
1394
1395 case Bbolp:
1396 PUSH (Fbolp ());
1397 break;
1398
1399 case Bbobp:
1400 PUSH (Fbobp ());
1401 break;
1402
1403 case Bcurrent_buffer:
1404 PUSH (Fcurrent_buffer ());
1405 break;
1406
1407 case Bset_buffer:
1408 BEFORE_POTENTIAL_GC ();
1409 TOP = Fset_buffer (TOP);
1410 AFTER_POTENTIAL_GC ();
1411 break;
1412
1413 case Binteractive_p:
1414 PUSH (Finteractive_p ());
1415 break;
1416
1417 case Bforward_char:
1418 BEFORE_POTENTIAL_GC ();
1419 TOP = Fforward_char (TOP);
1420 AFTER_POTENTIAL_GC ();
1421 break;
1422
1423 case Bforward_word:
1424 BEFORE_POTENTIAL_GC ();
1425 TOP = Fforward_word (TOP);
1426 AFTER_POTENTIAL_GC ();
1427 break;
1428
1429 case Bskip_chars_forward:
1430 {
1431 Lisp_Object v1;
1432 BEFORE_POTENTIAL_GC ();
1433 v1 = POP;
1434 TOP = Fskip_chars_forward (TOP, v1);
1435 AFTER_POTENTIAL_GC ();
1436 break;
1437 }
1438
1439 case Bskip_chars_backward:
1440 {
1441 Lisp_Object v1;
1442 BEFORE_POTENTIAL_GC ();
1443 v1 = POP;
1444 TOP = Fskip_chars_backward (TOP, v1);
1445 AFTER_POTENTIAL_GC ();
1446 break;
1447 }
1448
1449 case Bforward_line:
1450 BEFORE_POTENTIAL_GC ();
1451 TOP = Fforward_line (TOP);
1452 AFTER_POTENTIAL_GC ();
1453 break;
1454
1455 case Bchar_syntax:
1456 {
1457 int c;
1458
1459 BEFORE_POTENTIAL_GC ();
1460 CHECK_CHARACTER (TOP);
1461 AFTER_POTENTIAL_GC ();
1462 c = XFASTINT (TOP);
1463 if (NILP (current_buffer->enable_multibyte_characters))
1464 MAKE_CHAR_MULTIBYTE (c);
1465 XSETFASTINT (TOP, syntax_code_spec[(int) SYNTAX (c)]);
1466 }
1467 break;
1468
1469 case Bbuffer_substring:
1470 {
1471 Lisp_Object v1;
1472 BEFORE_POTENTIAL_GC ();
1473 v1 = POP;
1474 TOP = Fbuffer_substring (TOP, v1);
1475 AFTER_POTENTIAL_GC ();
1476 break;
1477 }
1478
1479 case Bdelete_region:
1480 {
1481 Lisp_Object v1;
1482 BEFORE_POTENTIAL_GC ();
1483 v1 = POP;
1484 TOP = Fdelete_region (TOP, v1);
1485 AFTER_POTENTIAL_GC ();
1486 break;
1487 }
1488
1489 case Bnarrow_to_region:
1490 {
1491 Lisp_Object v1;
1492 BEFORE_POTENTIAL_GC ();
1493 v1 = POP;
1494 TOP = Fnarrow_to_region (TOP, v1);
1495 AFTER_POTENTIAL_GC ();
1496 break;
1497 }
1498
1499 case Bwiden:
1500 BEFORE_POTENTIAL_GC ();
1501 PUSH (Fwiden ());
1502 AFTER_POTENTIAL_GC ();
1503 break;
1504
1505 case Bend_of_line:
1506 BEFORE_POTENTIAL_GC ();
1507 TOP = Fend_of_line (TOP);
1508 AFTER_POTENTIAL_GC ();
1509 break;
1510
1511 case Bset_marker:
1512 {
1513 Lisp_Object v1, v2;
1514 BEFORE_POTENTIAL_GC ();
1515 v1 = POP;
1516 v2 = POP;
1517 TOP = Fset_marker (TOP, v2, v1);
1518 AFTER_POTENTIAL_GC ();
1519 break;
1520 }
1521
1522 case Bmatch_beginning:
1523 BEFORE_POTENTIAL_GC ();
1524 TOP = Fmatch_beginning (TOP);
1525 AFTER_POTENTIAL_GC ();
1526 break;
1527
1528 case Bmatch_end:
1529 BEFORE_POTENTIAL_GC ();
1530 TOP = Fmatch_end (TOP);
1531 AFTER_POTENTIAL_GC ();
1532 break;
1533
1534 case Bupcase:
1535 BEFORE_POTENTIAL_GC ();
1536 TOP = Fupcase (TOP);
1537 AFTER_POTENTIAL_GC ();
1538 break;
1539
1540 case Bdowncase:
1541 BEFORE_POTENTIAL_GC ();
1542 TOP = Fdowncase (TOP);
1543 AFTER_POTENTIAL_GC ();
1544 break;
1545
1546 case Bstringeqlsign:
1547 {
1548 Lisp_Object v1;
1549 BEFORE_POTENTIAL_GC ();
1550 v1 = POP;
1551 TOP = Fstring_equal (TOP, v1);
1552 AFTER_POTENTIAL_GC ();
1553 break;
1554 }
1555
1556 case Bstringlss:
1557 {
1558 Lisp_Object v1;
1559 BEFORE_POTENTIAL_GC ();
1560 v1 = POP;
1561 TOP = Fstring_lessp (TOP, v1);
1562 AFTER_POTENTIAL_GC ();
1563 break;
1564 }
1565
1566 case Bequal:
1567 {
1568 Lisp_Object v1;
1569 v1 = POP;
1570 TOP = Fequal (TOP, v1);
1571 break;
1572 }
1573
1574 case Bnthcdr:
1575 {
1576 Lisp_Object v1;
1577 BEFORE_POTENTIAL_GC ();
1578 v1 = POP;
1579 TOP = Fnthcdr (TOP, v1);
1580 AFTER_POTENTIAL_GC ();
1581 break;
1582 }
1583
1584 case Belt:
1585 {
1586 Lisp_Object v1, v2;
1587 if (CONSP (TOP))
1588 {
1589 /* Exchange args and then do nth. */
1590 BEFORE_POTENTIAL_GC ();
1591 v2 = POP;
1592 v1 = TOP;
1593 CHECK_NUMBER (v2);
1594 AFTER_POTENTIAL_GC ();
1595 op = XINT (v2);
1596 immediate_quit = 1;
1597 while (--op >= 0 && CONSP (v1))
1598 v1 = XCDR (v1);
1599 immediate_quit = 0;
1600 TOP = CAR (v1);
1601 }
1602 else
1603 {
1604 BEFORE_POTENTIAL_GC ();
1605 v1 = POP;
1606 TOP = Felt (TOP, v1);
1607 AFTER_POTENTIAL_GC ();
1608 }
1609 break;
1610 }
1611
1612 case Bmember:
1613 {
1614 Lisp_Object v1;
1615 BEFORE_POTENTIAL_GC ();
1616 v1 = POP;
1617 TOP = Fmember (TOP, v1);
1618 AFTER_POTENTIAL_GC ();
1619 break;
1620 }
1621
1622 case Bassq:
1623 {
1624 Lisp_Object v1;
1625 BEFORE_POTENTIAL_GC ();
1626 v1 = POP;
1627 TOP = Fassq (TOP, v1);
1628 AFTER_POTENTIAL_GC ();
1629 break;
1630 }
1631
1632 case Bnreverse:
1633 BEFORE_POTENTIAL_GC ();
1634 TOP = Fnreverse (TOP);
1635 AFTER_POTENTIAL_GC ();
1636 break;
1637
1638 case Bsetcar:
1639 {
1640 Lisp_Object v1;
1641 BEFORE_POTENTIAL_GC ();
1642 v1 = POP;
1643 TOP = Fsetcar (TOP, v1);
1644 AFTER_POTENTIAL_GC ();
1645 break;
1646 }
1647
1648 case Bsetcdr:
1649 {
1650 Lisp_Object v1;
1651 BEFORE_POTENTIAL_GC ();
1652 v1 = POP;
1653 TOP = Fsetcdr (TOP, v1);
1654 AFTER_POTENTIAL_GC ();
1655 break;
1656 }
1657
1658 case Bcar_safe:
1659 {
1660 Lisp_Object v1;
1661 v1 = TOP;
1662 TOP = CAR_SAFE (v1);
1663 break;
1664 }
1665
1666 case Bcdr_safe:
1667 {
1668 Lisp_Object v1;
1669 v1 = TOP;
1670 TOP = CDR_SAFE (v1);
1671 break;
1672 }
1673
1674 case Bnconc:
1675 BEFORE_POTENTIAL_GC ();
1676 DISCARD (1);
1677 TOP = Fnconc (2, &TOP);
1678 AFTER_POTENTIAL_GC ();
1679 break;
1680
1681 case Bnumberp:
1682 TOP = (NUMBERP (TOP) ? Qt : Qnil);
1683 break;
1684
1685 case Bintegerp:
1686 TOP = INTEGERP (TOP) ? Qt : Qnil;
1687 break;
1688
1689 #ifdef BYTE_CODE_SAFE
1690 case Bset_mark:
1691 BEFORE_POTENTIAL_GC ();
1692 error ("set-mark is an obsolete bytecode");
1693 AFTER_POTENTIAL_GC ();
1694 break;
1695 case Bscan_buffer:
1696 BEFORE_POTENTIAL_GC ();
1697 error ("scan-buffer is an obsolete bytecode");
1698 AFTER_POTENTIAL_GC ();
1699 break;
1700 #endif
1701
1702 /* Handy byte-codes for lexical binding. */
1703 case Bstack_ref:
1704 case Bstack_ref+1:
1705 case Bstack_ref+2:
1706 case Bstack_ref+3:
1707 case Bstack_ref+4:
1708 case Bstack_ref+5:
1709 PUSH (stack.bottom[op - Bstack_ref]);
1710 break;
1711 case Bstack_ref+6:
1712 PUSH (stack.bottom[FETCH]);
1713 break;
1714 case Bstack_ref+7:
1715 PUSH (stack.bottom[FETCH2]);
1716 break;
1717 case Bstack_set:
1718 stack.bottom[FETCH] = POP;
1719 break;
1720 case Bstack_set2:
1721 stack.bottom[FETCH2] = POP;
1722 break;
1723 case BdiscardN:
1724 op = FETCH;
1725 if (op & 0x80)
1726 {
1727 op &= 0x7F;
1728 top[-op] = TOP;
1729 }
1730 DISCARD (op);
1731 break;
1732
1733 case 255:
1734 default:
1735 #ifdef BYTE_CODE_SAFE
1736 if (op < Bconstant)
1737 {
1738 abort ();
1739 }
1740 if ((op -= Bconstant) >= const_length)
1741 {
1742 abort ();
1743 }
1744 PUSH (vectorp[op]);
1745 #else
1746 PUSH (vectorp[op - Bconstant]);
1747 #endif
1748 }
1749 }
1750
1751 exit:
1752
1753 byte_stack_list = byte_stack_list->next;
1754
1755 /* Binds and unbinds are supposed to be compiled balanced. */
1756 if (SPECPDL_INDEX () != count)
1757 #ifdef BYTE_CODE_SAFE
1758 error ("binding stack not balanced (serious byte compiler bug)");
1759 #else
1760 abort ();
1761 #endif
1762
1763 return result;
1764 }
1765
1766 void
1767 syms_of_bytecode (void)
1768 {
1769 Qbytecode = intern_c_string ("byte-code");
1770 staticpro (&Qbytecode);
1771
1772 defsubr (&Sbyte_code);
1773
1774 #ifdef BYTE_CODE_METER
1775
1776 DEFVAR_LISP ("byte-code-meter", Vbyte_code_meter,
1777 doc: /* A vector of vectors which holds a histogram of byte-code usage.
1778 \(aref (aref byte-code-meter 0) CODE) indicates how many times the byte
1779 opcode CODE has been executed.
1780 \(aref (aref byte-code-meter CODE1) CODE2), where CODE1 is not 0,
1781 indicates how many times the byte opcodes CODE1 and CODE2 have been
1782 executed in succession. */);
1783
1784 DEFVAR_BOOL ("byte-metering-on", byte_metering_on,
1785 doc: /* If non-nil, keep profiling information on byte code usage.
1786 The variable byte-code-meter indicates how often each byte opcode is used.
1787 If a symbol has a property named `byte-code-meter' whose value is an
1788 integer, it is incremented each time that symbol's function is called. */);
1789
1790 byte_metering_on = 0;
1791 Vbyte_code_meter = Fmake_vector (make_number (256), make_number (0));
1792 Qbyte_code_meter = intern_c_string ("byte-code-meter");
1793 staticpro (&Qbyte_code_meter);
1794 {
1795 int i = 256;
1796 while (i--)
1797 XVECTOR (Vbyte_code_meter)->contents[i] =
1798 Fmake_vector (make_number (256), make_number (0));
1799 }
1800 #endif
1801 }
Unnamed repository; edit this file 'description' to name the repository.