xref: /dragonfly/usr.bin/dc/bcode.c (revision e5a92d33) 
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 }
1771