usr.bin/dc/bcode.c

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