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