?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel - adjust sdhc timeouts, cleanup
[dragonfly.git] / usr.bin / dc / bcode.c
blob629e389b1f13e4d8cbeeae19fd6751e3e007185c
1 /*
2 * $OpenBSD: bcode.c,v 1.45 2012/11/07 11:06:14 otto Exp $
3 * $DragonFly: src/usr.bin/dc/bcode.c,v 1.3 2008/09/14 21:08:29 swildner Exp $
4 */
5
6 /*
7 * Copyright (c) 2003, Otto Moerbeek <otto@drijf.net>
8 *
9 * Permission to use, copy, modify, and distribute this software for any
10 * purpose with or without fee is hereby granted, provided that the above
11 * copyright notice and this permission notice appear in all copies.
12 *
13 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
14 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
15 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
16 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
17 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
19 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20 */
21
22 #include <openssl/ssl.h>
23 #include <err.h>
24 #include <limits.h>
25 #include <signal.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29
30 #include "extern.h"
31
32 /* #define DEBUGGING */
33
34 #define MAX_ARRAY_INDEX 2048
35 #define READSTACK_SIZE 8
36
37 #define NO_ELSE -2 /* -1 is EOF */
38 #define REG_ARRAY_SIZE_SMALL (UCHAR_MAX + 1)
39 #define REG_ARRAY_SIZE_BIG (UCHAR_MAX + 1 + USHRT_MAX + 1)
40
41 struct bmachine {
42 struct stack stack;
43 u_int scale;
44 u_int obase;
45 u_int ibase;
46 size_t readsp;
47 bool extended_regs;
48 size_t reg_array_size;
49 struct stack *reg;
50 volatile sig_atomic_t interrupted;
51 struct source *readstack;
52 size_t readstack_sz;
53 };
54
55 static struct bmachine bmachine;
56 static void sighandler(int);
57
58 static __inline int readch(void);
59 static __inline void unreadch(void);
60 static __inline char *readline(void);
61 static __inline void src_free(void);
62
63 static __inline u_int max(u_int, u_int);
64 static u_long get_ulong(struct number *);
65
66 static __inline void push_number(struct number *);
67 static __inline void push_string(char *);
68 static __inline void push(struct value *);
69 static __inline struct value *tos(void);
70 static __inline struct number *pop_number(void);
71 static __inline char *pop_string(void);
72 static __inline void clear_stack(void);
73 static __inline void print_tos(void);
74 static void pop_print(void);
75 static void pop_printn(void);
76 static __inline void print_stack(void);
77 static __inline void dup(void);
78 static void swap(void);
79 static void drop(void);
80
81 static void get_scale(void);
82 static void set_scale(void);
83 static void get_obase(void);
84 static void set_obase(void);
85 static void get_ibase(void);
86 static void set_ibase(void);
87 static void stackdepth(void);
88 static void push_scale(void);
89 static u_int count_digits(const struct number *);
90 static void num_digits(void);
91 static void to_ascii(void);
92 static void push_line(void);
93 static void comment(void);
94 static void bexec(char *);
95 static void badd(void);
96 static void bsub(void);
97 static void bmul(void);
98 static void bdiv(void);
99 static void bmod(void);
100 static void bdivmod(void);
101 static void bexp(void);
102 static bool bsqrt_stop(const BIGNUM *, const BIGNUM *, u_int *);
103 static void bsqrt(void);
104 static void not(void);
105 static void equal_numbers(void);
106 static void less_numbers(void);
107 static void lesseq_numbers(void);
108 static void equal(void);
109 static void not_equal(void);
110 static void less(void);
111 static void not_less(void);
112 static void greater(void);
113 static void not_greater(void);
114 static void not_compare(void);
115 static bool compare_numbers(enum bcode_compare, struct number *,
116 struct number *);
117 static void compare(enum bcode_compare);
118 static int readreg(void);
119 static void load(void);
120 static void store(void);
121 static void load_stack(void);
122 static void store_stack(void);
123 static void load_array(void);
124 static void store_array(void);
125 static void nop(void);
126 static void quit(void);
127 static void quitN(void);
128 static void skipN(void);
129 static void skip_until_mark(void);
130 static void parse_number(void);
131 static void unknown(void);
132 static void eval_string(char *);
133 static void eval_line(void);
134 static void eval_tos(void);
135
136
137 typedef void (*opcode_function)(void);
138
139 struct jump_entry {
140 u_char ch;
141 opcode_function f;
142 };
143
144 static opcode_function jump_table[UCHAR_MAX];
145
146 static const struct jump_entry jump_table_data[] = {
147 { ' ', nop },
148 { '!', not_compare },
149 { '#', comment },
150 { '%', bmod },
151 { '(', less_numbers },
152 { '*', bmul },
153 { '+', badd },
154 { '-', bsub },
155 { '.', parse_number },
156 { '/', bdiv },
157 { '0', parse_number },
158 { '1', parse_number },
159 { '2', parse_number },
160 { '3', parse_number },
161 { '4', parse_number },
162 { '5', parse_number },
163 { '6', parse_number },
164 { '7', parse_number },
165 { '8', parse_number },
166 { '9', parse_number },
167 { ':', store_array },
168 { ';', load_array },
169 { '<', less },
170 { '=', equal },
171 { '>', greater },
172 { '?', eval_line },
173 { 'A', parse_number },
174 { 'B', parse_number },
175 { 'C', parse_number },
176 { 'D', parse_number },
177 { 'E', parse_number },
178 { 'F', parse_number },
179 { 'G', equal_numbers },
180 { 'I', get_ibase },
181 { 'J', skipN },
182 { 'K', get_scale },
183 { 'L', load_stack },
184 { 'M', nop },
185 { 'N', not },
186 { 'O', get_obase },
187 { 'P', pop_print },
188 { 'Q', quitN },
189 { 'R', drop },
190 { 'S', store_stack },
191 { 'X', push_scale },
192 { 'Z', num_digits },
193 { '[', push_line },
194 { '\f', nop },
195 { '\n', nop },
196 { '\r', nop },
197 { '\t', nop },
198 { '^', bexp },
199 { '_', parse_number },
200 { 'a', to_ascii },
201 { 'c', clear_stack },
202 { 'd', dup },
203 { 'f', print_stack },
204 { 'i', set_ibase },
205 { 'k', set_scale },
206 { 'l', load },
207 { 'n', pop_printn },
208 { 'o', set_obase },
209 { 'p', print_tos },
210 { 'q', quit },
211 { 'r', swap },
212 { 's', store },
213 { 'v', bsqrt },
214 { 'x', eval_tos },
215 { 'z', stackdepth },
216 { '{', lesseq_numbers },
217 { '~', bdivmod }
218 };
219
220 #define JUMP_TABLE_DATA_SIZE \
221 (sizeof(jump_table_data)/sizeof(jump_table_data[0]))
222
223 static void
224 sighandler(int ignored __unused)
225 {
226 bmachine.interrupted = true;
227 }
228
229 void
230 init_bmachine(bool extended_registers)
231 {
232 int i;
233
234 bmachine.extended_regs = extended_registers;
235 bmachine.reg_array_size = bmachine.extended_regs ?
236 REG_ARRAY_SIZE_BIG : REG_ARRAY_SIZE_SMALL;
237
238 bmachine.reg = calloc(bmachine.reg_array_size,
239 sizeof(bmachine.reg[0]));
240 if (bmachine.reg == NULL)
241 err(1, NULL);
242
243 for (i = 0; i < UCHAR_MAX; i++)
244 jump_table[i] = unknown;
245 for (i = 0; i < JUMP_TABLE_DATA_SIZE; i++)
246 jump_table[jump_table_data[i].ch] = jump_table_data[i].f;
247
248 stack_init(&bmachine.stack);
249
250 for (i = 0; i < bmachine.reg_array_size; i++)
251 stack_init(&bmachine.reg[i]);
252
253 bmachine.readstack_sz = READSTACK_SIZE;
254 bmachine.readstack = calloc(sizeof(struct source),
255 bmachine.readstack_sz);
256 if (bmachine.readstack == NULL)
257 err(1, NULL);
258 bmachine.obase = bmachine.ibase = 10;
259 signal(SIGINT, sighandler);
260 }
261
262 u_int
263 bmachine_scale(void)
264 {
265 return bmachine.scale;
266 }
267
268 /* Reset the things needed before processing a (new) file */
269 void
270 reset_bmachine(struct source *src)
271 {
272 bmachine.readsp = 0;
273 bmachine.readstack[0] = *src;
274 }
275
276 static __inline int
277 readch(void)
278 {
279 struct source *src = &bmachine.readstack[bmachine.readsp];
280
281 return src->vtable->readchar(src);
282 }
283
284 static __inline void
285 unreadch(void)
286 {
287 struct source *src = &bmachine.readstack[bmachine.readsp];
288
289 src->vtable->unreadchar(src);
290 }
291
292 static __inline char *
293 readline(void)
294 {
295 struct source *src = &bmachine.readstack[bmachine.readsp];
296
297 return src->vtable->readline(src);
298 }
299
300 static __inline void
301 src_free(void)
302 {
303 struct source *src = &bmachine.readstack[bmachine.readsp];
304
305 src->vtable->free(src);
306 }
307
308 #ifdef DEBUGGING
309 void
310 pn(const char *str, const struct number *n)
311 {
312 char *p = BN_bn2dec(n->number);
313 if (p == NULL)
314 err(1, "BN_bn2dec failed");
315 fputs(str, stderr);
316 fprintf(stderr, " %s (%u)\n" , p, n->scale);
317 OPENSSL_free(p);
318 }
319
320 void
321 pbn(const char *str, const BIGNUM *n)
322 {
323 char *p = BN_bn2dec(n);
324 if (p == NULL)
325 err(1, "BN_bn2dec failed");
326 fputs(str, stderr);
327 fprintf(stderr, " %s\n", p);
328 OPENSSL_free(p);
329 }
330
331 #endif
332
333 static __inline u_int
334 max(u_int a, u_int b)
335 {
336 return a > b ? a : b;
337 }
338
339 static unsigned long factors[] = {
340 0, 10, 100, 1000, 10000, 100000, 1000000, 10000000,
341 100000000, 1000000000
342 };
343
344 void
345 scale_number(BIGNUM *n, int s)
346 {
347 int abs_scale;
348
349 if (s == 0)
350 return;
351
352 abs_scale = s > 0 ? s : -s;
353
354 if (abs_scale < sizeof(factors)/sizeof(factors[0])) {
355 if (s > 0)
356 bn_check(BN_mul_word(n, factors[abs_scale]));
357 else
358 BN_div_word(n, factors[abs_scale]);
359 } else {
360 BIGNUM *a, *p;
361 BN_CTX *ctx;
362
363 a = BN_new();
364 bn_checkp(a);
365 p = BN_new();
366 bn_checkp(p);
367 ctx = BN_CTX_new();
368 bn_checkp(ctx);
369
370 bn_check(BN_set_word(a, 10));
371 bn_check(BN_set_word(p, abs_scale));
372 bn_check(BN_exp(a, a, p, ctx));
373 if (s > 0)
374 bn_check(BN_mul(n, n, a, ctx));
375 else
376 bn_check(BN_div(n, NULL, n, a, ctx));
377 BN_CTX_free(ctx);
378 BN_free(a);
379 BN_free(p);
380 }
381 }
382
383 void
384 split_number(const struct number *n, BIGNUM *i, BIGNUM *f)
385 {
386 u_long rem;
387
388 bn_checkp(BN_copy(i, n->number));
389
390 if (n->scale == 0 && f != NULL)
391 bn_check(BN_zero(f));
392 else if (n->scale < sizeof(factors)/sizeof(factors[0])) {
393 rem = BN_div_word(i, factors[n->scale]);
394 if (f != NULL)
395 bn_check(BN_set_word(f, rem));
396 } else {
397 BIGNUM *a, *p;
398 BN_CTX *ctx;
399
400 a = BN_new();
401 bn_checkp(a);
402 p = BN_new();
403 bn_checkp(p);
404 ctx = BN_CTX_new();
405 bn_checkp(ctx);
406
407 bn_check(BN_set_word(a, 10));
408 bn_check(BN_set_word(p, n->scale));
409 bn_check(BN_exp(a, a, p, ctx));
410 bn_check(BN_div(i, f, n->number, a, ctx));
411 BN_CTX_free(ctx);
412 BN_free(a);
413 BN_free(p);
414 }
415 }
416
417 __inline void
418 normalize(struct number *n, u_int s)
419 {
420 scale_number(n->number, s - n->scale);
421 n->scale = s;
422 }
423
424 static u_long
425 get_ulong(struct number *n)
426 {
427 normalize(n, 0);
428 return BN_get_word(n->number);
429 }
430
431 void
432 negate(struct number *n)
433 {
434 BN_set_negative(n->number, !BN_is_negative(n->number));
435 }
436
437 static __inline void
438 push_number(struct number *n)
439 {
440 stack_pushnumber(&bmachine.stack, n);
441 }
442
443 static __inline void
444 push_string(char *string)
445 {
446 stack_pushstring(&bmachine.stack, string);
447 }
448
449 static __inline void
450 push(struct value *v)
451 {
452 stack_push(&bmachine.stack, v);
453 }
454
455 static __inline struct value *
456 tos(void)
457 {
458 return stack_tos(&bmachine.stack);
459 }
460
461 static __inline struct value *
462 pop(void)
463 {
464 return stack_pop(&bmachine.stack);
465 }
466
467 static __inline struct number *
468 pop_number(void)
469 {
470 return stack_popnumber(&bmachine.stack);
471 }
472
473 static __inline char *
474 pop_string(void)
475 {
476 return stack_popstring(&bmachine.stack);
477 }
478
479 static __inline void
480 clear_stack(void)
481 {
482 stack_clear(&bmachine.stack);
483 }
484
485 static __inline void
486 print_stack(void)
487 {
488 stack_print(stdout, &bmachine.stack, "", bmachine.obase);
489 }
490
491 static __inline void
492 print_tos(void)
493 {
494 struct value *value = tos();
495 if (value != NULL) {
496 print_value(stdout, value, "", bmachine.obase);
497 putchar('\n');
498 }
499 else
500 warnx("stack empty");
501 }
502
503 static void
504 pop_print(void)
505 {
506 struct value *value = pop();
507
508 if (value != NULL) {
509 switch (value->type) {
510 case BCODE_NONE:
511 break;
512 case BCODE_NUMBER:
513 normalize(value->u.num, 0);
514 print_ascii(stdout, value->u.num);
515 fflush(stdout);
516 break;
517 case BCODE_STRING:
518 fputs(value->u.string, stdout);
519 fflush(stdout);
520 break;
521 }
522 stack_free_value(value);
523 }
524 }
525
526 static void
527 pop_printn(void)
528 {
529 struct value *value = pop();
530
531 if (value != NULL) {
532 print_value(stdout, value, "", bmachine.obase);
533 fflush(stdout);
534 stack_free_value(value);
535 }
536 }
537
538 static __inline void
539 dup(void)
540 {
541 stack_dup(&bmachine.stack);
542 }
543
544 static void
545 swap(void)
546 {
547 stack_swap(&bmachine.stack);
548 }
549
550 static void
551 drop(void)
552 {
553 struct value *v = pop();
554 if (v != NULL)
555 stack_free_value(v);
556 }
557
558 static void
559 get_scale(void)
560 {
561 struct number *n;
562
563 n = new_number();
564 bn_check(BN_set_word(n->number, bmachine.scale));
565 push_number(n);
566 }
567
568 static void
569 set_scale(void)
570 {
571 struct number *n;
572 u_long scale;
573
574 n = pop_number();
575 if (n != NULL) {
576 if (BN_is_negative(n->number))
577 warnx("scale must be a nonnegative number");
578 else {
579 scale = get_ulong(n);
580 if (scale != BN_MASK2 && scale <= UINT_MAX)
581 bmachine.scale = (u_int)scale;
582 else
583 warnx("scale too large");
584 }
585 free_number(n);
586 }
587 }
588
589 static void
590 get_obase(void)
591 {
592 struct number *n;
593
594 n = new_number();
595 bn_check(BN_set_word(n->number, bmachine.obase));
596 push_number(n);
597 }
598
599 static void
600 set_obase(void)
601 {
602 struct number *n;
603 u_long base;
604
605 n = pop_number();
606 if (n != NULL) {
607 base = get_ulong(n);
608 if (base != BN_MASK2 && base > 1 && base <= UINT_MAX)
609 bmachine.obase = (u_int)base;
610 else
611 warnx("output base must be a number greater than 1");
612 free_number(n);
613 }
614 }
615
616 static void
617 get_ibase(void)
618 {
619 struct number *n;
620
621 n = new_number();
622 bn_check(BN_set_word(n->number, bmachine.ibase));
623 push_number(n);
624 }
625
626 static void
627 set_ibase(void)
628 {
629 struct number *n;
630 u_long base;
631
632 n = pop_number();
633 if (n != NULL) {
634 base = get_ulong(n);
635 if (base != BN_MASK2 && 2 <= base && base <= 16)
636 bmachine.ibase = (u_int)base;
637 else
638 warnx("input base must be a number between 2 and 16 "
639 "(inclusive)");
640 free_number(n);
641 }
642 }
643
644 static void
645 stackdepth(void)
646 {
647 size_t i;
648 struct number *n;
649
650 i = stack_size(&bmachine.stack);
651 n = new_number();
652 bn_check(BN_set_word(n->number, i));
653 push_number(n);
654 }
655
656 static void
657 push_scale(void)
658 {
659 struct value *value;
660 u_int scale = 0;
661 struct number *n;
662
663
664 value = pop();
665 if (value != NULL) {
666 switch (value->type) {
667 case BCODE_NONE:
668 return;
669 case BCODE_NUMBER:
670 scale = value->u.num->scale;
671 break;
672 case BCODE_STRING:
673 break;
674 }
675 stack_free_value(value);
676 n = new_number();
677 bn_check(BN_set_word(n->number, scale));
678 push_number(n);
679 }
680 }
681
682 static u_int
683 count_digits(const struct number *n)
684 {
685 struct number *int_part, *fract_part;
686 u_int i;
687
688 if (BN_is_zero(n->number))
689 return n->scale ? n->scale : 1;
690
691 int_part = new_number();
692 fract_part = new_number();
693 fract_part->scale = n->scale;
694 split_number(n, int_part->number, fract_part->number);
695
696 i = 0;
697 while (!BN_is_zero(int_part->number)) {
698 BN_div_word(int_part->number, 10);
699 i++;
700 }
701 free_number(int_part);
702 free_number(fract_part);
703 return i + n->scale;
704 }
705
706 static void
707 num_digits(void)
708 {
709 struct value *value;
710 size_t digits;
711 struct number *n = NULL;
712
713 value = pop();
714 if (value != NULL) {
715 switch (value->type) {
716 case BCODE_NONE:
717 return;
718 case BCODE_NUMBER:
719 digits = count_digits(value->u.num);
720 n = new_number();
721 bn_check(BN_set_word(n->number, digits));
722 break;
723 case BCODE_STRING:
724 digits = strlen(value->u.string);
725 n = new_number();
726 bn_check(BN_set_word(n->number, digits));
727 break;
728 }
729 stack_free_value(value);
730 push_number(n);
731 }
732 }
733
734 static void
735 to_ascii(void)
736 {
737 char str[2];
738 struct value *value;
739 struct number *n;
740
741 value = pop();
742 if (value != NULL) {
743 str[1] = '\0';
744 switch (value->type) {
745 case BCODE_NONE:
746 return;
747 case BCODE_NUMBER:
748 n = value->u.num;
749 normalize(n, 0);
750 if (BN_num_bits(n->number) > 8)
751 bn_check(BN_mask_bits(n->number, 8));
752 str[0] = BN_get_word(n->number);
753 break;
754 case BCODE_STRING:
755 str[0] = value->u.string[0];
756 break;
757 }
758 stack_free_value(value);
759 push_string(bstrdup(str));
760 }
761 }
762
763 static int
764 readreg(void)
765 {
766 int index, ch1, ch2;
767
768 index = readch();
769 if (index == 0xff && bmachine.extended_regs) {
770 ch1 = readch();
771 ch2 = readch();
772 if (ch1 == EOF || ch2 == EOF) {
773 warnx("unexpected eof");
774 index = -1;
775 } else
776 index = (ch1 << 8) + ch2 + UCHAR_MAX + 1;
777 }
778 if (index < 0 || index >= bmachine.reg_array_size) {
779 warnx("internal error: reg num = %d", index);
780 index = -1;
781 }
782 return index;
783 }
784
785 static void
786 load(void)
787 {
788 int index;
789 struct value *v, copy;
790 struct number *n;
791
792 index = readreg();
793 if (index >= 0) {
794 v = stack_tos(&bmachine.reg[index]);
795 if (v == NULL) {
796 n = new_number();
797 bn_check(BN_zero(n->number));
798 push_number(n);
799 } else
800 push(stack_dup_value(v, &copy));
801 }
802 }
803
804 static void
805 store(void)
806 {
807 int index;
808 struct value *val;
809
810 index = readreg();
811 if (index >= 0) {
812 val = pop();
813 if (val == NULL) {
814 return;
815 }
816 stack_set_tos(&bmachine.reg[index], val);
817 }
818 }
819
820 static void
821 load_stack(void)
822 {
823 int index;
824 struct stack *stack;
825 struct value *value;
826
827 index = readreg();
828 if (index >= 0) {
829 stack = &bmachine.reg[index];
830 value = NULL;
831 if (stack_size(stack) > 0) {
832 value = stack_pop(stack);
833 }
834 if (value != NULL)
835 push(value);
836 else
837 warnx("stack register '%c' (0%o) is empty",
838 index, index);
839 }
840 }
841
842 static void
843 store_stack(void)
844 {
845 int index;
846 struct value *value;
847
848 index = readreg();
849 if (index >= 0) {
850 value = pop();
851 if (value == NULL)
852 return;
853 stack_push(&bmachine.reg[index], value);
854 }
855 }
856
857 static void
858 load_array(void)
859 {
860 int reg;
861 struct number *inumber, *n;
862 u_long index;
863 struct stack *stack;
864 struct value *v, copy;
865
866 reg = readreg();
867 if (reg >= 0) {
868 inumber = pop_number();
869 if (inumber == NULL)
870 return;
871 index = get_ulong(inumber);
872 if (BN_is_negative(inumber->number))
873 warnx("negative index");
874 else if (index == BN_MASK2 || index > MAX_ARRAY_INDEX)
875 warnx("index too big");
876 else {
877 stack = &bmachine.reg[reg];
878 v = frame_retrieve(stack, index);
879 if (v == NULL || v->type == BCODE_NONE ) {
880 n = new_number();
881 bn_check(BN_zero(n->number));
882 push_number(n);
883 }
884 else
885 push(stack_dup_value(v, &copy));
886 }
887 free_number(inumber);
888 }
889 }
890
891 static void
892 store_array(void)
893 {
894 int reg;
895 struct number *inumber;
896 u_long index;
897 struct value *value;
898 struct stack *stack;
899
900 reg = readreg();
901 if (reg >= 0) {
902 inumber = pop_number();
903 if (inumber == NULL)
904 return;
905 value = pop();
906 if (value == NULL) {
907 free_number(inumber);
908 return;
909 }
910 index = get_ulong(inumber);
911 if (BN_is_negative(inumber->number)) {
912 warnx("negative index");
913 stack_free_value(value);
914 } else if (index == BN_MASK2 || index > MAX_ARRAY_INDEX) {
915 warnx("index too big");
916 stack_free_value(value);
917 } else {
918 stack = &bmachine.reg[reg];
919 frame_assign(stack, index, value);
920 }
921 free_number(inumber);
922 }
923 }
924
925 static void
926 push_line(void)
927 {
928 push_string(read_string(&bmachine.readstack[bmachine.readsp]));
929 }
930
931 static void
932 comment(void)
933 {
934 free(readline());
935 }
936
937 static void
938 bexec(char *line)
939 {
940 system(line);
941 free(line);
942 }
943
944 static void
945 badd(void)
946 {
947 struct number *a, *b;
948 struct number *r;
949
950 a = pop_number();
951 if (a == NULL) {
952 return;
953 }
954 b = pop_number();
955 if (b == NULL) {
956 push_number(a);
957 return;
958 }
959
960 r = new_number();
961 r->scale = max(a->scale, b->scale);
962 if (r->scale > a->scale)
963 normalize(a, r->scale);
964 else if (r->scale > b->scale)
965 normalize(b, r->scale);
966 bn_check(BN_add(r->number, a->number, b->number));
967 push_number(r);
968 free_number(a);
969 free_number(b);
970 }
971
972 static void
973 bsub(void)
974 {
975 struct number *a, *b;
976 struct number *r;
977
978 a = pop_number();
979 if (a == NULL) {
980 return;
981 }
982 b = pop_number();
983 if (b == NULL) {
984 push_number(a);
985 return;
986 }
987
988 r = new_number();
989
990 r->scale = max(a->scale, b->scale);
991 if (r->scale > a->scale)
992 normalize(a, r->scale);
993 else if (r->scale > b->scale)
994 normalize(b, r->scale);
995 bn_check(BN_sub(r->number, b->number, a->number));
996 push_number(r);
997 free_number(a);
998 free_number(b);
999 }
1000
1001 void
1002 bmul_number(struct number *r, struct number *a, struct number *b, u_int scale)
1003 {
1004 BN_CTX *ctx;
1005
1006 /* Create copies of the scales, since r might be equal to a or b */
1007 u_int ascale = a->scale;
1008 u_int bscale = b->scale;
1009 u_int rscale = ascale + bscale;
1010
1011 ctx = BN_CTX_new();
1012 bn_checkp(ctx);
1013 bn_check(BN_mul(r->number, a->number, b->number, ctx));
1014 BN_CTX_free(ctx);
1015
1016 r->scale = rscale;
1017 if (rscale > bmachine.scale && rscale > ascale && rscale > bscale)
1018 normalize(r, max(scale, max(ascale, bscale)));
1019 }
1020
1021 static void
1022 bmul(void)
1023 {
1024 struct number *a, *b;
1025 struct number *r;
1026
1027 a = pop_number();
1028 if (a == NULL) {
1029 return;
1030 }
1031 b = pop_number();
1032 if (b == NULL) {
1033 push_number(a);
1034 return;
1035 }
1036
1037 r = new_number();
1038 bmul_number(r, a, b, bmachine.scale);
1039
1040 push_number(r);
1041 free_number(a);
1042 free_number(b);
1043 }
1044
1045 static void
1046 bdiv(void)
1047 {
1048 struct number *a, *b;
1049 struct number *r;
1050 u_int scale;
1051 BN_CTX *ctx;
1052
1053 a = pop_number();
1054 if (a == NULL) {
1055 return;
1056 }
1057 b = pop_number();
1058 if (b == NULL) {
1059 push_number(a);
1060 return;
1061 }
1062
1063 r = new_number();
1064 r->scale = bmachine.scale;
1065 scale = max(a->scale, b->scale);
1066
1067 if (BN_is_zero(a->number))
1068 warnx("divide by zero");
1069 else {
1070 normalize(a, scale);
1071 normalize(b, scale + r->scale);
1072
1073 ctx = BN_CTX_new();
1074 bn_checkp(ctx);
1075 bn_check(BN_div(r->number, NULL, b->number, a->number, ctx));
1076 BN_CTX_free(ctx);
1077 }
1078 push_number(r);
1079 free_number(a);
1080 free_number(b);
1081 }
1082
1083 static void
1084 bmod(void)
1085 {
1086 struct number *a, *b;
1087 struct number *r;
1088 u_int scale;
1089 BN_CTX *ctx;
1090
1091 a = pop_number();
1092 if (a == NULL) {
1093 return;
1094 }
1095 b = pop_number();
1096 if (b == NULL) {
1097 push_number(a);
1098 return;
1099 }
1100
1101 r = new_number();
1102 scale = max(a->scale, b->scale);
1103 r->scale = max(b->scale, a->scale + bmachine.scale);
1104
1105 if (BN_is_zero(a->number))
1106 warnx("remainder by zero");
1107 else {
1108 normalize(a, scale);
1109 normalize(b, scale + bmachine.scale);
1110
1111 ctx = BN_CTX_new();
1112 bn_checkp(ctx);
1113 bn_check(BN_mod(r->number, b->number, a->number, ctx));
1114 BN_CTX_free(ctx);
1115 }
1116 push_number(r);
1117 free_number(a);
1118 free_number(b);
1119 }
1120
1121 static void
1122 bdivmod(void)
1123 {
1124 struct number *a, *b;
1125 struct number *rdiv, *rmod;
1126 u_int scale;
1127 BN_CTX *ctx;
1128
1129 a = pop_number();
1130 if (a == NULL) {
1131 return;
1132 }
1133 b = pop_number();
1134 if (b == NULL) {
1135 push_number(a);
1136 return;
1137 }
1138
1139 rdiv = new_number();
1140 rmod = new_number();
1141 rdiv->scale = bmachine.scale;
1142 rmod->scale = max(b->scale, a->scale + bmachine.scale);
1143 scale = max(a->scale, b->scale);
1144
1145 if (BN_is_zero(a->number))
1146 warnx("divide by zero");
1147 else {
1148 normalize(a, scale);
1149 normalize(b, scale + bmachine.scale);
1150
1151 ctx = BN_CTX_new();
1152 bn_checkp(ctx);
1153 bn_check(BN_div(rdiv->number, rmod->number,
1154 b->number, a->number, ctx));
1155 BN_CTX_free(ctx);
1156 }
1157 push_number(rdiv);
1158 push_number(rmod);
1159 free_number(a);
1160 free_number(b);
1161 }
1162
1163 static void
1164 bexp(void)
1165 {
1166 struct number *a, *p;
1167 struct number *r;
1168 bool neg;
1169 u_int rscale;
1170
1171 p = pop_number();
1172 if (p == NULL) {
1173 return;
1174 }
1175 a = pop_number();
1176 if (a == NULL) {
1177 push_number(p);
1178 return;
1179 }
1180
1181 if (p->scale != 0) {
1182 BIGNUM *i, *f;
1183 i = BN_new();
1184 bn_checkp(i);
1185 f = BN_new();
1186 bn_checkp(f);
1187 split_number(p, i, f);
1188 if (!BN_is_zero(f))
1189 warnx("Runtime warning: non-zero fractional part in exponent");
1190 BN_free(i);
1191 BN_free(f);
1192 }
1193 normalize(p, 0);
1194
1195 neg = false;
1196 if (BN_is_negative(p->number)) {
1197 neg = true;
1198 negate(p);
1199 rscale = bmachine.scale;
1200 } else {
1201 /* Posix bc says min(a.scale * b, max(a.scale, scale) */
1202 u_long b;
1203 u_int m;
1204
1205 b = BN_get_word(p->number);
1206 m = max(a->scale, bmachine.scale);
1207 rscale = a->scale * (u_int)b;
1208 if (rscale > m || (a->scale > 0 && (b == BN_MASK2 ||
1209 b > UINT_MAX)))
1210 rscale = m;
1211 }
1212
1213 if (BN_is_zero(p->number)) {
1214 r = new_number();
1215 bn_check(BN_one(r->number));
1216 normalize(r, rscale);
1217 } else {
1218 u_int ascale, mscale;
1219
1220 ascale = a->scale;
1221 while (!BN_is_bit_set(p->number, 0)) {
1222 ascale *= 2;
1223 bmul_number(a, a, a, ascale);
1224 bn_check(BN_rshift1(p->number, p->number));
1225 }
1226
1227 r = dup_number(a);
1228 bn_check(BN_rshift1(p->number, p->number));
1229
1230 mscale = ascale;
1231 while (!BN_is_zero(p->number)) {
1232 ascale *=2;
1233 bmul_number(a, a, a, ascale);
1234 if (BN_is_bit_set(p->number, 0)) {
1235 mscale += ascale;
1236 bmul_number(r, r, a, mscale);
1237 }
1238 bn_check(BN_rshift1(p->number, p->number));
1239 }
1240
1241 if (neg) {
1242 BN_CTX *ctx;
1243 BIGNUM *one;
1244
1245 one = BN_new();
1246 bn_checkp(one);
1247 bn_check(BN_one(one));
1248 ctx = BN_CTX_new();
1249 bn_checkp(ctx);
1250 scale_number(one, r->scale + rscale);
1251
1252 if (BN_is_zero(r->number))
1253 warnx("divide by zero");
1254 else
1255 bn_check(BN_div(r->number, NULL, one,
1256 r->number, ctx));
1257 BN_free(one);
1258 BN_CTX_free(ctx);
1259 r->scale = rscale;
1260 } else
1261 normalize(r, rscale);
1262 }
1263 push_number(r);
1264 free_number(a);
1265 free_number(p);
1266 }
1267
1268 static bool
1269 bsqrt_stop(const BIGNUM *x, const BIGNUM *y, u_int *onecount)
1270 {
1271 BIGNUM *r;
1272 bool ret;
1273
1274 r = BN_new();
1275 bn_checkp(r);
1276 bn_check(BN_sub(r, x, y));
1277 if (BN_is_one(r))
1278 (*onecount)++;
1279 ret = BN_is_zero(r);
1280 BN_free(r);
1281 return ret || *onecount > 1;
1282 }
1283
1284 static void
1285 bsqrt(void)
1286 {
1287 struct number *n;
1288 struct number *r;
1289 BIGNUM *x, *y;
1290 u_int scale, onecount;
1291 BN_CTX *ctx;
1292
1293 onecount = 0;
1294 n = pop_number();
1295 if (n == NULL) {
1296 return;
1297 }
1298 if (BN_is_zero(n->number)) {
1299 r = new_number();
1300 push_number(r);
1301 } else if (BN_is_negative(n->number))
1302 warnx("square root of negative number");
1303 else {
1304 scale = max(bmachine.scale, n->scale);
1305 normalize(n, 2*scale);
1306 x = BN_dup(n->number);
1307 bn_checkp(x);
1308 bn_check(BN_rshift(x, x, BN_num_bits(x)/2));
1309 y = BN_new();
1310 bn_checkp(y);
1311 ctx = BN_CTX_new();
1312 bn_checkp(ctx);
1313 for (;;) {
1314 bn_checkp(BN_copy(y, x));
1315 bn_check(BN_div(x, NULL, n->number, x, ctx));
1316 bn_check(BN_add(x, x, y));
1317 bn_check(BN_rshift1(x, x));
1318 if (bsqrt_stop(x, y, &onecount))
1319 break;
1320 }
1321 r = bmalloc(sizeof(*r));
1322 r->scale = scale;
1323 r->number = y;
1324 BN_free(x);
1325 BN_CTX_free(ctx);
1326 push_number(r);
1327 }
1328
1329 free_number(n);
1330 }
1331
1332 static void
1333 not(void)
1334 {
1335 struct number *a;
1336
1337 a = pop_number();
1338 if (a == NULL) {
1339 return;
1340 }
1341 a->scale = 0;
1342 bn_check(BN_set_word(a->number, BN_get_word(a->number) ? 0 : 1));
1343 push_number(a);
1344 }
1345
1346 static void
1347 equal(void)
1348 {
1349 compare(BCODE_EQUAL);
1350 }
1351
1352 static void
1353 equal_numbers(void)
1354 {
1355 struct number *a, *b, *r;
1356
1357 a = pop_number();
1358 if (a == NULL) {
1359 return;
1360 }
1361 b = pop_number();
1362 if (b == NULL) {
1363 push_number(a);
1364 return;
1365 }
1366 r = new_number();
1367 bn_check(BN_set_word(r->number,
1368 compare_numbers(BCODE_EQUAL, a, b) ? 1 : 0));
1369 push_number(r);
1370 }
1371
1372 static void
1373 less_numbers(void)
1374 {
1375 struct number *a, *b, *r;
1376
1377 a = pop_number();
1378 if (a == NULL) {
1379 return;
1380 }
1381 b = pop_number();
1382 if (b == NULL) {
1383 push_number(a);
1384 return;
1385 }
1386 r = new_number();
1387 bn_check(BN_set_word(r->number,
1388 compare_numbers(BCODE_LESS, a, b) ? 1 : 0));
1389 push_number(r);
1390 }
1391
1392 static void
1393 lesseq_numbers(void)
1394 {
1395 struct number *a, *b, *r;
1396
1397 a = pop_number();
1398 if (a == NULL) {
1399 return;
1400 }
1401 b = pop_number();
1402 if (b == NULL) {
1403 push_number(a);
1404 return;
1405 }
1406 r = new_number();
1407 bn_check(BN_set_word(r->number,
1408 compare_numbers(BCODE_NOT_GREATER, a, b) ? 1 : 0));
1409 push_number(r);
1410 }
1411
1412 static void
1413 not_equal(void)
1414 {
1415 compare(BCODE_NOT_EQUAL);
1416 }
1417
1418 static void
1419 less(void)
1420 {
1421 compare(BCODE_LESS);
1422 }
1423
1424 static void
1425 not_compare(void)
1426 {
1427 switch (readch()) {
1428 case '<':
1429 not_less();
1430 break;
1431 case '>':
1432 not_greater();
1433 break;
1434 case '=':
1435 not_equal();
1436 break;
1437 default:
1438 unreadch();
1439 bexec(readline());
1440 break;
1441 }
1442 }
1443
1444 static void
1445 not_less(void)
1446 {
1447 compare(BCODE_NOT_LESS);
1448 }
1449
1450 static void
1451 greater(void)
1452 {
1453 compare(BCODE_GREATER);
1454 }
1455
1456 static void
1457 not_greater(void)
1458 {
1459 compare(BCODE_NOT_GREATER);
1460 }
1461
1462 static bool
1463 compare_numbers(enum bcode_compare type, struct number *a, struct number *b)
1464 {
1465 u_int scale;
1466 int cmp;
1467
1468 scale = max(a->scale, b->scale);
1469
1470 if (scale > a->scale)
1471 normalize(a, scale);
1472 else if (scale > b->scale)
1473 normalize(b, scale);
1474
1475 cmp = BN_cmp(a->number, b->number);
1476
1477 free_number(a);
1478 free_number(b);
1479
1480 switch (type) {
1481 case BCODE_EQUAL:
1482 return cmp == 0;
1483 case BCODE_NOT_EQUAL:
1484 return cmp != 0;
1485 case BCODE_LESS:
1486 return cmp < 0;
1487 case BCODE_NOT_LESS:
1488 return cmp >= 0;
1489 case BCODE_GREATER:
1490 return cmp > 0;
1491 case BCODE_NOT_GREATER:
1492 return cmp <= 0;
1493 }
1494 return false;
1495 }
1496
1497 static void
1498 compare(enum bcode_compare type)
1499 {
1500 int index, elseindex;
1501 struct number *a, *b;
1502 bool ok;
1503 struct value *v;
1504
1505 elseindex = NO_ELSE;
1506 index = readreg();
1507 if (readch() == 'e')
1508 elseindex = readreg();
1509 else
1510 unreadch();
1511
1512 a = pop_number();
1513 if (a == NULL)
1514 return;
1515 b = pop_number();
1516 if (b == NULL) {
1517 push_number(a);
1518 return;
1519 }
1520
1521 ok = compare_numbers(type, a, b);
1522
1523 if (!ok && elseindex != NO_ELSE)
1524 index = elseindex;
1525
1526 if (index >= 0 && (ok || (!ok && elseindex != NO_ELSE))) {
1527 v = stack_tos(&bmachine.reg[index]);
1528 if (v == NULL)
1529 warnx("register '%c' (0%o) is empty", index, index);
1530 else {
1531 switch(v->type) {
1532 case BCODE_NONE:
1533 warnx("register '%c' (0%o) is empty",
1534 index, index);
1535 break;
1536 case BCODE_NUMBER:
1537 warn("eval called with non-string argument");
1538 break;
1539 case BCODE_STRING:
1540 eval_string(bstrdup(v->u.string));
1541 break;
1542 }
1543 }
1544 }
1545 }
1546
1547
1548 static void
1549 nop(void)
1550 {
1551 }
1552
1553 static void
1554 quit(void)
1555 {
1556 if (bmachine.readsp < 2)
1557 exit(0);
1558 src_free();
1559 bmachine.readsp--;
1560 src_free();
1561 bmachine.readsp--;
1562 }
1563
1564 static void
1565 quitN(void)
1566 {
1567 struct number *n;
1568 u_long i;
1569
1570 n = pop_number();
1571 if (n == NULL)
1572 return;
1573 i = get_ulong(n);
1574 free_number(n);
1575 if (i == BN_MASK2 || i == 0)
1576 warnx("Q command requires a number >= 1");
1577 else if (bmachine.readsp < i)
1578 warnx("Q command argument exceeded string execution depth");
1579 else {
1580 while (i-- > 0) {
1581 src_free();
1582 bmachine.readsp--;
1583 }
1584 }
1585 }
1586
1587 static void
1588 skipN(void)
1589 {
1590 struct number *n;
1591 u_long i;
1592
1593 n = pop_number();
1594 if (n == NULL)
1595 return;
1596 i = get_ulong(n);
1597 if (i == BN_MASK2)
1598 warnx("J command requires a number >= 0");
1599 else if (i > 0 && bmachine.readsp < i)
1600 warnx("J command argument exceeded string execution depth");
1601 else {
1602 while (i-- > 0) {
1603 src_free();
1604 bmachine.readsp--;
1605 }
1606 skip_until_mark();
1607 }
1608 }
1609
1610 static void
1611 skip_until_mark(void)
1612 {
1613 int ch;
1614
1615 for (;;) {
1616 ch = readch();
1617 switch (ch) {
1618 case 'M':
1619 return;
1620 case EOF:
1621 errx(1, "mark not found");
1622 return;
1623 case 'l':
1624 case 'L':
1625 case 's':
1626 case 'S':
1627 case ':':
1628 case ';':
1629 case '<':
1630 case '>':
1631 case '=':
1632 readreg();
1633 if (readch() == 'e')
1634 readreg();
1635 else
1636 unreadch();
1637 break;
1638 case '[':
1639 free(read_string(&bmachine.readstack[bmachine.readsp]));
1640 break;
1641 case '!':
1642 switch (ch = readch()) {
1643 case '<':
1644 case '>':
1645 case '=':
1646 readreg();
1647 if (readch() == 'e')
1648 readreg();
1649 else
1650 unreadch();
1651 break;
1652 default:
1653 free(readline());
1654 break;
1655 }
1656 break;
1657 default:
1658 break;
1659 }
1660 }
1661 }
1662
1663 static void
1664 parse_number(void)
1665 {
1666 unreadch();
1667 push_number(readnumber(&bmachine.readstack[bmachine.readsp],
1668 bmachine.ibase));
1669 }
1670
1671 static void
1672 unknown(void)
1673 {
1674 int ch = bmachine.readstack[bmachine.readsp].lastchar;
1675 warnx("%c (0%o) is unimplemented", ch, ch);
1676 }
1677
1678 static void
1679 eval_string(char *p)
1680 {
1681 int ch;
1682
1683 if (bmachine.readsp > 0) {
1684 /* Check for tail call. Do not recurse in that case. */
1685 ch = readch();
1686 if (ch == EOF) {
1687 src_free();
1688 src_setstring(&bmachine.readstack[bmachine.readsp], p);
1689 return;
1690 } else
1691 unreadch();
1692 }
1693 if (bmachine.readsp == bmachine.readstack_sz - 1) {
1694 size_t newsz = bmachine.readstack_sz * 2;
1695 struct source *stack;
1696 stack = realloc(bmachine.readstack, newsz *
1697 sizeof(struct source));
1698 if (stack == NULL)
1699 err(1, "recursion too deep");
1700 bmachine.readstack_sz = newsz;
1701 bmachine.readstack = stack;
1702 }
1703 src_setstring(&bmachine.readstack[++bmachine.readsp], p);
1704 }
1705
1706 static void
1707 eval_line(void)
1708 {
1709 /* Always read from stdin */
1710 struct source in;
1711 char *p;
1712
1713 clearerr(stdin);
1714 src_setstream(&in, stdin);
1715 p = (*in.vtable->readline)(&in);
1716 eval_string(p);
1717 }
1718
1719 static void
1720 eval_tos(void)
1721 {
1722 char *p;
1723
1724 p = pop_string();
1725 if (p == NULL)
1726 return;
1727 eval_string(p);
1728 }
1729
1730 void
1731 eval(void)
1732 {
1733 int ch;
1734
1735 for (;;) {
1736 ch = readch();
1737 if (ch == EOF) {
1738 if (bmachine.readsp == 0)
1739 return;
1740 src_free();
1741 bmachine.readsp--;
1742 continue;
1743 }
1744 if (bmachine.interrupted) {
1745 if (bmachine.readsp > 0) {
1746 src_free();
1747 bmachine.readsp--;
1748 continue;
1749 } else
1750 bmachine.interrupted = false;
1751 }
1752 #ifdef DEBUGGING
1753 fprintf(stderr, "# %c\n", ch);
1754 stack_print(stderr, &bmachine.stack, "* ",
1755 bmachine.obase);
1756 fprintf(stderr, "%zd =>\n", bmachine.readsp);
1757 #endif
1758
1759 if (0 <= ch && ch < UCHAR_MAX)
1760 (*jump_table[ch])();
1761 else
1762 warnx("internal error: opcode %d", ch);
1763
1764 #ifdef DEBUGGING
1765 stack_print(stderr, &bmachine.stack, "* ",
1766 bmachine.obase);
1767 fprintf(stderr, "%zd ==\n", bmachine.readsp);
1768 #endif
1769 }
1770 }
DragonFly BSD