home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / language / sbprolog / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-23  |  42.9 KB  |  1,406 lines
  1. /************************************************************************
  2. *                                                                       *
  3. * The SB-Prolog System                                                  *
  4. * Copyright SUNY at Stony Brook, 1986; University of Arizona, 1987      *
  5. *                                                                       *
  6. ************************************************************************/
  7.  
  8. /*-----------------------------------------------------------------
  9. SB-Prolog is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY.  No author or distributor
  11. accepts responsibility to anyone for the consequences of using it
  12. or for whether it serves any particular purpose or works at all,
  13. unless he says so in writing.  Refer to the SB-Prolog General Public
  14. License for full details.
  15.  
  16. Everyone is granted permission to copy, modify and redistribute
  17. SB-Prolog, but only under the conditions described in the
  18. SB-Prolog General Public License.   A copy of this license is
  19. supposed to have been given to you along with SB-Prolog so you
  20. can know your rights and responsibilities.  It should be in a
  21. file named COPYING.  Among other things, the copyright notice
  22. and this notice must be preserved on all copies.
  23. ------------------------------------------------------------------ */
  24. /* main.c */
  25.  
  26. #include "simdef.h"
  27. #include "aux.h"
  28. #include "inst.h"
  29.  
  30. #define NEXT_INSTRUCTION     goto contcase
  31.  
  32. #define OPREGC        (rreg[*lpcreg++])
  33. #define OPREG         ((LONG)(rreg + *lpcreg++))
  34. #define VARC(varno)   FOLLOW(lereg - (LONG)(varno))
  35. #define OPVARC        VARC(*lpcreg++)
  36. #define OPVAR         ((LONG)(lereg - (LONG)*lpcreg++))
  37.  
  38. #define PAD           lpcreg++
  39. #define OP2WORD       op2 = *(LONG_PTR)lpcreg;  lpcreg += 2
  40. #define NPARSE_VWv    op1 = OPVARC;  OP2WORD
  41. #define NPARSE_RWv    op1 = OPREGC;  OP2WORD
  42. #define NPARSE_Rv     op1 = OPREGC
  43. #define NPARSE_Vv     op1 = OPVARC
  44. #define NPARSE_PW     lpcreg++;  OP2WORD    /* note op2! */
  45. #define NPARSE_BW     op1 = *lpcreg++;  OP2WORD
  46. #define NPARSE_B      op1 = *lpcreg++
  47.  
  48. extern LONG_PTR set_intercode();
  49. extern double   floatval();
  50. extern LONG     makefloat();
  51. extern          eval();
  52.  
  53. LONG   temp_res;
  54. double result;
  55. WORD   floatp, current_opcode;
  56. LONG simpath;
  57.  
  58. main(argc, argv)
  59. int  argc;
  60. char *argv[];
  61. {
  62.    register WORD_PTR lpcreg;        /* local pcreg */
  63.    register LONG_PTR lereg;         /* local ereg */
  64.    register LONG_PTR rreg;          /* for SUN */
  65.    register LONG_PTR sreg;
  66.    register LONG_PTR top;
  67.    register LONG     op1;
  68.    LONG              op2, op3;
  69.    LONG              top1, top2;
  70.    PSC_REC_PTR       psc_ptr;
  71.    WORD              i, arity;      /* to unify subfields of op1 and op2 */
  72.    LONG_PTR          tempbreg;      /* for subtryme, rerestore, trrestore */
  73.    LONG_PTR          oldtr;
  74.    BYTE              flag;          /* read/write mode flag */
  75.  
  76.    arm_intercept();                 /* set up interrupt routine */
  77.    init_sim(argc, argv);            /* set up memory according to arguments */
  78.  
  79.    /* init_parse_routine(); */      /* set up array of pointers to functions */
  80.    init_load_routine();             /* set up array of pointers to functions */
  81.    init_builtin();                  /* set up array of pointers to functions */
  82.    init_loading(argc, argv);        /* load input files (bc_files) */
  83.    init_simpath(&simpath);        /* set up SIMPATH */
  84.  
  85.    if (disassem) {                  /* disassembly is requested */
  86.       dis();
  87.       printf("The byte code file is dumped in the file dump.pil\n");
  88.       exit(0);
  89.    }
  90.  
  91.    lpcreg = inst_begin;
  92.    lereg = ereg;
  93.    rreg   = (LONG_PTR)®[0];      /* for SUN */
  94.  
  95. /******************************************************************************/
  96. contcase:                           /* TOP OF EXECUTION LOOP */
  97.  
  98.    switch (*lpcreg++) {             /* switch on current opcode */
  99.  
  100.       case getpvar:                 /* PSS    Variable, Register */
  101.          PAD;
  102.          op1 = *lpcreg++;
  103.          VARC(op1) = OPREGC;
  104.          NEXT_INSTRUCTION;
  105.  
  106.       case getpval:                 /* PVR */
  107.          PAD;
  108.          op1 = OPVARC;
  109.          op2 = OPREGC;
  110.          goto nunify;
  111.  
  112.       case getstrv:                 /* VW */
  113.          NPARSE_VWv;
  114.          goto nunify_with_str;
  115.  
  116.       case gettval:                 /* PRR */
  117.          PAD;
  118.          op1 = OPREGC;
  119.          op2 = OPREGC;
  120.          goto nunify;
  121.  
  122.       case getcon:                  /* RW */
  123.          NPARSE_RWv;
  124.          goto nunify_with_con;
  125.  
  126.       case getnil:                  /* R */
  127.          NPARSE_Rv;
  128.          goto nunify_with_nil;
  129.  
  130.       case getstr:                  /* RW */
  131.          NPARSE_RWv;
  132.          goto nunify_with_str;
  133.  
  134.       case getlist:                 /* R */
  135.          NPARSE_Rv;
  136.          goto nunify_with_list_sym;
  137.  
  138.       case unipvar:                 /* V */
  139.          if (flag == WRITEFLAG) {
  140.             OPVARC = (LONG)hreg;
  141.             NEW_HEAP_FREE;
  142.          } else OPVARC = *sreg++;
  143.          NEXT_INSTRUCTION;
  144.  
  145.       case unipval:                 /* V */
  146.          NPARSE_Vv;
  147.          if (flag == WRITEFLAG)
  148.             goto nbldval;
  149.          else {
  150.             op2 = *sreg++;
  151.             goto nunify;
  152.          }
  153.  
  154.       case unitvar:                 /* R */
  155.          if (flag == WRITEFLAG) {
  156.             OPREGC = (LONG)hreg;
  157.             NEW_HEAP_FREE;
  158.          } else OPREGC = *sreg++;
  159.          NEXT_INSTRUCTION;
  160.  
  161.       case unitval:                 /* R */
  162.          NPARSE_Rv;
  163.          if (flag == WRITEFLAG)
  164.             goto nbldval;
  165.          else {
  166.             op2 = *sreg++;
  167.             goto nunify;
  168.          }
  169.  
  170.       case unicon:                  /* PW */
  171.          NPARSE_PW;                 /* note goes to op2! */
  172.          if (flag == WRITEFLAG) {
  173.             NEW_HEAP_CON(op2);
  174.             NEXT_INSTRUCTION;
  175.          } else {                   /* op2 already set */
  176.             op1 = *sreg++;
  177.             goto nunify_with_con;
  178.          }
  179.  
  180.       case uninil:                  /* P */
  181.          PAD;
  182.          if (flag == WRITEFLAG) {
  183.             NEW_HEAP_NODE(nil_sym);
  184.             NEXT_INSTRUCTION;
  185.          } else {
  186.             op1 = *sreg++;
  187.             goto nunify_with_nil;
  188.          }
  189.  
  190.       case getnumcon:               /* RW */
  191.          NPARSE_RWv;
  192.          goto nunify_with_int;
  193.  
  194.       case putnumcon:               /* RW */
  195.          op1 = *lpcreg++;
  196.          rreg[op1] = MAKEINT(*(LONG_PTR)lpcreg);
  197.          lpcreg += 2;
  198.          NEXT_INSTRUCTION;
  199.  
  200.       case putpvar:                 /* PVR */
  201.          PAD;
  202.          op1 = OPVAR;
  203.          FOLLOW(op1) = op1;
  204.          OPREGC = op1;
  205.          NEXT_INSTRUCTION;
  206.  
  207.       case putpval:                 /* PVR */
  208.          PAD;
  209.          op1 = *lpcreg++;
  210.          OPREGC = VARC(op1);
  211.          NEXT_INSTRUCTION;
  212.  
  213.       case puttvar:                 /* PRR */
  214.          PAD;
  215.          OPREGC = (LONG)hreg;
  216.          OPREGC = (LONG)hreg;
  217.          NEW_HEAP_FREE;
  218.          NEXT_INSTRUCTION;
  219.  
  220.       case putstrv:                 /* VW */
  221.          OPVARC = (LONG)hreg | CS_TAG;
  222.          NEW_HEAP_NODE(*(LONG_PTR)lpcreg);
  223.          lpcreg += 2;
  224.          NEXT_INSTRUCTION;
  225.  
  226.       case putcon:                  /* RW */
  227.          op1 = *lpcreg++;
  228.          rreg[op1] = *(LONG_PTR)lpcreg | CS_TAG;
  229.          lpcreg += 2;
  230.          NEXT_INSTRUCTION;
  231.  
  232.       case putnil:                  /* R */
  233.          OPREGC = nil_sym;
  234.          NEXT_INSTRUCTION;
  235.  
  236.       case putstr:                  /* RW */
  237.          OPREGC = (LONG)hreg | CS_TAG;
  238.          NEW_HEAP_NODE(*(LONG_PTR)lpcreg);
  239.          lpcreg += 2;
  240.          NEXT_INSTRUCTION;
  241.  
  242.       case putlist:                 /* R */
  243.          OPREGC = (LONG)hreg | LIST_TAG;
  244.          NEXT_INSTRUCTION;
  245.  
  246.       case bldpvar:                 /* V */
  247.          OPVARC = (LONG)hreg;
  248.          NEW_HEAP_FREE;
  249.          NEXT_INSTRUCTION;
  250.  
  251.       case bldpval:                 /* V */
  252.          NPARSE_Vv;
  253.          goto nbldval;
  254.  
  255.       case bldtvar:                 /* R */
  256.          OPREGC = (LONG)hreg;
  257.          NEW_HEAP_FREE;
  258.          NEXT_INSTRUCTION;
  259.  
  260.       case bldtval:                 /* R */
  261.          NPARSE_Rv;
  262.          goto nbldval;
  263.  
  264.       case bldcon:                  /* PW */
  265.          PAD;
  266.          NEW_HEAP_CON(*(LONG_PTR)lpcreg);
  267.          lpcreg += 2;
  268.          NEXT_INSTRUCTION;
  269.  
  270.       case bldnil:                  /* P */
  271.          PAD;
  272.          NEW_HEAP_NODE(nil_sym);
  273.          NEXT_INSTRUCTION;
  274.  
  275.       case uninumcon:               /* PL */
  276.          NPARSE_PW;                 /* num in op2 */
  277.          if (flag == WRITEFLAG) {
  278.             NEW_HEAP_INT(op2);
  279.             NEXT_INSTRUCTION;
  280.          } else {                   /* op2 set */
  281.             op1 = *sreg++;
  282.             goto nunify_with_int;
  283.          }
  284.  
  285.       case bldnumcon:               /* PL */
  286.          NPARSE_PW;                 /* num in op2 */
  287.          NEW_HEAP_INT(op2);
  288.          NEXT_INSTRUCTION;
  289.  
  290.       case getfloatcon:             /* RW */
  291.          NPARSE_RWv;
  292.          goto nunify_with_float;
  293.  
  294.       case putfloatcon:             /* RW */
  295.          op1 = *lpcreg++;
  296.          rreg[op1] = *(LONG_PTR)lpcreg;
  297.          lpcreg += 2;               /* float already tagged */
  298.          NEXT_INSTRUCTION;
  299.  
  300.       case unifloatcon:             /* PL */
  301.          NPARSE_PW;                 /* float in op2 */
  302.          if (flag == WRITEFLAG) {
  303.             NEW_HEAP_FLOAT(op2);
  304.             NEXT_INSTRUCTION;
  305.          } else {                   /* op2 set */
  306.             op1 = *sreg++;
  307.             goto nunify_with_float;
  308.          }
  309.  
  310.       case bldfloatcon:             /* PL */
  311.          NPARSE_PW;                 /* float in op2 */
  312.          NEW_HEAP_FLOAT(op2);
  313.          NEXT_INSTRUCTION;
  314.  
  315.       case test_unifiable:          /* RRR */
  316.          /* if reg1 and reg2 are unifiable, then reg3 is set to 1,
  317.           * else reg3 is set to 0.  Logically equivalent to
  318.           * not(not(reg1 = reg2)).
  319.           */
  320.          op1 = OPREGC;
  321.          op2 = OPREGC;
  322.          op3 = OPREG;
  323.          top1 = (LONG)trreg;
  324.          FOLLOW(op3) = MAKEINT(unify(op1, op2));
  325.          while ((LONG)trreg != top1) {    /* undo bindings, if any */
  326.             top = (LONG_PTR)*(++trreg);
  327.             *(LONG_PTR *)top = top;
  328.          }
  329.          NEXT_INSTRUCTION;
  330.  
  331.       case getlist_k:               /* R */
  332.          PAD;
  333.          flag = READFLAG;
  334.          NEXT_INSTRUCTION;
  335.  
  336.       case getlist_k_tvar_tvar:     /* BBB */
  337.          PAD;
  338.          OPREGC = *sreg++;
  339.          OPREGC = *sreg;
  340.          NEXT_INSTRUCTION;
  341.  
  342.       case getlist_tvar_tvar:       /* BBB */
  343.          op1 = OPREGC;
  344. glrr:    switch (TAG(op1)) {
  345.             case FREE: NDEREF(op1, glrr);
  346.                        FOLLOW(op1) = (LONG)hreg | LIST_TAG;
  347.                        PUSHTRAIL(op1);
  348.                        OPREGC = (LONG)hreg;
  349.                        NEW_HEAP_FREE;
  350.                        OPREGC = (LONG)hreg;
  351.                        NEW_HEAP_FREE;
  352.                        NEXT_INSTRUCTION;
  353.             case CS  :
  354.             case NUM : FAIL1;
  355.                        NEXT_INSTRUCTION;
  356.             case LIST: sreg = (LONG_PTR)(UNTAGGED(op1));
  357.                        OPREGC = *sreg++;
  358.                        OPREGC = *sreg;
  359.                        NEXT_INSTRUCTION;
  360.          }  /* end getlist_tvar_tvar */
  361.  
  362.       case getcomma:                /* R */
  363.          NPARSE_Rv;
  364.          op2 = (LONG)comma_psc;
  365.          goto nunify_with_str;
  366.  
  367.       case getcomma_tvar_tvar:      /* BBB */
  368.          op1 = OPREGC;
  369. gcrr:    switch (TAG(op1)) {
  370.             case FREE: NDEREF(op1, gcrr);
  371.                        FOLLOW(op1) = (LONG)hreg | CS_TAG;
  372.                        PUSHTRAIL(op1);
  373.                        NEW_HEAP_NODE((LONG)comma_psc);
  374.                        PUSHTRAIL(op1);
  375.                        OPREGC = (LONG)hreg;
  376.                        NEW_HEAP_FREE;
  377.                        OPREGC = (LONG)hreg;
  378.                        NEW_HEAP_FREE;
  379.                        NEXT_INSTRUCTION;
  380.             case CS  : UNTAG(op1);
  381.                        if (FOLLOW(op1) == (LONG)comma_psc) {
  382.                           sreg = (LONG_PTR)(op1+4);
  383.                           OPREGC = *sreg++;
  384.                           OPREGC = *sreg;
  385.                           NEXT_INSTRUCTION;
  386.                        }
  387.             case NUM :
  388.             case LIST: FAIL1;
  389.                        NEXT_INSTRUCTION;
  390.          }  /* end getcomma_tvar_tvar */
  391.  
  392.       case trymeelse:               /* BA */
  393.          NPARSE_BW;
  394.          goto subtryme;
  395.  
  396.       case retrymeelse:             /* BA */
  397.          op1 = *lpcreg++;
  398.          *(breg + 1) = *(LONG_PTR)lpcreg;
  399.          lpcreg += 2;
  400.          goto rerestore;
  401.  
  402.       case trustmeelsefail:         /* B */
  403.          NPARSE_B;
  404.          goto trrestore;
  405.  
  406.       case try:                     /* BA */
  407.          op1 = *lpcreg++;
  408.          op2 = (LONG)(lpcreg + 2);
  409.          lpcreg = (WORD_PTR)*(LONG_PTR)lpcreg;
  410.          goto subtryme;
  411.  
  412.       case retry:                   /* BA */
  413.          op1 = *lpcreg++;
  414.          *(breg + 1) = (LONG)(lpcreg + 2);
  415.          lpcreg = (WORD_PTR)*(LONG_PTR)lpcreg;
  416.          goto rerestore;
  417.  
  418.       case trust:                   /* BA */
  419.          op1 = *lpcreg++;
  420.          lpcreg = (WORD_PTR)*(LONG_PTR)lpcreg;
  421.          goto trrestore;
  422.  
  423.       case getpbreg:                /* V */
  424.          OPVARC = (LONG)breg | NUM_TAG;
  425.          NEXT_INSTRUCTION;
  426.  
  427.       case gettbreg:                /* R */
  428.          OPREGC = (LONG)breg | NUM_TAG;
  429.          NEXT_INSTRUCTION;
  430.  
  431.       case putpbreg:                /* V */
  432.          NPARSE_Vv;
  433.          DEREF(op1);
  434.          breg  = (LONG_PTR)UNTAGGED(op1);
  435.          hbreg = (LONG_PTR)*(breg + 3);
  436.          NEXT_INSTRUCTION;
  437.  
  438.       case puttbreg:                /* R */
  439.          NPARSE_Rv;
  440.          DEREF(op1);
  441.          breg = (LONG_PTR)UNTAGGED(op1);
  442.          hbreg = (LONG_PTR)*(breg + 3);
  443.          NEXT_INSTRUCTION;
  444.  
  445.       case switchonterm:            /* RWW */
  446.          op1 = OPREGC;
  447. sotd:    switch (TAG(op1)) {
  448.             case FREE: NDEREF(op1, sotd);
  449.                        lpcreg += 4;
  450.                        NEXT_INSTRUCTION;
  451.             case NUM : lpcreg = *(WORD_PTR *)lpcreg;
  452.                        NEXT_INSTRUCTION;
  453.             case CS  : if (GET_STR_ARITY(op1) == 0) {
  454.                           lpcreg = *(WORD_PTR *)lpcreg;
  455.                           NEXT_INSTRUCTION;
  456.                        }
  457.             case LIST: /* include structure case here */
  458.                        lpcreg += 2;
  459.                        lpcreg = *(WORD_PTR *)lpcreg;
  460.                        NEXT_INSTRUCTION;
  461.          }  /* end switchonterm */
  462.  
  463.       case arg:                     /* RRR */
  464.          op1 = OPREGC;              /* index, i */
  465.          op2 = OPREGC;              /* term being indexed into, T */
  466.          op3 = OPREGC;              /* i_th. argument of T */
  467.          DEREF(op1);
  468.          if (!ISINTEGER(op1)) {
  469.             printf("arg: Index must be an integer.\n");
  470.             FAIL1;
  471.             NEXT_INSTRUCTION;
  472.          }
  473.          op1 = INTVAL(op1);
  474.          if (op1 <= 0) {
  475.             printf("arg: index must be > 0\n");
  476.             FAIL1;
  477.             NEXT_INSTRUCTION;
  478.          }
  479.          DEREF(op2);
  480.          if (ISCONSTR(op2) && op1 <= GET_STR_ARITY(op2))
  481.             if (unify(*((LONG_PTR)UNTAG(op2) + op1), op3))
  482.                NEXT_INSTRUCTION;
  483.          if (ISLIST(op2) && op1 <= 2)
  484.             if (unify(*((LONG_PTR)UNTAG(op2) + op1 - 1), op3))
  485.                NEXT_INSTRUCTION;
  486.          FAIL1;
  487.          NEXT_INSTRUCTION;
  488.  
  489.       case arg0:                    /* RRR */
  490.          op1 = OPREGC;              /* index, i */
  491.          op2 = OPREGC;              /* term being indexed into, T */
  492.          op3 = OPREGC;              /* i_th. argument of T */
  493.          DEREF(op1);
  494.          if (!ISINTEGER(op1)) {
  495.             printf("arg: Index must be an integer.\n");
  496.             FAIL1;
  497.             NEXT_INSTRUCTION;
  498.          }
  499.          op1 = INTVAL(op1);
  500.          if (op1 <= 0) {
  501.             printf("arg: index must be > 0\n");
  502.             FAIL1;
  503.             NEXT_INSTRUCTION;
  504.          }
  505.          DEREF(op2);
  506.          if (ISCONSTR(op2) && op1 <= GET_STR_ARITY(op2))
  507.             op2 = *((LONG_PTR)UNTAG(op2) + op1);
  508.          else if (ISLIST(op2) && op1 <= 2)
  509.             op2 = *((LONG_PTR)UNTAG(op2) + op1 - 1);
  510.          else {
  511.             FAIL1;
  512.             NEXT_INSTRUCTION;
  513.          }
  514.          DEREF(op3);
  515.          if (ISNONVAR(op2)) {
  516.             FOLLOW(op3) = op2;
  517.             PUSHTRAIL(op3);
  518.          } else {                          /* op2 is a variable */
  519.             if (op2 != op3) {
  520.                if (op2 < op3) {
  521.                   if (op2 < (LONG)hreg) {  /* op2 not in loc stack */
  522.                      FOLLOW(op3) = op2;
  523.                      PUSHTRAIL(op3);
  524.                   } else {                 /* op2 points to op3 */
  525.                      FOLLOW(op2) = op3;
  526.                      PUSHTRAIL(op2);
  527.                   }
  528.                } else {                    /* op2 > op3 */
  529.                   if (op3 < (LONG)hreg) {
  530.                      FOLLOW(op2) = op3;
  531.                      PUSHTRAIL(op2);
  532.                   } else {
  533.                      FOLLOW(op3) = op2;
  534.                      PUSHTRAIL(op3);
  535.                   }
  536.                }
  537.             }
  538.          }
  539.          NEXT_INSTRUCTION;
  540.  
  541.       case switchonbound:           /* RWW */
  542.          op1 = OPREGC;
  543. sotd1:   switch (TAG(op1)) {
  544.             case FREE: NDEREF(op1, sotd1);
  545.                        lpcreg += 4;
  546.                        NEXT_INSTRUCTION;
  547.             case NUM : op1 = NUMVAL(op1);
  548.                        break;
  549.             case LIST: op1 = *(LONG_PTR)UNTAGGED(list_str);
  550.                        break;
  551.             case CS  : op1 = (LONG)GET_STR_PSC(op1);
  552.                        break;
  553.          }
  554.          op2 = *(LONG_PTR)lpcreg;
  555.          lpcreg += 2;
  556.          op3 = *(LONG_PTR)lpcreg;
  557.          lpcreg = *(WORD_PTR *)(IHASH(op1, op3) * 4 + op2);
  558.          NEXT_INSTRUCTION;
  559.  
  560.       case switchonlist:            /* RWW */
  561.          /* this is a specialization of the switchonterm instruction:
  562.           * switchonlist R, L1, L2 means: if reg R DEREFs to '[]', goto
  563.           * L1; if it DEREFs to [_|_], goto L2; if it DEREFs to a variable,
  564.           * fall through; else fail.
  565.           */
  566.          op1 = OPREGC;
  567. sold:    switch (TAG(op1)) {
  568.             case FREE: NDEREF(op1, sold);
  569.                        lpcreg += 4;
  570.                        NEXT_INSTRUCTION;
  571.             case NUM : FAIL1;
  572.                        NEXT_INSTRUCTION;
  573.             case CS  : if (op1 == nil_sym)
  574.                           lpcreg = *(WORD_PTR *)lpcreg;
  575.                        else
  576.                           FAIL1;
  577.                        NEXT_INSTRUCTION;
  578.             case LIST: sreg = (LONG_PTR)(UNTAGGED(op1));
  579.                        lpcreg += 2;
  580.                        lpcreg = *(WORD_PTR *)lpcreg;
  581.                        NEXT_INSTRUCTION;
  582.          }  /* end switchonlist */
  583.  
  584.       case get_tag:                 /* PRR */
  585.          /* DEREFs 1st operand reg, copies low 3 bits into 2nd operand reg */
  586.          PAD;
  587.          op1 = OPREGC;  DEREF(op1);
  588.          OPREGC = MAKEINT(op1 & 0x7);
  589.          NEXT_INSTRUCTION;
  590.  
  591.       case movreg:                  /* PRR */
  592.          PAD;
  593.          op1 = *lpcreg++;
  594.          OPREGC = rreg[op1];
  595.          NEXT_INSTRUCTION;
  596.  
  597.       case negate:
  598.          op1 = *lpcreg++;
  599.          op2 = rreg[op1];  DEREF(op2);
  600.          if (!ISINTEGER(op2)) {
  601.             printf("negate: integer required\n");
  602.             FAIL1;
  603.          } else rreg[op1] = MAKEINT(~INTVAL(op2));
  604.          NEXT_INSTRUCTION;
  605.  
  606.       case and:
  607.          PAD;
  608.          op1 = OPREGC;
  609.          op3 = OPREG;
  610.          op2 = FOLLOW(op3);
  611.          DEREF(op1);
  612.          DEREF(op2);
  613.          if (!ISINTEGER(op1) || !ISINTEGER(op2)) {
  614.             printf("and: integer required\n");
  615.             FAIL1;
  616.          } else FOLLOW(op3) = MAKEINT(INTVAL(op2) & INTVAL(op1));
  617.          NEXT_INSTRUCTION;
  618.  
  619.       case or:
  620.          PAD;
  621.          op1 = OPREGC;
  622.          op3 = OPREG;
  623.          op2 = FOLLOW(op3);
  624.          DEREF(op1);
  625.          DEREF(op2);
  626.          if (!ISINTEGER(op1) || !ISINTEGER(op2)) {
  627.             printf("or: integer required\n");
  628.             FAIL1;
  629.          } else FOLLOW(op3) = MAKEINT(INTVAL(op2) | INTVAL(op1));
  630.          NEXT_INSTRUCTION;
  631.  
  632.       case lshiftl:
  633.          PAD;
  634.          op1 = OPREGC;
  635.          op3 = OPREG;
  636.          op2 = FOLLOW(op3);
  637.          DEREF(op1);
  638.          DEREF(op2);
  639.          if (!ISINTEGER(op1) || !ISINTEGER(op2)) {
  640.             printf("lshiftl: integer required\n");
  641.             FAIL1;
  642.          } else FOLLOW(op3) = MAKEINT(INTVAL(op2) << INTVAL(op1));
  643.          NEXT_INSTRUCTION;
  644.  
  645.       case lshiftr:
  646.          PAD;
  647.          op1 = OPREGC;
  648.          op3 = OPREG;
  649.          op2 = FOLLOW(op3);
  650.          DEREF(op1);
  651.          DEREF(op2);
  652.          if (!ISINTEGER(op1) ||!ISINTEGER(op2)) {
  653.             printf("lshiftr: integer required\n");
  654.             FAIL1;
  655.          } else FOLLOW(op3) = MAKEINT(INTVAL(op2) >> INTVAL(op1));
  656.          NEXT_INSTRUCTION;
  657.  
  658.       case addreg:                /* PRR */
  659.          PAD;
  660.          op1 = OPREGC;
  661.          op3 = OPREG;
  662.          op2 = FOLLOW(op3);
  663.          DEREF(op1);
  664.          if (ISINTEGER(op1))
  665.             floatp = 0;
  666.          else if (ISFLOAT(op1))
  667.             floatp = 1;
  668.          else {
  669.             floatp = eval(op1, &top1);
  670.             op1 = top1;
  671.          }
  672.          DEREF(op2);
  673.          if (ISINTEGER(op2))
  674.             ;
  675.          else if (ISFLOAT(op2))
  676.             floatp = floatp | 1;
  677.          else {
  678.             floatp = floatp | eval(op2, &top2);
  679.             op2 = top2;
  680.          }
  681.          switch (floatp) {
  682.             case -1: printf("add: number required\n");
  683.                      FAIL1;
  684.                      NEXT_INSTRUCTION;
  685.             case  0: FOLLOW(op3) = MAKEINT(INTVAL(op2) + INTVAL(op1));
  686.                      NEXT_INSTRUCTION;
  687.             case  1: FOLLOW(op3) = makefloat(NUMVAL(op2) + NUMVAL(op1));
  688.                      NEXT_INSTRUCTION;
  689.          }
  690.          NEXT_INSTRUCTION;
  691.  
  692.       case subreg:                /* PRR */
  693.          PAD;
  694.          op1 = OPREGC;
  695.          op3 = OPREG;
  696.          op2 = FOLLOW(op3);
  697.          DEREF(op1);
  698.          if (ISINTEGER(op1))
  699.             floatp = 0;
  700.          else if (ISFLOAT(op1))
  701.             floatp = 1;
  702.          else {
  703.             floatp = eval(op1, &top1);
  704.             op1 = top1;
  705.          }
  706.          DEREF(op2);
  707.          if (ISINTEGER(op2))
  708.             ;
  709.          else if (ISFLOAT(op2))
  710.             floatp = floatp | 1;
  711.          else {
  712.             floatp = floatp | eval(op2, &top2);
  713.             op2 = top2;
  714.          }
  715.          switch (floatp) {
  716.             case -1: printf("sub: number required\n");
  717.                      FAIL1;
  718.                      NEXT_INSTRUCTION;
  719.             case  0: FOLLOW(op3) = MAKEINT(INTVAL(op2) - INTVAL(op1));
  720.                      NEXT_INSTRUCTION;
  721.             case  1: FOLLOW(op3) = makefloat(NUMVAL(op2) - NUMVAL(op1));
  722.                      NEXT_INSTRUCTION;
  723.          }
  724.          NEXT_INSTRUCTION;
  725.  
  726.       case mulreg:                /* PRR */
  727.          PAD;
  728.          op1 = OPREGC;
  729.          op3 = OPREG;
  730.          op2 = FOLLOW(op3);
  731.          DEREF(op1);
  732.          if (ISINTEGER(op1))
  733.             floatp = 0;
  734.          else if (ISFLOAT(op1))
  735.             floatp = 1;
  736.          else {
  737.             floatp = eval(op1, &top1);
  738.             op1 = top1;
  739.          }
  740.          DEREF(op2);
  741.          if (ISINTEGER(op2))
  742.             ;
  743.          else if (ISFLOAT(op2))
  744.             floatp = floatp | 1;
  745.          else {
  746.             floatp = floatp | eval(op2, &top2);
  747.             op2 = top2;
  748.          }
  749.          switch (floatp) {
  750.             case -1: printf("mul: number required\n");
  751.                      FAIL1;
  752.                      NEXT_INSTRUCTION;
  753.             case  0:  FOLLOW(op3) = MAKEINT(INTVAL(op2) * INTVAL(op1));
  754.                      NEXT_INSTRUCTION;
  755.             case  1: FOLLOW(op3) = makefloat(NUMVAL(op2) * NUMVAL(op1));
  756.                      NEXT_INSTRUCTION;
  757.          }
  758.          NEXT_INSTRUCTION;
  759.  
  760.       case divreg:                /* PRR */
  761.          PAD;
  762.          op1 = OPREGC;
  763.          op3 = OPREG;
  764.          op2 = FOLLOW(op3);
  765.          DEREF(op1);
  766.          if (!ISNUM(op1)) {
  767.             eval(op1, &top1);
  768.             op1 = top1;
  769.          }
  770.          DEREF(op2);
  771.          if (!ISNUM(op2)) {
  772.             eval(op2, &top2);
  773.             op2 = top2;
  774.          }
  775.          result = NUMVAL(op2) / NUMVAL(op1);
  776.          FOLLOW(op3) = makefloat(result);
  777.          NEXT_INSTRUCTION;
  778.  
  779.       case idivreg:               /* PRR */
  780.          PAD;
  781.          op1 = OPREGC;
  782.          op3 = OPREG;
  783.          op2 = FOLLOW(op3);
  784.          DEREF(op1);
  785.          if (ISINTEGER(op1))
  786.             floatp = 0;
  787.          else {
  788.             floatp = eval(op1, &top1);
  789.             op1 = top1;
  790.          }
  791.          DEREF(op2);
  792.          if (ISINTEGER(op2))
  793.             ;
  794.          else {
  795.             floatp = floatp | eval(op2, &top2);
  796.             op2 = top2;
  797.          }
  798.          if (floatp != 0) {
  799.             printf("integer division: operands must be integers\n");
  800.             FAIL1;
  801.          } else FOLLOW(op3) = MAKEINT(INTVAL(op2) / INTVAL(op1));
  802.          NEXT_INSTRUCTION;
  803.  
  804.       case putdval:               /* PVR */
  805.          PAD;
  806.          op1 = OPVARC;  DEREF(op1);
  807.          OPREGC = op1;
  808.          NEXT_INSTRUCTION;
  809.  
  810.       case putuval:               /* PVR */
  811.          PAD;
  812.          op1 = OPVARC;  DEREF(op1);
  813.          if (ISNONVAR(op1) || op1 < (LONG)hreg || op1 >= (LONG)lereg)
  814.             OPREGC = op1;
  815.          else {
  816.             FOLLOW(op1) = OPREGC = (LONG)hreg;
  817.             PUSHTRAIL(op1);
  818.             NEW_HEAP_FREE;
  819.          }
  820.          NEXT_INSTRUCTION;
  821.  
  822.       case call:                  /* PW */
  823.          NPARSE_PW;
  824.          cpreg = (LONG_PTR)lpcreg;
  825.          psc_ptr = (PSC_REC_PTR)op2;
  826.          goto call_sub;
  827.  
  828.       case allocate:
  829.          op1 = *lpcreg++;
  830.          op2 = (breg < lereg) ? (LONG)breg : (LONG)(lereg - ENV_SIZE(cpreg));
  831.  
  832.      /* check for heap overflow */
  833.          if ((LONG_PTR)op2 - op1 < hreg) {
  834.             ereg = lereg;
  835.             /* garbage_collection("allocate"); */ /* GC buggy! */
  836.         if ((LONG_PTR)op2 - op1 < hreg) {    /* still too full */
  837.            quit("Heap overflow\n");
  838. /*
  839.            if (!overflow_f) {
  840.                   overflow_f = 1;
  841.                   lpcreg = (WORD_PTR)set_intercode(2);
  842.                }
  843. */
  844.         }
  845.      }
  846.  
  847.          FOLLOW(op2) = (LONG)lereg;
  848.          FOLLOW(op2 - 4) = (LONG)cpreg;
  849.      lereg = (LONG_PTR)op2;
  850.          for (op2 -= 8, op1 -= 2; op1 > 0; op2 -= 4, op1 -= 1)
  851.             FOLLOW(op2) = op2;        /* init permanent vars */
  852.          NEXT_INSTRUCTION;
  853.  
  854.       case deallocate:
  855.          PAD;
  856.          cpreg  = (LONG_PTR)*(lereg - 1);
  857.          lereg = (LONG_PTR)*lereg;
  858.          NEXT_INSTRUCTION;
  859.  
  860.       case proceed:
  861.          PAD;
  862.          lpcreg = (WORD_PTR)cpreg;
  863.          NEXT_INSTRUCTION;
  864.  
  865.       case execute:
  866.          NPARSE_PW;
  867.          psc_ptr = (PSC_REC_PTR)op2;
  868.          goto call_sub;
  869.  
  870.       case calld:
  871.          PAD;
  872.          cpreg  = (LONG_PTR)(lpcreg + 2);
  873.          lpcreg = (WORD_PTR)*(LONG_PTR)lpcreg;
  874.  
  875.      /* check for potential heap overflow */
  876.          if (lereg < hreg + 100) {
  877.             ereg = lereg;
  878.             /* garbage_collection("calld"); */ /* GC buggy! */
  879.         if (lereg < hreg + 100)     /* still too full */
  880.            quit("Heap overflow\n");
  881.          }
  882.  
  883.          NEXT_INSTRUCTION;
  884.  
  885.       case jump:
  886.          PAD;
  887.          lpcreg = (WORD_PTR)*(LONG_PTR)lpcreg;
  888.          NEXT_INSTRUCTION;
  889.  
  890.       case jumpz:
  891.          op3 = OPREGC;
  892.          if (NUMVAL(op3) == 0)
  893.             lpcreg = *(WORD_PTR *)lpcreg;
  894.          else
  895.             lpcreg += 2;
  896.          NEXT_INSTRUCTION;
  897.  
  898.       case jumpnz:
  899.          op3 = OPREGC;
  900.          if (NUMVAL(op3) != 0)
  901.             lpcreg = *(WORD_PTR *)lpcreg;
  902.          else
  903.             lpcreg += 2;
  904.          NEXT_INSTRUCTION;
  905.  
  906.       case jumplt:
  907.          op3 = OPREGC;
  908.          if (NUMVAL(op3) < 0)
  909.             lpcreg = *(WORD_PTR *)lpcreg;
  910.          else
  911.             lpcreg += 2;
  912.          NEXT_INSTRUCTION;
  913.  
  914.       case jumple:
  915.          op3 = OPREGC;
  916.          if (NUMVAL(op3) <= 0)
  917.             lpcreg = *(WORD_PTR *)lpcreg;
  918.          else
  919.             lpcreg += 2;
  920.          NEXT_INSTRUCTION;
  921.  
  922.       case jumpgt:
  923.          op3 = OPREGC;
  924.          if (NUMVAL(op3) > 0)
  925.             lpcreg = *(WORD_PTR *)lpcreg;
  926.          else
  927.             lpcreg += 2;
  928.          NEXT_INSTRUCTION;
  929.  
  930.       case jumpge:
  931.          op3 = OPREGC;
  932.          if (NUMVAL(op3) >= 0)
  933.             lpcreg = *(WORD_PTR *)lpcreg;
  934.          else
  935.             lpcreg += 2;
  936.          NEXT_INSTRUCTION;
  937.  
  938.       case fail:
  939.          PAD;
  940.          FAIL1;
  941.          NEXT_INSTRUCTION;
  942.  
  943.       case noop:
  944.          NPARSE_B;
  945.          lpcreg += op1;
  946.          NEXT_INSTRUCTION;
  947.  
  948.       case halt:
  949.          PAD;
  950.          printf("\nHalt. Program terminated normally\n");
  951.          exit(0);
  952.          NEXT_INSTRUCTION;
  953.  
  954.       case builtin:
  955.          NPARSE_B;
  956.          pcreg = lpcreg;
  957.          ereg  = lereg;
  958.          Builtin(op1);
  959.          lpcreg = pcreg;
  960.          NEXT_INSTRUCTION;
  961.  
  962.       case endfile:
  963.          NPARSE_PW;
  964.          NEXT_INSTRUCTION;
  965.  
  966.       case getival:               /* RW */
  967.          NPARSE_RWv;
  968.          goto nunify;
  969.  
  970.       case jumptbreg:             /* RW */
  971.          OPREGC = (LONG)breg | NUM_TAG;
  972.          lpcreg = *(WORD_PTR *)lpcreg;
  973.          NEXT_INSTRUCTION;
  974.  
  975.       case unexec:
  976.          /* PWW, builds str on heap, and executes 2nd arg
  977.           * simulates exec(op2(op1(A1,A2,..,An)) for intercepting calls
  978.           */
  979.          NPARSE_PW;
  980.          op3 = (LONG)hreg;        /* save addr of new structure rec */
  981.          NEW_HEAP_NODE(op2);      /* set str psc ptr */
  982.          for (i = 1; i <= GET_ARITY((PSC_REC_PTR)op2); i++) {
  983.             op1 = rreg[i];
  984. unebld:     if (ISVAR(op1)) {
  985.                NDEREF(op1, unebld);
  986.                FOLLOW(op1) = (LONG)hreg;
  987.                PUSHTRAIL(op1);
  988.                NEW_HEAP_FREE;
  989.             } else NEW_HEAP_NODE(op1);
  990.          }
  991.          rreg[1] = op3 | CS_TAG;  /* ptr to new structure on heap */
  992.          OP2WORD;
  993.          psc_ptr = (PSC_REC_PTR)op2;
  994.          goto call_sub;
  995.  
  996.       case unexeci:
  997.          /* PWW, builds str on heap with last arg a var,
  998.           * and executes 2nd arg; for interpreting;
  999.           * simulates exec(op2(op1(A1,A2,..,An-1,B),B)
  1000.           */
  1001.          NPARSE_PW;
  1002.          op3 = (LONG)hreg;        /* save addr of new structure rec */
  1003.          NEW_HEAP_NODE(op2);      /* set str psc ptr */
  1004.          for (i = 1; i < GET_ARITY((PSC_REC_PTR)op2); i++) {
  1005.             op1 = rreg[i];
  1006. unibld:     if (ISVAR(op1)) {
  1007.                NDEREF(op1, unibld);
  1008.                FOLLOW(op1) = (LONG)hreg;
  1009.                PUSHTRAIL(op1);
  1010.                NEW_HEAP_FREE;
  1011.             } else NEW_HEAP_NODE(op1);
  1012.          }
  1013.          rreg[1] = op3 | CS_TAG;  /* ptr to new structure on heap */
  1014.          rreg[2] = (LONG)hreg;
  1015.          NEW_HEAP_FREE;           /* add last field to rec */
  1016.          OP2WORD;
  1017.          psc_ptr = (PSC_REC_PTR)op2;
  1018.          goto call_sub;
  1019.  
  1020.       case executev:
  1021.          NPARSE_PW;
  1022. exun:    switch (TAG(op2)) {
  1023.             case FREE: NDEREF(op2,exun);
  1024.             case NUM : printf("Error: Illegal call\n");
  1025.                        FAIL1;
  1026.                        NEXT_INSTRUCTION;
  1027.             case CS  : psc_ptr = GET_STR_PSC(op2);
  1028.                        goto call_sub;
  1029.             case LIST: psc_ptr = list_psc;
  1030.                        goto call_sub;
  1031.          }
  1032.  
  1033.       default:
  1034.          printf("\nIllegal opcode hex %x at %x\n", *--lpcreg, lpcreg);
  1035.          exit(1);
  1036.  
  1037.    }  /* end switch */
  1038.  
  1039. /******************************************************************************/
  1040.  
  1041. /*------------------------------------------------------------------*/
  1042. nunify:                                     /* op1 and op2 are unknown type */
  1043.  
  1044.    switch (TAG(op1)) {
  1045.       case FREE:                            /* op1 is derefed free node */
  1046.          NDEREF(op1, nunify);
  1047. nunify1: switch (TAG(op2)) {
  1048.             case FREE:                      /* op1 is free, op2 is free */
  1049.                NDEREF(op2, nunify1);
  1050.                if (op1 != op2) {
  1051.                   if (op1 < op2) {
  1052.                      if (op1 < (LONG)hreg) {  /* op1 not in loc stack */
  1053.                         FOLLOW(op2) = op1;
  1054.                         PUSHTRAIL(op2);
  1055.                      } else {                 /* op1 points to op2 */
  1056.                         FOLLOW(op1) = op2;
  1057.                         PUSHTRAIL(op1);
  1058.                      }
  1059.                   } else {                    /* op1 > op2 */
  1060.                      if (op2 < (LONG)hreg) {
  1061.                         FOLLOW(op1) = op2;
  1062.                         PUSHTRAIL(op1);
  1063.                      } else {
  1064.                         FOLLOW(op2) = op1;
  1065.                         PUSHTRAIL(op2);
  1066.                      }
  1067.                   }
  1068.                }
  1069.                NEXT_INSTRUCTION;
  1070.             case CS  :                      /* op1 is free, op2 is con/str */
  1071.             case LIST:                      /* op1 is free, op2 is list    */
  1072.             case NUM :                      /* op1 is free, op2 is num     */
  1073.            FOLLOW(op1) = op2;
  1074.                PUSHTRAIL(op1);
  1075.                NEXT_INSTRUCTION;
  1076.          }  /* op1 = FREE - switch on op2 */
  1077.  
  1078.       case CS:                              /* op1 is con/str */
  1079. nunify2: switch (TAG(op2)) {
  1080.             case FREE:                      /* op1 is con/str, op2 is free */
  1081.            NDEREF(op2, nunify2);
  1082.                FOLLOW(op2) = op1;
  1083.                PUSHTRAIL(op2);
  1084.                NEXT_INSTRUCTION;
  1085.             case CS:                        /* op1 is con/str, op2 is con/str */
  1086.            if (op1 != op2) {
  1087.                   UNTAG(op1);
  1088.                   UNTAG(op2);
  1089.                   if (FOLLOW(op1) != FOLLOW(op2))
  1090.                      FAIL1;
  1091.                   else {
  1092.                      arity = GET_STR_ARITY(op1);
  1093.                      for (i = 1; i <= arity; i++)
  1094.                         if (!unify(*((LONG_PTR)op1+i), *((LONG_PTR)op2+i))) {
  1095.                            FAIL1;
  1096.                            NEXT_INSTRUCTION;
  1097.                         }
  1098.                   }
  1099.                }
  1100.                NEXT_INSTRUCTION;            /* OK by default */
  1101.             case LIST:                      /* op1 is con/str, op2 is list */
  1102.             case NUM :                      /* op1 is con/str, op2 is num  */
  1103.            FAIL1;
  1104.                NEXT_INSTRUCTION;
  1105.          }  /* op1 = CS - switch on op2 */
  1106.  
  1107.       case LIST:                            /* op1 is list */
  1108. nunify3: switch (TAG(op2)) {
  1109.             case FREE:                      /* op1 is list, op2 is free */
  1110.            NDEREF(op2, nunify3);
  1111.                FOLLOW(op2) = op1;
  1112.                PUSHTRAIL(op2);
  1113.                NEXT_INSTRUCTION;
  1114.             case CS :                       /* op1 is list, op2 is con/str */
  1115.             case NUM:                       /* op1 is list, op2 is num     */
  1116.            FAIL1;
  1117.                NEXT_INSTRUCTION;
  1118.             case LIST:                      /* op1 is list, op2 is list */
  1119.            if (op1 != op2) {
  1120.                   UNTAG(op1);
  1121.                   UNTAG(op2);
  1122.                   if (!unify(*(LONG_PTR)op1, *(LONG_PTR)op2) ||
  1123.                       !unify(*((LONG_PTR)op1 + 1), *((LONG_PTR)op2 + 1)))
  1124.                      FAIL1;
  1125.                }
  1126.                NEXT_INSTRUCTION;            /* OK by default */
  1127.          }  /* op1 = LIST - switch on op2 */
  1128.  
  1129.       case NUM:                             /* op1 is num */
  1130. nunify4: switch (TAG(op2)) {
  1131.             case FREE:                      /* op1 is num, op2 is free */
  1132.                NDEREF(op2, nunify4);
  1133.                FOLLOW(op2) = op1;
  1134.                PUSHTRAIL(op2);
  1135.                NEXT_INSTRUCTION;
  1136.             case NUM:                       /* op1 is num, op2 is num */
  1137.            if (op1 == op2)
  1138.                   NEXT_INSTRUCTION;
  1139.                else if ((ISFLOAT(op1) || ISFLOAT(op2)) &&
  1140.                      NUMVAL(op2) == NUMVAL(op1))
  1141.                   NEXT_INSTRUCTION;    /* fails by default */
  1142.             case CS  :                      /* op1 is num, op2 is con/str */
  1143.             case LIST:                      /* op1 is num, op2 is list    */
  1144.            FAIL1;
  1145.                NEXT_INSTRUCTION;
  1146.          }  /* op1 = NUM - switch on op2 */
  1147.  
  1148.    }  /* end of nunify */
  1149.  
  1150. /*------------------------------------------------------------------*/
  1151. nunify_with_con:                            /* op1 is unknown,           */
  1152.                         /* op2 is con/str (UNTAGGED) */
  1153.    switch (TAG(op1)) {
  1154.       case FREE:                            /* op1 is free, op2 is con/str */
  1155.      NDEREF(op1, nunify_with_con);
  1156.          FOLLOW(op1) = op2 | CS_TAG;
  1157.          PUSHTRAIL(op1);
  1158.          NEXT_INSTRUCTION;
  1159.       case CS:                              /* op1 is con/str, op2 is con/str */
  1160.          UNTAG(op1);
  1161.          if (op1 != op2)
  1162.             if (FOLLOW(op2) != FOLLOW(op1))
  1163.                FAIL1;
  1164.          NEXT_INSTRUCTION;                  /* OK by default */
  1165.       case LIST:                            /* op1 is list, op2 is con/str */
  1166.       case NUM :                            /* op1 is num, op2 is con/str  */
  1167.          FAIL1;
  1168.          NEXT_INSTRUCTION;
  1169.    }  /* end nunify_with_con */
  1170.  
  1171. /*------------------------------------------------------------------*/
  1172. nunify_with_int:                            /* op1 is unknown,           */
  1173.                         /* op2 is integer (UNTAGGED) */
  1174.    switch (TAG(op1)) {
  1175.       case FREE:
  1176.      NDEREF(op1, nunify_with_int);
  1177.          FOLLOW(op1) = MAKEINT(op2);
  1178.          PUSHTRAIL(op1);
  1179.          NEXT_INSTRUCTION;
  1180.       case NUM:
  1181.      if (ISINTEGER(op1) && INTVAL(op1) == op2)
  1182.             NEXT_INSTRUCTION;
  1183.          else if (ISFLOAT(op1) && floatval(op1) == op2)
  1184.             NEXT_INSTRUCTION;
  1185.          /* fails by default */
  1186.       case CS  :
  1187.       case LIST:
  1188.          FAIL1;
  1189.          NEXT_INSTRUCTION;
  1190.    }  /* end nunify_with_int */
  1191.  
  1192. /*------------------------------------------------------------------*/
  1193. nunify_with_float:                      /* op1 is unknown,                   */
  1194.                                         /* op2 is tagged float in WAM format */
  1195.    switch (TAG(op1)) {
  1196.       case FREE:
  1197.          NDEREF(op1, nunify_with_float);
  1198.          FOLLOW(op1) = op2;
  1199.          PUSHTRAIL(op1);
  1200.          NEXT_INSTRUCTION;
  1201.       case NUM:
  1202.          if (NUMVAL(op1) == floatval(op2))
  1203.             NEXT_INSTRUCTION;
  1204.          /* fails by default */
  1205.       case CS  :
  1206.       case LIST:
  1207.          FAIL1;
  1208.          NEXT_INSTRUCTION;
  1209.    }  /* end nunify_with_float */
  1210.  
  1211. /*------------------------------------------------------------------*/
  1212. nunify_with_nil:                         /* op1 is unknown,         */
  1213.                                          /* op2 is nil_sym (TAGGED) */
  1214.    switch (TAG(op1)) {
  1215.       case FREE:
  1216.      NDEREF(op1, nunify_with_nil);
  1217.          FOLLOW(op1) = nil_sym;
  1218.          PUSHTRAIL(op1);
  1219.          NEXT_INSTRUCTION;
  1220.       case CS:
  1221.      if (op1 == nil_sym)
  1222.             NEXT_INSTRUCTION;
  1223.          /* fails by default */
  1224.       case LIST:
  1225.       case NUM :
  1226.      FAIL1;
  1227.          NEXT_INSTRUCTION;
  1228.    }  /* end nunify_with_nil */
  1229.  
  1230. /*------------------------------------------------------------------*/
  1231. nunify_with_str:                         /* op1 is unknown, */
  1232.                                          /* op2 is psc_ptr  */
  1233.    switch (TAG(op1)) {
  1234.       case FREE:
  1235.      NDEREF(op1, nunify_with_str);
  1236.          FOLLOW(op1) = (LONG)hreg | CS_TAG;
  1237.          PUSHTRAIL(op1);
  1238.          NEW_HEAP_NODE(op2);
  1239.          flag = WRITEFLAG;
  1240.          NEXT_INSTRUCTION;
  1241.       case CS:
  1242.      UNTAG(op1);
  1243.          if (FOLLOW(op1) == op2) {
  1244.             flag = READFLAG;
  1245.             sreg = (LONG_PTR)op1 + 1;
  1246.             NEXT_INSTRUCTION;
  1247.          }
  1248.          /* fails by default */
  1249.       case LIST:
  1250.       case NUM :
  1251.      FAIL1;
  1252.          NEXT_INSTRUCTION;
  1253.    }  /* end nunify_with_str */
  1254.  
  1255. /*------------------------------------------------------------------*/
  1256. nunify_with_list_sym:                    /* op1 is unknown, */
  1257.                                          /* op2 is list     */
  1258.    switch (TAG(op1)) {
  1259.       case FREE:
  1260.      NDEREF(op1, nunify_with_list_sym);
  1261.          FOLLOW(op1) = (LONG)hreg | LIST_TAG;
  1262.          PUSHTRAIL(op1);
  1263.          flag = WRITEFLAG;
  1264.          NEXT_INSTRUCTION;
  1265.       case CS :
  1266.       case NUM:
  1267.      FAIL1;
  1268.          NEXT_INSTRUCTION;
  1269.       case LIST:
  1270.      sreg = (LONG_PTR)UNTAGGED(op1);
  1271.          flag = READFLAG;
  1272.          NEXT_INSTRUCTION;
  1273.    }  /* end nunify_with_list_sym */
  1274.  
  1275. /*------------------------------------------------------------------*/
  1276. nbldval:
  1277.  
  1278.    if (ISVAR(op1)) {
  1279.       NDEREF(op1, nbldval);
  1280.       FOLLOW(op1) = (LONG)hreg;
  1281.       PUSHTRAIL(op1);
  1282.       NEW_HEAP_FREE;
  1283.    } else NEW_HEAP_NODE(op1);
  1284.    NEXT_INSTRUCTION;    /* end of nbldval */
  1285.  
  1286. /*------------------------------------------------------------------*/
  1287. subtryme:
  1288.  
  1289.    tempbreg = (breg < lereg) ? breg : lereg - ENV_SIZE(cpreg);
  1290.  
  1291.    /* check for heap overflow */
  1292.    if (tempbreg - op1 - 6 < hreg) {
  1293.       ereg = lereg;
  1294.       /* garbage_collection("subtryme"); */ /* GC buggy! */
  1295.       if (tempbreg - op1 - 6 < hreg) {   /* still too full */
  1296.      quit("Heap overflow\n");
  1297. /*
  1298.      if (!overflow_f) {
  1299.             overflow_f = 1;
  1300.             lpcreg = (WORD_PTR)set_intercode(2);
  1301.             NEXT_INSTRUCTION;
  1302.          }
  1303. */
  1304.       }
  1305.    }
  1306.  
  1307.    for (i = 1; i <= op1; i++)
  1308.       *tempbreg-- = rreg[i];
  1309.  
  1310.    *tempbreg-- = (LONG)lereg;
  1311.    *tempbreg-- = (LONG)cpreg;
  1312.    *tempbreg-- = (LONG)trreg;
  1313.    *tempbreg-- = (LONG)hreg;
  1314.    *tempbreg-- = (LONG)breg;
  1315.    *tempbreg-- = op2;               /* next process' entry pt. */
  1316.    breg  = tempbreg;                /* next free space was b+6 */
  1317.    hbreg = hreg;
  1318.  
  1319.    NEXT_INSTRUCTION;    /* end of subtryme */
  1320.  
  1321. /*------------------------------------------------------------------*/
  1322. rerestore:
  1323.  
  1324.    tempbreg = breg + 3;
  1325.    hreg  = (LONG_PTR)*tempbreg;
  1326.    oldtr = (LONG_PTR)*(++tempbreg);
  1327.    while (trreg != oldtr) {
  1328.       top = (LONG_PTR)*(++trreg);
  1329.       *(LONG_PTR *)top = top;
  1330.    }
  1331.    cpreg  = (LONG_PTR)*(++tempbreg);
  1332.    lereg = (LONG_PTR)*(++tempbreg);
  1333.    for (i = op1; i >= 1; i--)
  1334.       rreg[i] = *(++tempbreg);
  1335.    NEXT_INSTRUCTION;    /* end of rerestore */
  1336.  
  1337. /*------------------------------------------------------------------*/
  1338. trrestore:
  1339.  
  1340.    tempbreg = breg + 3;
  1341.    hreg  = (LONG_PTR)*(tempbreg);
  1342.    oldtr = (LONG_PTR)*(++tempbreg);
  1343.    while (trreg != oldtr) {
  1344.       top = (LONG_PTR)*(++trreg);
  1345.       *(LONG_PTR *)top = top;
  1346.    }
  1347.    cpreg  = (LONG_PTR)*(++tempbreg);
  1348.    lereg = (LONG_PTR)*(++tempbreg);
  1349.    for (i = op1; i >= 1; i--)
  1350.       rreg[i] = *(++tempbreg);
  1351.  
  1352.    breg  = (LONG_PTR)*(breg + 2);
  1353.    hbreg = (LONG_PTR)*(breg + 3);
  1354.    NEXT_INSTRUCTION;    /* end of trrestore */
  1355.  
  1356. /*------------------------------------------------------------------*/
  1357. call_sub:                         /* (psc) */
  1358.  
  1359.    /* check for potential heap overflow */
  1360.    if (lereg < hreg + 100) {
  1361.       ereg = lereg;
  1362.       /* garbage_collection("call_sub"); */ /* GC buggy! */
  1363.       if (lereg < hreg + 100)     /* still too full */
  1364.      quit("Heap overflow\n");
  1365.    }
  1366.  
  1367.    if (interrupt_code > 0) {      /* combine with call_intercept check! */
  1368.       build_call(psc_ptr);
  1369.       lpcreg = (WORD_PTR)set_intercode(1);
  1370.       interrupt_code = 0;
  1371.       arm_intercept();
  1372.       psc_ptr = interrupt_psc;
  1373.    } else if (IS_PRED(psc_ptr) || IS_DYNA(psc_ptr)) {
  1374.       lpcreg = (WORD_PTR)GET_EP(psc_ptr);
  1375.    } else if (IS_BUFF(psc_ptr)) {
  1376.       lpcreg = (WORD_PTR)GET_NAME(psc_ptr) + 1;
  1377.    } else {
  1378.       build_call(psc_ptr);
  1379.       lpcreg = (WORD_PTR)set_intercode(0);
  1380.       psc_ptr = interrupt_psc;
  1381.    }
  1382.  
  1383.    if (call_intercept) {
  1384.       if (hitrace) {
  1385.          printf("call/exec: ");
  1386.          writepname(stdout, GET_NAME(psc_ptr), GET_LENGTH(psc_ptr));
  1387.          printf("/%d(", GET_ARITY(psc_ptr));
  1388.          for (i = 1; i <= GET_ARITY(psc_ptr); i++) {
  1389.             printterm(rreg[i], CAR);
  1390.             if (i < GET_ARITY(psc_ptr))
  1391.                printf(" ");
  1392.          }
  1393.          printf(")\n");
  1394.       }
  1395.       if (trace_sta) {
  1396.          if (hreg  > mheaptop ) mheaptop  = hreg;
  1397.          if (ereg  < mlocaltop) mlocaltop = ereg;
  1398.          if (breg  < mlocaltop) mlocaltop = breg;
  1399.          if (trreg < mtrailtop) mtrailtop = trreg;
  1400.       }
  1401.    }
  1402.  
  1403.    NEXT_INSTRUCTION;    /* end of call_sub */
  1404.  
  1405. }  /* end of main */
  1406.