usr.bin/dc/bcode.c

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