ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/cvsroot/microscheme/scheme.c
(Generate patch)

Comparing cvsroot/microscheme/scheme.c (file contents):
Revision 1.10 by root, Thu Nov 26 00:03:19 2015 UTC vs.
Revision 1.15 by root, Thu Nov 26 09:05:20 2015 UTC

… …
208#define T_SYNTAX 0x0010 208#define T_SYNTAX 0x0010
209#define T_IMMUTABLE 0x0020 209#define T_IMMUTABLE 0x0020
210#define T_ATOM 0x0040 /* only for gc */ 210#define T_ATOM 0x0040 /* only for gc */
211#define T_MARK 0x0080 /* only for gc */ 211#define T_MARK 0x0080 /* only for gc */
212 212
213static num num_add (num a, num b); 213enum num_op { NUM_ADD, NUM_SUB, NUM_MUL, NUM_INTDIV };
214static num num_mul (num a, num b); 214
215static num num_div (num a, num b); 215static num num_op (enum num_op op, num a, num b);
216static num num_intdiv (num a, num b); 216static num num_intdiv (num a, num b);
217static num num_sub (num a, num b);
218static num num_rem (num a, num b); 217static num num_rem (num a, num b);
219static num num_mod (num a, num b); 218static num num_mod (num a, num b);
220static int num_eq (num a, num b);
221static int num_gt (num a, num b);
222static int num_ge (num a, num b);
223static int num_lt (num a, num b);
224static int num_le (num a, num b);
225 219
226#if USE_MATH 220#if USE_MATH
227static double round_per_R5RS (double x); 221static double round_per_R5RS (double x);
228#endif 222#endif
229static int is_zero_rvalue (RVALUE x); 223static int is_zero_rvalue (RVALUE x);
… …
376{ 370{
377 return type (p) == T_PAIR; 371 return type (p) == T_PAIR;
378} 372}
379 373
380#define car(p) ((p)->object.cons.car + 0) 374#define car(p) ((p)->object.cons.car + 0)
381#define cdr(p) ((p)->object.cons.cdr) /* find_consecutive_cells uses &cdr */ 375#define cdr(p) ((p)->object.cons.cdr + 0)
382 376
383#define caar(p) car (car (p)) 377static pointer caar (pointer p) { return car (car (p)); }
384#define cadr(p) car (cdr (p)) 378static pointer cadr (pointer p) { return car (cdr (p)); }
385#define cdar(p) cdr (car (p)) 379static pointer cdar (pointer p) { return cdr (car (p)); }
386#define cddr(p) cdr (cdr (p)) 380static pointer cddr (pointer p) { return cdr (cdr (p)); }
387 381
388#define cadar(p) car (cdr (car (p))) 382static pointer cadar (pointer p) { return car (cdr (car (p))); }
389#define caddr(p) car (cdr (cdr (p))) 383static pointer caddr (pointer p) { return car (cdr (cdr (p))); }
390#define cdaar(p) cdr (car (car (p))) 384static pointer cdaar (pointer p) { return cdr (car (car (p))); }
391 385
392INTERFACE void 386INTERFACE void
393set_car (pointer p, pointer q) 387set_car (pointer p, pointer q)
394{ 388{
395 p->object.cons.car = q; 389 p->object.cons.car = q;
… …
671static pointer ss_get_cont (SCHEME_P); 665static pointer ss_get_cont (SCHEME_P);
672static void ss_set_cont (SCHEME_P_ pointer cont); 666static void ss_set_cont (SCHEME_P_ pointer cont);
673static void dump_stack_mark (SCHEME_P); 667static void dump_stack_mark (SCHEME_P);
674static pointer opexe_0 (SCHEME_P_ enum scheme_opcodes op); 668static pointer opexe_0 (SCHEME_P_ enum scheme_opcodes op);
675static pointer opexe_2 (SCHEME_P_ enum scheme_opcodes op); 669static pointer opexe_2 (SCHEME_P_ enum scheme_opcodes op);
670static pointer opexe_r (SCHEME_P_ enum scheme_opcodes op);
676static pointer opexe_3 (SCHEME_P_ enum scheme_opcodes op); 671static pointer opexe_3 (SCHEME_P_ enum scheme_opcodes op);
677static pointer opexe_4 (SCHEME_P_ enum scheme_opcodes op); 672static pointer opexe_4 (SCHEME_P_ enum scheme_opcodes op);
678static pointer opexe_5 (SCHEME_P_ enum scheme_opcodes op); 673static pointer opexe_5 (SCHEME_P_ enum scheme_opcodes op);
679static pointer opexe_6 (SCHEME_P_ enum scheme_opcodes op); 674static pointer opexe_6 (SCHEME_P_ enum scheme_opcodes op);
680static void Eval_Cycle (SCHEME_P_ enum scheme_opcodes op); 675static void Eval_Cycle (SCHEME_P_ enum scheme_opcodes op);
681static void assign_syntax (SCHEME_P_ const char *name); 676static void assign_syntax (SCHEME_P_ const char *name);
682static int syntaxnum (pointer p); 677static int syntaxnum (pointer p);
683static void assign_proc (SCHEME_P_ enum scheme_opcodes, const char *name); 678static void assign_proc (SCHEME_P_ enum scheme_opcodes, const char *name);
684 679
685static num 680static num
686num_add (num a, num b) 681num_op (enum num_op op, num a, num b)
687{ 682{
688 num ret; 683 num ret;
689 684
690 num_set_fixnum (ret, num_is_fixnum (a) && num_is_fixnum (b)); 685 num_set_fixnum (ret, num_is_fixnum (a) && num_is_fixnum (b));
691 686
692 if (num_is_fixnum (ret)) 687 if (num_is_fixnum (ret))
693 num_set_ivalue (ret, num_get_ivalue (a) + num_get_ivalue (b)); 688 {
689 IVALUE av = num_get_ivalue (a);
690 IVALUE bv = num_get_ivalue (b);
691
692 switch (op)
693 {
694 case NUM_ADD: av += bv; break;
695 case NUM_SUB: av -= bv; break;
696 case NUM_MUL: av *= bv; break;
697 case NUM_INTDIV: av /= bv; break;
698 }
699
700 num_set_ivalue (ret, av);
701 }
694 else 702 else
695 num_set_rvalue (ret, num_get_rvalue (a) + num_get_rvalue (b)); 703 {
704 RVALUE av = num_get_rvalue (a);
705 RVALUE bv = num_get_rvalue (b);
696 706
697 return ret; 707 switch (op)
698} 708 {
709 case NUM_ADD: av += bv; break;
710 case NUM_SUB: av -= bv; break;
711 case NUM_MUL: av *= bv; break;
712 case NUM_INTDIV: av /= bv; break;
713 }
699 714
700static num 715 num_set_rvalue (ret, av);
701num_mul (num a, num b) 716 }
702{
703 num ret;
704
705 num_set_fixnum (ret, num_is_fixnum (a) && num_is_fixnum (b));
706
707 if (num_is_fixnum (ret))
708 num_set_ivalue (ret, num_get_ivalue (a) * num_get_ivalue (b));
709 else
710 num_set_rvalue (ret, num_get_rvalue (a) * num_get_rvalue (b));
711 717
712 return ret; 718 return ret;
713} 719}
714 720
715static num 721static num
… …
726 732
727 return ret; 733 return ret;
728} 734}
729 735
730static num 736static num
731num_intdiv (num a, num b)
732{
733 num ret;
734
735 num_set_fixnum (ret, num_is_fixnum (a) && num_is_fixnum (b));
736
737 if (num_is_fixnum (ret))
738 num_set_ivalue (ret, num_get_ivalue (a) / num_get_ivalue (b));
739 else
740 num_set_rvalue (ret, num_get_rvalue (a) / num_get_rvalue (b));
741
742 return ret;
743}
744
745static num
746num_sub (num a, num b)
747{
748 num ret;
749
750 num_set_fixnum (ret, num_is_fixnum (a) && num_is_fixnum (b));
751
752 if (num_is_fixnum (ret))
753 num_set_ivalue (ret, num_get_ivalue (a) - num_get_ivalue (b));
754 else
755 num_set_rvalue (ret, num_get_rvalue (a) - num_get_rvalue (b));
756
757 return ret;
758}
759
760static num
761num_rem (num a, num b) 737num_rem (num a, num b)
762{ 738{
763 num ret; 739 num ret;
764 long e1, e2, res; 740 long e1, e2, res;
765 741
… …
801 777
802 num_set_ivalue (ret, res); 778 num_set_ivalue (ret, res);
803 return ret; 779 return ret;
804} 780}
805 781
782/* this completely disrespects NaNs */
806static int 783static int
807num_eq (num a, num b) 784num_cmp (num a, num b)
808{ 785{
786 int is_fixnum = num_is_fixnum (a) && num_is_fixnum (b);
809 int ret; 787 int ret;
810 int is_fixnum = num_is_fixnum (a) && num_is_fixnum (b);
811 788
812 if (is_fixnum) 789 if (is_fixnum)
813 ret = num_get_ivalue (a) == num_get_ivalue (b); 790 {
791 IVALUE av = num_get_ivalue (a);
792 IVALUE bv = num_get_ivalue (b);
793
794 ret = av == bv ? 0 : av < bv ? -1 : +1;
795 }
814 else 796 else
815 ret = num_get_rvalue (a) == num_get_rvalue (b); 797 {
798 RVALUE av = num_get_rvalue (a);
799 RVALUE bv = num_get_rvalue (b);
800
801 ret = av == bv ? 0 : av < bv ? -1 : +1;
802 }
816 803
817 return ret; 804 return ret;
818}
819
820
821static int
822num_gt (num a, num b)
823{
824 int ret;
825 int is_fixnum = num_is_fixnum (a) && num_is_fixnum (b);
826
827 if (is_fixnum)
828 ret = num_get_ivalue (a) > num_get_ivalue (b);
829 else
830 ret = num_get_rvalue (a) > num_get_rvalue (b);
831
832 return ret;
833}
834
835static int
836num_ge (num a, num b)
837{
838 return !num_lt (a, b);
839}
840
841static int
842num_lt (num a, num b)
843{
844 int ret;
845 int is_fixnum = num_is_fixnum (a) && num_is_fixnum (b);
846
847 if (is_fixnum)
848 ret = num_get_ivalue (a) < num_get_ivalue (b);
849 else
850 ret = num_get_rvalue (a) < num_get_rvalue (b);
851
852 return ret;
853}
854
855static int
856num_le (num a, num b)
857{
858 return !num_gt (a, b);
859} 805}
860 806
861#if USE_MATH 807#if USE_MATH
862 808
863/* Round to nearest. Round to even if midway */ 809/* Round to nearest. Round to even if midway */
… …
2796 } 2742 }
2797 else if (is_number (a)) 2743 else if (is_number (a))
2798 { 2744 {
2799 if (is_number (b)) 2745 if (is_number (b))
2800 if (num_is_integer (a) == num_is_integer (b)) 2746 if (num_is_integer (a) == num_is_integer (b))
2801 return num_eq (nvalue (a), nvalue (b)); 2747 return num_cmp (nvalue (a), nvalue (b)) == 0;
2802 2748
2803 return 0; 2749 return 0;
2804 } 2750 }
2805 else if (is_character (a)) 2751 else if (is_character (a))
2806 { 2752 {
… …
3968 SCHEME_V->code = car (SCHEME_V->args); 3914 SCHEME_V->code = car (SCHEME_V->args);
3969 SCHEME_V->args = cons (mk_continuation (SCHEME_A_ ss_get_cont (SCHEME_A)), NIL); 3915 SCHEME_V->args = cons (mk_continuation (SCHEME_A_ ss_get_cont (SCHEME_A)), NIL);
3970 s_goto (OP_APPLY); 3916 s_goto (OP_APPLY);
3971 } 3917 }
3972 3918
3973 return S_T; 3919 abort ();
3974} 3920}
3975 3921
3976static pointer 3922static pointer
3977opexe_2 (SCHEME_P_ enum scheme_opcodes op) 3923opexe_2 (SCHEME_P_ enum scheme_opcodes op)
3978{ 3924{
… …
4107 4053
4108 case OP_ADD: /* + */ 4054 case OP_ADD: /* + */
4109 v = num_zero; 4055 v = num_zero;
4110 4056
4111 for (x = SCHEME_V->args; x != NIL; x = cdr (x)) 4057 for (x = SCHEME_V->args; x != NIL; x = cdr (x))
4112 v = num_add (v, nvalue (car (x))); 4058 v = num_op ('+', v, nvalue (car (x)));
4113 4059
4114 s_return (mk_number (SCHEME_A_ v)); 4060 s_return (mk_number (SCHEME_A_ v));
4115 4061
4116 case OP_MUL: /* * */ 4062 case OP_MUL: /* * */
4117 v = num_one; 4063 v = num_one;
4118 4064
4119 for (x = SCHEME_V->args; x != NIL; x = cdr (x)) 4065 for (x = SCHEME_V->args; x != NIL; x = cdr (x))
4120 v = num_mul (v, nvalue (car (x))); 4066 v = num_op ('+', v, nvalue (car (x)));
4121 4067
4122 s_return (mk_number (SCHEME_A_ v)); 4068 s_return (mk_number (SCHEME_A_ v));
4123 4069
4124 case OP_SUB: /* - */ 4070 case OP_SUB: /* - */
4125 if (cdr (SCHEME_V->args) == NIL) 4071 if (cdr (SCHEME_V->args) == NIL)
… …
4132 x = cdr (SCHEME_V->args); 4078 x = cdr (SCHEME_V->args);
4133 v = nvalue (car (SCHEME_V->args)); 4079 v = nvalue (car (SCHEME_V->args));
4134 } 4080 }
4135 4081
4136 for (; x != NIL; x = cdr (x)) 4082 for (; x != NIL; x = cdr (x))
4137 v = num_sub (v, nvalue (car (x))); 4083 v = num_op ('+', v, nvalue (car (x)));
4138 4084
4139 s_return (mk_number (SCHEME_A_ v)); 4085 s_return (mk_number (SCHEME_A_ v));
4140 4086
4141 case OP_DIV: /* / */ 4087 case OP_DIV: /* / */
4142 if (cdr (SCHEME_V->args) == NIL) 4088 if (cdr (SCHEME_V->args) == NIL)
… …
4173 } 4119 }
4174 4120
4175 for (; x != NIL; x = cdr (x)) 4121 for (; x != NIL; x = cdr (x))
4176 { 4122 {
4177 if (ivalue (car (x)) != 0) 4123 if (ivalue (car (x)) != 0)
4178 v = num_intdiv (v, nvalue (car (x))); 4124 v = num_op ('/', v, nvalue (car (x)));
4179 else 4125 else
4180 Error_0 ("quotient: division by zero"); 4126 Error_0 ("quotient: division by zero");
4181 } 4127 }
4182 4128
4183 s_return (mk_number (SCHEME_A_ v)); 4129 s_return (mk_number (SCHEME_A_ v));
… …
4571 } 4517 }
4572 } 4518 }
4573} 4519}
4574 4520
4575static pointer 4521static pointer
4522opexe_r (SCHEME_P_ enum scheme_opcodes op)
4523{
4524 pointer x = SCHEME_V->args;
4525
4526 for (;;)
4527 {
4528 num v = nvalue (car (x));
4529 x = cdr (x);
4530
4531 if (x == NIL)
4532 break;
4533
4534 int r = num_cmp (v, nvalue (car (x)));
4535
4536 switch (op)
4537 {
4538 case OP_NUMEQ: r = r == 0; break;
4539 case OP_LESS: r = r < 0; break;
4540 case OP_GRE: r = r > 0; break;
4541 case OP_LEQ: r = r <= 0; break;
4542 case OP_GEQ: r = r >= 0; break;
4543 }
4544
4545 if (!r)
4546 s_return (S_F);
4547 }
4548
4549 s_return (S_T);
4550}
4551
4552static pointer
4576opexe_3 (SCHEME_P_ enum scheme_opcodes op) 4553opexe_3 (SCHEME_P_ enum scheme_opcodes op)
4577{ 4554{
4578 pointer x; 4555 pointer x = SCHEME_V->args;
4579 num v; 4556 pointer a = car (x);
4580 int (*comp_func) (num, num); 4557 pointer d = cdr (x);
4558 int r;
4581 4559
4582 switch (op) 4560 switch (op)
4583 { 4561 {
4584 case OP_NOT: /* not */ 4562 case OP_NOT: /* not */ r = is_false (a) ; break;
4585 s_retbool (is_false (car (SCHEME_V->args))); 4563 case OP_BOOLP: /* boolean? */ r = a == S_F || a == S_T; break;
4564 case OP_EOFOBJP: /* eof-object? */ r = a == S_EOF ; break;
4565 case OP_NULLP: /* null? */ r = a == NIL ; break;
4566 case OP_SYMBOLP: /* symbol? */ r = is_symbol (a) ; break;
4567 case OP_NUMBERP: /* number? */ r = is_number (a) ; break;
4568 case OP_STRINGP: /* string? */ r = is_string (a) ; break;
4569 case OP_INTEGERP: /* integer? */ r = is_integer (a) ; break;
4570 case OP_REALP: /* real? */ r = is_number (a) ; break; /* all numbers are real */
4571 case OP_CHARP: /* char? */ r = is_character (a) ; break;
4586 4572
4587 case OP_BOOLP: /* boolean? */
4588 s_retbool (car (SCHEME_V->args) == S_F || car (SCHEME_V->args) == S_T);
4589
4590 case OP_EOFOBJP: /* boolean? */
4591 s_retbool (car (SCHEME_V->args) == S_EOF);
4592
4593 case OP_NULLP: /* null? */
4594 s_retbool (car (SCHEME_V->args) == NIL);
4595
4596 case OP_NUMEQ: /* = */
4597 case OP_LESS: /* < */
4598 case OP_GRE: /* > */
4599 case OP_LEQ: /* <= */
4600 case OP_GEQ: /* >= */
4601 switch (op)
4602 {
4603 case OP_NUMEQ:
4604 comp_func = num_eq;
4605 break;
4606
4607 case OP_LESS:
4608 comp_func = num_lt;
4609 break;
4610
4611 case OP_GRE:
4612 comp_func = num_gt;
4613 break;
4614
4615 case OP_LEQ:
4616 comp_func = num_le;
4617 break;
4618
4619 case OP_GEQ:
4620 comp_func = num_ge;
4621 break;
4622 }
4623
4624 x = SCHEME_V->args;
4625 v = nvalue (car (x));
4626 x = cdr (x);
4627
4628 for (; x != NIL; x = cdr (x))
4629 {
4630 if (!comp_func (v, nvalue (car (x))))
4631 s_retbool (0);
4632
4633 v = nvalue (car (x));
4634 }
4635
4636 s_retbool (1);
4637
4638 case OP_SYMBOLP: /* symbol? */
4639 s_retbool (is_symbol (car (SCHEME_V->args)));
4640
4641 case OP_NUMBERP: /* number? */
4642 s_retbool (is_number (car (SCHEME_V->args)));
4643
4644 case OP_STRINGP: /* string? */
4645 s_retbool (is_string (car (SCHEME_V->args)));
4646
4647 case OP_INTEGERP: /* integer? */
4648 s_retbool (is_integer (car (SCHEME_V->args)));
4649
4650 case OP_REALP: /* real? */
4651 s_retbool (is_number (car (SCHEME_V->args))); /* All numbers are real */
4652
4653 case OP_CHARP: /* char? */
4654 s_retbool (is_character (car (SCHEME_V->args)));
4655#if USE_CHAR_CLASSIFIERS 4573#if USE_CHAR_CLASSIFIERS
4656
4657 case OP_CHARAP: /* char-alphabetic? */ 4574 case OP_CHARAP: /* char-alphabetic? */ r = Cisalpha (ivalue (a)); break;
4658 s_retbool (Cisalpha (ivalue (car (SCHEME_V->args)))); 4575 case OP_CHARNP: /* char-numeric? */ r = Cisdigit (ivalue (a)); break;
4659
4660 case OP_CHARNP: /* char-numeric? */
4661 s_retbool (Cisdigit (ivalue (car (SCHEME_V->args))));
4662
4663 case OP_CHARWP: /* char-whitespace? */ 4576 case OP_CHARWP: /* char-whitespace? */ r = Cisspace (ivalue (a)); break;
4664 s_retbool (Cisspace (ivalue (car (SCHEME_V->args))));
4665
4666 case OP_CHARUP: /* char-upper-case? */ 4577 case OP_CHARUP: /* char-upper-case? */ r = Cisupper (ivalue (a)); break;
4667 s_retbool (Cisupper (ivalue (car (SCHEME_V->args))));
4668
4669 case OP_CHARLP: /* char-lower-case? */ 4578 case OP_CHARLP: /* char-lower-case? */ r = Cislower (ivalue (a)); break;
4670 s_retbool (Cislower (ivalue (car (SCHEME_V->args))));
4671#endif 4579#endif
4580
4672#if USE_PORTS 4581#if USE_PORTS
4673 4582 case OP_PORTP: /* port? */ r = is_port (a) ; break;
4674 case OP_PORTP: /* port? */
4675 s_retbool (is_port (car (SCHEME_V->args)));
4676
4677 case OP_INPORTP: /* input-port? */ 4583 case OP_INPORTP: /* input-port? */ r = is_inport (a) ; break;
4678 s_retbool (is_inport (car (SCHEME_V->args)));
4679
4680 case OP_OUTPORTP: /* output-port? */ 4584 case OP_OUTPORTP: /* output-port? */ r = is_outport (a); break;
4681 s_retbool (is_outport (car (SCHEME_V->args)));
4682#endif 4585#endif
4683 4586
4684 case OP_PROCP: /* procedure? */ 4587 case OP_PROCP: /* procedure? */
4685 4588
4686 /*-- 4589 /*--
4687 * continuation should be procedure by the example 4590 * continuation should be procedure by the example
4688 * (call-with-current-continuation procedure?) ==> #t 4591 * (call-with-current-continuation procedure?) ==> #t
4689 * in R^3 report sec. 6.9 4592 * in R^3 report sec. 6.9
4690 */ 4593 */
4691 s_retbool (is_proc (car (SCHEME_V->args)) || is_closure (car (SCHEME_V->args)) 4594 r = is_proc (a) || is_closure (a) || is_continuation (a) || is_foreign (a);
4692 || is_continuation (car (SCHEME_V->args)) || is_foreign (car (SCHEME_V->args))); 4595 break;
4693 4596
4694 case OP_PAIRP: /* pair? */ 4597 case OP_PAIRP: /* pair? */ r = is_pair (a) ; break;
4695 s_retbool (is_pair (car (SCHEME_V->args))); 4598 case OP_LISTP: /* list? */ r = list_length (SCHEME_A_ a) >= 0; break;
4696 4599 case OP_ENVP: /* environment? */ r = is_environment (a) ; break;
4697 case OP_LISTP: /* list? */ 4600 case OP_VECTORP: /* vector? */ r = is_vector (a) ; break;
4698 s_retbool (list_length (SCHEME_A_ car (SCHEME_V->args)) >= 0); 4601 case OP_EQ: /* eq? */ r = a == cadr (x) ; break;
4699 4602 case OP_EQV: /* eqv? */ r = eqv (a, cadr (x)) ; break;
4700 case OP_ENVP: /* environment? */
4701 s_retbool (is_environment (car (SCHEME_V->args)));
4702
4703 case OP_VECTORP: /* vector? */
4704 s_retbool (is_vector (car (SCHEME_V->args)));
4705
4706 case OP_EQ: /* eq? */
4707 s_retbool (car (SCHEME_V->args) == cadr (SCHEME_V->args));
4708
4709 case OP_EQV: /* eqv? */
4710 s_retbool (eqv (car (SCHEME_V->args), cadr (SCHEME_V->args)));
4711 } 4603 }
4712 4604
4713 return S_T; 4605 s_retbool (r);
4714} 4606}
4715 4607
4716static pointer 4608static pointer
4717opexe_4 (SCHEME_P_ enum scheme_opcodes op) 4609opexe_4 (SCHEME_P_ enum scheme_opcodes op)
4718{ 4610{
… …
5032 case OP_CURR_ENV: /* current-environment */ 4924 case OP_CURR_ENV: /* current-environment */
5033 s_return (SCHEME_V->envir); 4925 s_return (SCHEME_V->envir);
5034 4926
5035 } 4927 }
5036 4928
5037 return S_T; 4929 abort ();
5038} 4930}
5039 4931
5040static pointer 4932static pointer
5041opexe_5 (SCHEME_P_ enum scheme_opcodes op) 4933opexe_5 (SCHEME_P_ enum scheme_opcodes op)
5042{ 4934{
… …
5381 s_goto (OP_P0LIST); 5273 s_goto (OP_P0LIST);
5382 } 5274 }
5383 } 5275 }
5384 } 5276 }
5385 5277
5386 return S_T; 5278 abort ();
5387} 5279}
5388 5280
5389static pointer 5281static pointer
5390opexe_6 (SCHEME_P_ enum scheme_opcodes op) 5282opexe_6 (SCHEME_P_ enum scheme_opcodes op)
5391{ 5283{
… …
5442 5334
5443 case OP_MACROP: /* macro? */ 5335 case OP_MACROP: /* macro? */
5444 s_retbool (is_macro (car (SCHEME_V->args))); 5336 s_retbool (is_macro (car (SCHEME_V->args)));
5445 } 5337 }
5446 5338
5447 return S_T; /* NOTREACHED */ 5339 abort ();
5448} 5340}
5449 5341
5450typedef pointer (*dispatch_func) (SCHEME_P_ enum scheme_opcodes); 5342typedef pointer (*dispatch_func) (SCHEME_P_ enum scheme_opcodes);
5451 5343
5452typedef int (*test_predicate) (pointer); 5344typedef int (*test_predicate) (pointer);

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines