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