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.14 by root, Thu Nov 26 08:56:32 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 */
4585 s_retbool (is_false (car (SCHEME_V->args))); 4563 r = is_false (a); break;
4586 4564
4587 case OP_BOOLP: /* boolean? */ 4565 case OP_BOOLP: /* boolean? */
4588 s_retbool (car (SCHEME_V->args) == S_F || car (SCHEME_V->args) == S_T); 4566 r = a == S_F || a == S_T; break;
4589 4567
4590 case OP_EOFOBJP: /* boolean? */ 4568 case OP_EOFOBJP: /* eof-object? */
4591 s_retbool (car (SCHEME_V->args) == S_EOF); 4569 r = a == S_EOF; break;
4592 4570
4593 case OP_NULLP: /* null? */ 4571 case OP_NULLP: /* null? */
4594 s_retbool (car (SCHEME_V->args) == NIL); 4572 r = a == NIL; break;
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 4573
4638 case OP_SYMBOLP: /* symbol? */ 4574 case OP_SYMBOLP: /* symbol? */
4639 s_retbool (is_symbol (car (SCHEME_V->args))); 4575 r = is_symbol (a); break;
4640 4576
4641 case OP_NUMBERP: /* number? */ 4577 case OP_NUMBERP: /* number? */
4642 s_retbool (is_number (car (SCHEME_V->args))); 4578 r = is_number (a); break;
4643 4579
4644 case OP_STRINGP: /* string? */ 4580 case OP_STRINGP: /* string? */
4645 s_retbool (is_string (car (SCHEME_V->args))); 4581 r = is_string (a); break;
4646 4582
4647 case OP_INTEGERP: /* integer? */ 4583 case OP_INTEGERP: /* integer? */
4648 s_retbool (is_integer (car (SCHEME_V->args))); 4584 r = is_integer (a); break;
4649 4585
4650 case OP_REALP: /* real? */ 4586 case OP_REALP: /* real? */
4651 s_retbool (is_number (car (SCHEME_V->args))); /* All numbers are real */ 4587 r = is_number (a); break; /* all numbers are real */
4652 4588
4653 case OP_CHARP: /* char? */ 4589 case OP_CHARP: /* char? */
4654 s_retbool (is_character (car (SCHEME_V->args))); 4590 r = is_character (a); break;
4591
4655#if USE_CHAR_CLASSIFIERS 4592#if USE_CHAR_CLASSIFIERS
4656
4657 case OP_CHARAP: /* char-alphabetic? */ 4593 case OP_CHARAP: /* char-alphabetic? */
4658 s_retbool (Cisalpha (ivalue (car (SCHEME_V->args)))); 4594 r = Cisalpha (ivalue (a)); break;
4659 4595
4660 case OP_CHARNP: /* char-numeric? */ 4596 case OP_CHARNP: /* char-numeric? */
4661 s_retbool (Cisdigit (ivalue (car (SCHEME_V->args)))); 4597 r = Cisdigit (ivalue (a)); break;
4662 4598
4663 case OP_CHARWP: /* char-whitespace? */ 4599 case OP_CHARWP: /* char-whitespace? */
4664 s_retbool (Cisspace (ivalue (car (SCHEME_V->args)))); 4600 r = Cisspace (ivalue (a)); break;
4665 4601
4666 case OP_CHARUP: /* char-upper-case? */ 4602 case OP_CHARUP: /* char-upper-case? */
4667 s_retbool (Cisupper (ivalue (car (SCHEME_V->args)))); 4603 r = Cisupper (ivalue (a)); break;
4668 4604
4669 case OP_CHARLP: /* char-lower-case? */ 4605 case OP_CHARLP: /* char-lower-case? */
4670 s_retbool (Cislower (ivalue (car (SCHEME_V->args)))); 4606 r = Cislower (ivalue (a)); break;
4671#endif 4607#endif
4608
4672#if USE_PORTS 4609#if USE_PORTS
4673
4674 case OP_PORTP: /* port? */ 4610 case OP_PORTP: /* port? */
4675 s_retbool (is_port (car (SCHEME_V->args))); 4611 r = is_port (a); break;
4676 4612
4677 case OP_INPORTP: /* input-port? */ 4613 case OP_INPORTP: /* input-port? */
4678 s_retbool (is_inport (car (SCHEME_V->args))); 4614 r = is_inport (a); break;
4679 4615
4680 case OP_OUTPORTP: /* output-port? */ 4616 case OP_OUTPORTP: /* output-port? */
4681 s_retbool (is_outport (car (SCHEME_V->args))); 4617 r = is_outport (a); break;
4682#endif 4618#endif
4683 4619
4684 case OP_PROCP: /* procedure? */ 4620 case OP_PROCP: /* procedure? */
4685 4621
4686 /*-- 4622 /*--
4687 * continuation should be procedure by the example 4623 * continuation should be procedure by the example
4688 * (call-with-current-continuation procedure?) ==> #t 4624 * (call-with-current-continuation procedure?) ==> #t
4689 * in R^3 report sec. 6.9 4625 * in R^3 report sec. 6.9
4690 */ 4626 */
4691 s_retbool (is_proc (car (SCHEME_V->args)) || is_closure (car (SCHEME_V->args)) 4627 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))); 4628 break;
4693 4629
4694 case OP_PAIRP: /* pair? */ 4630 case OP_PAIRP: /* pair? */
4695 s_retbool (is_pair (car (SCHEME_V->args))); 4631 r = is_pair (a); break;
4696 4632
4697 case OP_LISTP: /* list? */ 4633 case OP_LISTP: /* list? */
4698 s_retbool (list_length (SCHEME_A_ car (SCHEME_V->args)) >= 0); 4634 r = list_length (SCHEME_A_ a) >= 0; break;
4699 4635
4700 case OP_ENVP: /* environment? */ 4636 case OP_ENVP: /* environment? */
4701 s_retbool (is_environment (car (SCHEME_V->args))); 4637 r = is_environment (a); break;
4702 4638
4703 case OP_VECTORP: /* vector? */ 4639 case OP_VECTORP: /* vector? */
4704 s_retbool (is_vector (car (SCHEME_V->args))); 4640 r = is_vector (a); break;
4705 4641
4706 case OP_EQ: /* eq? */ 4642 case OP_EQ: /* eq? */
4707 s_retbool (car (SCHEME_V->args) == cadr (SCHEME_V->args)); 4643 r = a == cadr (x); break;
4708 4644
4709 case OP_EQV: /* eqv? */ 4645 case OP_EQV: /* eqv? */
4710 s_retbool (eqv (car (SCHEME_V->args), cadr (SCHEME_V->args))); 4646 r = eqv (a, cadr (x)); break;
4711 } 4647 }
4712 4648
4713 return S_T; 4649 s_retbool (r);
4714} 4650}
4715 4651
4716static pointer 4652static pointer
4717opexe_4 (SCHEME_P_ enum scheme_opcodes op) 4653opexe_4 (SCHEME_P_ enum scheme_opcodes op)
4718{ 4654{
… …
5032 case OP_CURR_ENV: /* current-environment */ 4968 case OP_CURR_ENV: /* current-environment */
5033 s_return (SCHEME_V->envir); 4969 s_return (SCHEME_V->envir);
5034 4970
5035 } 4971 }
5036 4972
5037 return S_T; 4973 abort ();
5038} 4974}
5039 4975
5040static pointer 4976static pointer
5041opexe_5 (SCHEME_P_ enum scheme_opcodes op) 4977opexe_5 (SCHEME_P_ enum scheme_opcodes op)
5042{ 4978{
… …
5381 s_goto (OP_P0LIST); 5317 s_goto (OP_P0LIST);
5382 } 5318 }
5383 } 5319 }
5384 } 5320 }
5385 5321
5386 return S_T; 5322 abort ();
5387} 5323}
5388 5324
5389static pointer 5325static pointer
5390opexe_6 (SCHEME_P_ enum scheme_opcodes op) 5326opexe_6 (SCHEME_P_ enum scheme_opcodes op)
5391{ 5327{
… …
5442 5378
5443 case OP_MACROP: /* macro? */ 5379 case OP_MACROP: /* macro? */
5444 s_retbool (is_macro (car (SCHEME_V->args))); 5380 s_retbool (is_macro (car (SCHEME_V->args)));
5445 } 5381 }
5446 5382
5447 return S_T; /* NOTREACHED */ 5383 abort ();
5448} 5384}
5449 5385
5450typedef pointer (*dispatch_func) (SCHEME_P_ enum scheme_opcodes); 5386typedef pointer (*dispatch_func) (SCHEME_P_ enum scheme_opcodes);
5451 5387
5452typedef int (*test_predicate) (pointer); 5388typedef int (*test_predicate) (pointer);

Diff Legend

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