home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Guide / c-cplusplus-interactive-guide.iso / c_ref / csource5 / 335_01 / as2650.y < prev    next >
Encoding:
Lex Description  |  1990-12-03  |  39.6 KB  |  1,634 lines
  1. %{
  2.  
  3. /*
  4. HEADER:     ;
  5. TITLE:         Frankenstein Cross Assemblers;
  6. VERSION:     2.0;
  7. DESCRIPTION: "    Reconfigurable Cross-assembler producing Intel (TM)
  8.         Hex format object records.  ";
  9. KEYWORDS:     cross-assemblers, 1805, 2650, 6301, 6502, 6805, 6809, 
  10.         6811, tms7000, 8048, 8051, 8096, z8, z80;
  11. SYSTEM:     UNIX, MS-Dos ;
  12. FILENAME:     as2650.y;
  13. WARNINGS:     "This software is in the public domain.  
  14.         Any prior copyright claims are relinquished.  
  15.  
  16.         This software is distributed with no warranty whatever.  
  17.         The author takes no responsibility for the consequences 
  18.         of its use.
  19.  
  20.         Yacc (or Bison) required to compile."  ;
  21. SEE-ALSO:     as2650.doc,frasmain.c;    
  22. AUTHORS:     Mark Zenier;
  23. COMPILERS:     Microport Sys V/AT, ATT Yacc, Turbo C V1.5, Bison (CUG disk 285)
  24.         (previous versions Xenix, Unisoft 68000 Version 7, Sun 3);
  25. */
  26. /* 2650 instruction generation file, standard syntax */
  27. /* November 17, 1990 */
  28.  
  29. /*
  30.     description    frame work parser description for framework cross
  31.             assemblers
  32.     history        February 2, 1988
  33.             September 11, 1990 - merge table definition
  34.             September 12, 1990 - short file names
  35.             September 14, 1990 - short variable names
  36.             September 17, 1990 - use yylex as external
  37. */
  38. #include <stdio.h>
  39. #include "frasmdat.h"
  40. #include "fragcon.h"
  41.  
  42. #define yylex lexintercept
  43.  
  44.     /* selectors for register */
  45.     /* 0000 0000 0000 xxxx */
  46. #define REGMASK    0xf 
  47. #define REG0    0x1
  48. #define REG1    0x2
  49. #define REG2    0x4
  50. #define REG3    0x8
  51.     /* selectors for conditions */
  52.     /* 0000 0000 xxxx 0000 */
  53. #define CONDMASK    0xf0
  54. #define COND0    0x10
  55. #define COND1    0x20
  56. #define COND2    0x40
  57. #define COND3 0x80
  58.  
  59. #define PAGEBITS 0x6000
  60. #define ST_INH 0x1
  61. #define ST_EXP 0x2
  62. #define ST_INDIR 0x4
  63. #define ST_REG 0x8
  64. #define ST_REGCOMMA 0x10
  65. #define ST_REGEXP 0x20
  66. #define ST_REGINDIR 0x40
  67. #define ST_COND 0x80
  68. #define ST_CONDEXP 0x100
  69. #define ST_CONDINDIR 0x200
  70. #define ST_BINDEX 0x400
  71. #define ST_BINDIRX 0x800
  72. #define    API_ABS    0
  73. #define    API_INC    2
  74. #define    API_DEC    4
  75. #define    API_IND    6
  76. #define    API_IABS    8
  77. #define    API_IINC    0xa
  78. #define    API_IDEC    0xc
  79. #define    API_IIND    0xe
  80. #define ST_ABSOLUTE 0x1
  81. #define ST_INDEX 0x2
  82. #define ST_INCINDEX 0x4
  83. #define ST_DECINDEX 0x8
  84. #define ST_AREGINDIR 0x10
  85. #define ST_INDIRX 0x20
  86. #define ST_INCINDIRX 0x40
  87. #define ST_DECINDIRX 0x80
  88.     
  89.     static int    regsel[4] = {REG0, REG1, REG2, REG3};
  90.     static int    condsel[4] = {COND0, COND1, COND2, COND3};
  91.     static int    prevpage;
  92.     static char    genbdef[] = "[1=];";
  93.     static char    genwdef[] = "[1=]x"; /* x for normal, y for byte rev */
  94.     char ignosyn[] = "[Xinvalid syntax for instruction";
  95.     char ignosel[] = "[Xinvalid operands";
  96.  
  97.     long    labelloc;
  98.     static int satsub;
  99.     int    ifstkpt = 0;
  100.     int    fraifskip = FALSE;
  101.  
  102.     struct symel * endsymbol = SYMNULL;
  103.  
  104. %}
  105. %union {
  106.     int    intv;
  107.     long     longv;
  108.     char    *strng;
  109.     struct symel *symb;
  110. }
  111.  
  112. %token <intv> REGISTER 
  113. %token <intv> CONDITION 
  114. %token <intv> KOC_BDEF
  115. %token <intv> KOC_ELSE
  116. %token <intv> KOC_END
  117. %token <intv> KOC_ENDI
  118. %token <intv> KOC_EQU
  119. %token <intv> KOC_IF
  120. %token <intv> KOC_INCLUDE
  121. %token <intv> KOC_ORG
  122. %token <intv> KOC_RESM
  123. %token <intv> KOC_SDEF
  124. %token <intv> KOC_SET
  125. %token <intv> KOC_WDEF
  126. %token <intv> KOC_CHSET
  127. %token <intv> KOC_CHDEF
  128. %token <intv> KOC_CHUSE
  129. %token <intv> KOC_ACON
  130. %token <intv> KOC_opcode
  131. %token <intv> KOC_indexabs
  132.  
  133. %token <longv> CONSTANT
  134. %token EOL
  135. %token KEOP_AND
  136. %token KEOP_DEFINED
  137. %token KEOP_EQ
  138. %token KEOP_GE
  139. %token KEOP_GT
  140. %token KEOP_HIGH
  141. %token KEOP_LE
  142. %token KEOP_LOW
  143. %token KEOP_LT
  144. %token KEOP_MOD
  145. %token KEOP_MUN
  146. %token KEOP_NE
  147. %token KEOP_NOT
  148. %token KEOP_OR
  149. %token KEOP_SHL
  150. %token KEOP_SHR
  151. %token KEOP_XOR
  152. %token KEOP_locctr
  153. %token <symb> LABEL
  154. %token <strng> STRING
  155. %token <symb> SYMBOL
  156.  
  157. %token KTK_invalid
  158.  
  159. %right    KEOP_HIGH KEOP_LOW
  160. %left    KEOP_OR KEOP_XOR
  161. %left    KEOP_AND
  162. %right    KEOP_NOT
  163. %nonassoc    KEOP_GT KEOP_GE KEOP_LE KEOP_LT KEOP_NE KEOP_EQ
  164. %left    '+' '-'
  165. %left    '*' '/' KEOP_MOD KEOP_SHL KEOP_SHR
  166. %right    KEOP_MUN
  167.  
  168.  
  169. %type <intv> expr exprlist stringlist
  170.  
  171. %start file
  172.  
  173. %%
  174.  
  175. file    :    file allline
  176.     |    allline
  177.     ;
  178.  
  179. allline    :     line EOL
  180.             {
  181.                 clrexpr();
  182.             }
  183.     |    EOL
  184.     |    error EOL
  185.             {
  186.                 clrexpr();
  187.                 yyerrok;
  188.             }
  189.     ;
  190.  
  191. line    :    LABEL KOC_END 
  192.             {
  193.                 endsymbol = $1;
  194.                 nextreadact = Nra_end;
  195.             }
  196.     |          KOC_END 
  197.             {
  198.                 nextreadact = Nra_end;
  199.             }
  200.     |    KOC_INCLUDE STRING
  201.             {
  202.         if(nextfstk >= FILESTKDPTH)
  203.         {
  204.             fraerror("include file nesting limit exceeded");
  205.         }
  206.         else
  207.         {
  208.             infilestk[nextfstk].fnm = savestring($2,strlen($2));
  209.             if( (infilestk[nextfstk].fpt = fopen($2,"r"))
  210.                 ==(FILE *)NULL )
  211.             {
  212.                 fraerror("cannot open include file");
  213.             }
  214.             else
  215.             {
  216.                 nextreadact = Nra_new;
  217.             }
  218.         }
  219.             }
  220.     |    LABEL KOC_EQU expr 
  221.             {
  222.                 if($1 -> seg == SSG_UNDEF)
  223.                 {
  224.                     pevalexpr(0, $3);
  225.                     if(evalr[0].seg == SSG_ABS)
  226.                     {
  227.                         $1 -> seg = SSG_EQU;
  228.                         $1 -> value = evalr[0].value;
  229.                         prtequvalue("C: 0x%lx\n",
  230.                             evalr[0].value);
  231.                     }
  232.                     else
  233.                     {
  234.                         fraerror(
  235.                     "noncomputable expression for EQU");
  236.                     }
  237.                 }
  238.                 else
  239.                 {
  240.                     fraerror(
  241.                 "cannot change symbol value with EQU");
  242.                 }
  243.             }
  244.     |    LABEL KOC_SET expr 
  245.             {
  246.                 if($1 -> seg == SSG_UNDEF
  247.                    || $1 -> seg == SSG_SET)
  248.                 {
  249.                     pevalexpr(0, $3);
  250.                     if(evalr[0].seg == SSG_ABS)
  251.                     {
  252.                         $1 -> seg = SSG_SET;
  253.                         $1 -> value = evalr[0].value;
  254.                         prtequvalue("C: 0x%lx\n",
  255.                             evalr[0].value);
  256.                     }
  257.                     else
  258.                     {
  259.                         fraerror(
  260.                     "noncomputable expression for SET");
  261.                     }
  262.                 }
  263.                 else
  264.                 {
  265.                     fraerror(
  266.                 "cannot change symbol value with SET");
  267.                 }
  268.             }
  269.     |    KOC_IF expr 
  270.             {
  271.         if((++ifstkpt) < IFSTKDEPTH)
  272.         {
  273.             pevalexpr(0, $2);
  274.             if(evalr[0].seg == SSG_ABS)
  275.             {
  276.                 if(evalr[0].value != 0)
  277.                 {
  278.                     elseifstk[ifstkpt] = If_Skip;
  279.                     endifstk[ifstkpt] = If_Active;
  280.                 }
  281.                 else
  282.                 {
  283.                     fraifskip = TRUE;
  284.                     elseifstk[ifstkpt] = If_Active;
  285.                     endifstk[ifstkpt] = If_Active;
  286.                 }
  287.             }
  288.             else
  289.             {
  290.                 fraifskip = TRUE;
  291.                 elseifstk[ifstkpt] = If_Active;
  292.                 endifstk[ifstkpt] = If_Active;
  293.             }
  294.         }
  295.         else
  296.         {
  297.             fraerror("IF stack overflow");
  298.         }
  299.             }
  300.                         
  301.     |    KOC_IF 
  302.             {
  303.         if(fraifskip) 
  304.         {
  305.             if((++ifstkpt) < IFSTKDEPTH)
  306.             {
  307.                     elseifstk[ifstkpt] = If_Skip;
  308.                     endifstk[ifstkpt] = If_Skip;
  309.             }
  310.             else
  311.             {
  312.                 fraerror("IF stack overflow");
  313.             }
  314.         }
  315.         else
  316.         {
  317.             yyerror("syntax error");
  318.             YYERROR;
  319.         }
  320.                 }
  321.                         
  322.     |    KOC_ELSE 
  323.             {
  324.                 switch(elseifstk[ifstkpt])
  325.                 {
  326.                 case If_Active:
  327.                     fraifskip = FALSE;
  328.                     break;
  329.                 
  330.                 case If_Skip:
  331.                     fraifskip = TRUE;
  332.                     break;
  333.                 
  334.                 case If_Err:
  335.                     fraerror("ELSE with no matching if");
  336.                     break;
  337.                 }
  338.             }
  339.  
  340.     |    KOC_ENDI 
  341.             {
  342.                 switch(endifstk[ifstkpt])
  343.                 {
  344.                 case If_Active:
  345.                     fraifskip = FALSE;
  346.                     ifstkpt--;
  347.                     break;
  348.                 
  349.                 case If_Skip:
  350.                     fraifskip = TRUE;
  351.                     ifstkpt--;
  352.                     break;
  353.                 
  354.                 case If_Err:
  355.                     fraerror("ENDI with no matching if");
  356.                     break;
  357.                 }
  358.             }
  359.     |    LABEL KOC_ORG expr 
  360.             {
  361.                 pevalexpr(0, $3);
  362.                 if(evalr[0].seg == SSG_ABS)
  363.                 {
  364.                     locctr = labelloc = evalr[0].value;
  365.                     if($1 -> seg == SSG_UNDEF)
  366.                     {
  367.                         $1 -> seg = SSG_ABS;
  368.                         $1 -> value = labelloc;
  369.                     }
  370.                     else
  371.                         fraerror(
  372.                         "multiple definition of label");
  373.                     prtequvalue("C: 0x%lx\n",
  374.                         evalr[0].value);
  375.                 }
  376.                 else
  377.                 {
  378.                     fraerror(
  379.                      "noncomputable expression for ORG");
  380.                 }
  381.             }
  382.     |          KOC_ORG expr 
  383.             {
  384.                 pevalexpr(0, $2);
  385.                 if(evalr[0].seg == SSG_ABS)
  386.                 {
  387.                     locctr = labelloc = evalr[0].value;
  388.                     prtequvalue("C: 0x%lx\n",
  389.                         evalr[0].value);
  390.                 }
  391.                 else
  392.                 {
  393.                     fraerror(
  394.                      "noncomputable expression for ORG");
  395.                 }
  396.             }
  397.     |    LABEL KOC_CHSET
  398.             {
  399.                 if($1 -> seg == SSG_UNDEF)
  400.                 {
  401.                     $1 -> seg = SSG_EQU;
  402.                     if( ($1->value = chtcreate()) <= 0)
  403.                     {
  404.         fraerror( "cannot create character translation table");
  405.                     }
  406.                     prtequvalue("C: 0x%lx\n", $1 -> value);
  407.                 }
  408.                 else
  409.                 {
  410.             fraerror( "multiple definition of label");
  411.                 }
  412.             }
  413.     |        KOC_CHUSE
  414.             {
  415.                 chtcpoint = (int *) NULL;
  416.                 prtequvalue("C: 0x%lx\n", 0L);
  417.             }
  418.     |        KOC_CHUSE expr
  419.             {
  420.                 pevalexpr(0, $2);
  421.                 if( evalr[0].seg == SSG_ABS)
  422.                 {
  423.                     if( evalr[0].value == 0)
  424.                     {
  425.                         chtcpoint = (int *)NULL;
  426.                         prtequvalue("C: 0x%lx\n", 0L);
  427.                     }
  428.                     else if(evalr[0].value < chtnxalph)
  429.                     {
  430.                 chtcpoint = chtatab[evalr[0].value];
  431.                 prtequvalue("C: 0x%lx\n", evalr[0].value);
  432.                     }
  433.                     else
  434.                     {
  435.             fraerror("nonexistent character translation table");
  436.                     }
  437.                 }
  438.                 else
  439.                 {
  440.                     fraerror("noncomputable expression");
  441.                 }
  442.             }
  443.     |        KOC_CHDEF STRING ',' exprlist
  444.             {
  445.         int findrv, numret, *charaddr;
  446.         char *sourcestr = $2, *before;
  447.  
  448.         if(chtnpoint != (int *)NULL)
  449.         {
  450.             for(satsub = 0; satsub < $4; satsub++)
  451.             {
  452.                 before = sourcestr;
  453.  
  454.                 pevalexpr(0, exprlist[satsub]);
  455.                 findrv = chtcfind(chtnpoint, &sourcestr,
  456.                         &charaddr, &numret);
  457.                 if(findrv == CF_END)
  458.                 {
  459.             fraerror("more expressions than characters");
  460.                     break;
  461.                 }
  462.  
  463.                 if(evalr[0].seg == SSG_ABS)
  464.                 {
  465.                     switch(findrv)
  466.                     {
  467.                     case CF_UNDEF:
  468.                         {
  469.                 if(evalr[0].value < 0 ||
  470.                     evalr[0].value > 255)
  471.                 {
  472.             frawarn("character translation value truncated");
  473.                 }
  474.                 *charaddr = evalr[0].value & 0xff;
  475.                 prtequvalue("C: 0x%lx\n", evalr[0].value);
  476.                         }
  477.                         break;
  478.  
  479.                     case CF_INVALID:
  480.                     case CF_NUMBER:
  481.                 fracherror("invalid character to define", 
  482.                     before, sourcestr);
  483.                         break;
  484.  
  485.                     case CF_CHAR:
  486.                 fracherror("character already defined", 
  487.                     before, sourcestr);
  488.                         break;
  489.                     }
  490.                 }
  491.                 else
  492.                 {
  493.                     fraerror("noncomputable expression");
  494.                 }
  495.             }
  496.  
  497.             if( *sourcestr != '\0')
  498.             {
  499.                 fraerror("more characters than expressions");
  500.             }
  501.         }
  502.         else
  503.         {
  504.             fraerror("no CHARSET statement active");
  505.         }
  506.             
  507.             }
  508.     |    LABEL 
  509.             {
  510.             if($1 -> seg == SSG_UNDEF)
  511.             {
  512.                 $1 -> seg = SSG_ABS;
  513.                 $1 -> value = labelloc;
  514.                 prtequvalue("C: 0x%lx\n", labelloc);
  515.  
  516.             }
  517.             else
  518.                 fraerror(
  519.                 "multiple definition of label");
  520.             }
  521.     |    labeledline
  522.     ;
  523.  
  524. labeledline :    LABEL genline
  525.             {
  526.             if($1 -> seg == SSG_UNDEF)
  527.             {
  528.                 $1 -> seg = SSG_ABS;
  529.                 $1 -> value = labelloc;
  530.             }
  531.             else
  532.                 fraerror(
  533.                 "multiple definition of label");
  534.             labelloc = locctr;
  535.             }
  536.                 
  537.     |    genline
  538.             {
  539.                 labelloc = locctr;
  540.             }
  541.     ;
  542.  
  543. genline    :    KOC_BDEF    exprlist 
  544.             {
  545.                 genlocrec(currseg, labelloc);
  546.                 for( satsub = 0; satsub < $2; satsub++)
  547.                 {
  548.                     pevalexpr(1, exprlist[satsub]);
  549.                     locctr += geninstr(genbdef);
  550.                 }
  551.             }
  552.     |    KOC_SDEF stringlist 
  553.             {
  554.                 genlocrec(currseg, labelloc);
  555.                 for(satsub = 0; satsub < $2; satsub++)
  556.                 {
  557.                     locctr += genstring(stringlist[satsub]);
  558.                 }
  559.             }
  560.     |    KOC_WDEF exprlist 
  561.             {
  562.                 genlocrec(currseg, labelloc);
  563.                 for( satsub = 0; satsub < $2; satsub++)
  564.                 {
  565.                     pevalexpr(1, exprlist[satsub]);
  566.                     locctr += geninstr(genwdef);
  567.                 }
  568.             }    
  569.     |    KOC_RESM expr 
  570.             {
  571.                 pevalexpr(0, $2);
  572.                 if(evalr[0].seg == SSG_ABS)
  573.                 {
  574.                     locctr = labelloc + evalr[0].value;
  575.                     prtequvalue("C: 0x%lx\n", labelloc);
  576.                 }
  577.                 else
  578.                 {
  579.                     fraerror(
  580.                  "noncomputable result for RMB expression");
  581.                 }
  582.             }
  583.     ;
  584.  
  585. exprlist :    exprlist ',' expr
  586.             {
  587.                 exprlist[nextexprs ++ ] = $3;
  588.                 $$ = nextexprs;
  589.             }
  590.     |    expr
  591.             {
  592.                 nextexprs = 0;
  593.                 exprlist[nextexprs ++ ] = $1;
  594.                 $$ = nextexprs;
  595.             }
  596.     ;
  597.  
  598. stringlist :    stringlist ',' STRING
  599.             {
  600.                 stringlist[nextstrs ++ ] = $3;
  601.                 $$ = nextstrs;
  602.             }
  603.     |    STRING
  604.             {
  605.                 nextstrs = 0;
  606.                 stringlist[nextstrs ++ ] = $1;
  607.                 $$ = nextstrs;
  608.             }
  609.     ;
  610.  
  611.  
  612. genline :    KOC_ACON exprlist
  613.         {
  614.             genlocrec(currseg, labelloc);
  615.             for( satsub = 0; satsub < $2; satsub++)
  616.             {
  617.                 pevalexpr(1, exprlist[satsub]);
  618.                 locctr += geninstr("[1=].fIx");
  619.             }
  620.         }    
  621. genline : KOC_opcode 
  622.         {
  623.         genlocrec(currseg, labelloc);
  624.         prevpage = (locctr & PAGEBITS);
  625.         if(prevpage == locctr)
  626.             frawarn("Page Boundary");
  627.         locctr += geninstr(findgen($1, ST_INH, 0));
  628.         }
  629.     ;
  630. genline : KOC_opcode  expr
  631.         {
  632.         genlocrec(currseg, labelloc);
  633.         prevpage = (locctr & PAGEBITS);
  634.         if(prevpage == locctr)
  635.             frawarn("Page Boundary");
  636.         pevalexpr(1, $2);
  637.         locctr += geninstr(findgen($1, ST_EXP, 0));
  638.         if(((locctr -1) & PAGEBITS) != prevpage)
  639.             fraerror("instruction crosses page boundry");
  640.         }
  641.     ;
  642. genline : KOC_opcode  '*' expr 
  643.         {
  644.         genlocrec(currseg, labelloc);
  645.         prevpage = (locctr & PAGEBITS);
  646.         if(prevpage == locctr)
  647.             frawarn("Page Boundary");
  648.         pevalexpr(1, $3);
  649.         locctr += geninstr(findgen($1, ST_INDIR, 0));
  650.         if(((locctr -1) & PAGEBITS) != prevpage)
  651.             fraerror("instruction crosses page boundry");
  652.         }
  653.     ;
  654. genline : KOC_opcode  REGISTER
  655.         {
  656.         genlocrec(currseg, labelloc);
  657.         prevpage = (locctr & PAGEBITS);
  658.         if(prevpage == locctr)
  659.             frawarn("Page Boundary");
  660.         evalr[1].value = $2;
  661.         locctr += geninstr(findgen($1, ST_REG, regsel[$2] ));
  662.         }
  663.     ;
  664. genline : KOC_opcode  ',' REGISTER
  665.         {
  666.         genlocrec(currseg, labelloc);
  667.         prevpage = (locctr & PAGEBITS);
  668.         if(prevpage == locctr)
  669.             frawarn("Page Boundary");
  670.         evalr[1].value = $3;
  671.         locctr += geninstr(findgen($1, ST_REGCOMMA, regsel[$3] ));
  672.         }
  673.     ;
  674. genline : KOC_opcode  ',' REGISTER expr
  675.         {
  676.         genlocrec(currseg, labelloc);
  677.         prevpage = (locctr & PAGEBITS);
  678.         if(prevpage == locctr)
  679.             frawarn("Page Boundary");
  680.         evalr[1].value = $3;
  681.         pevalexpr(2, $4);
  682.         locctr += geninstr(findgen($1, ST_REGEXP, regsel[$3] ));
  683.         if(((locctr -1) & PAGEBITS) != prevpage)
  684.             fraerror("instruction crosses page boundry");
  685.         }
  686.     ;
  687. genline : KOC_opcode  ',' REGISTER '*' expr 
  688.         {
  689.         genlocrec(currseg, labelloc);
  690.         prevpage = (locctr & PAGEBITS);
  691.         if(prevpage == locctr)
  692.             frawarn("Page Boundary");
  693.         evalr[1].value = $3;
  694.         pevalexpr(2, $5);
  695.         locctr += geninstr(findgen($1, ST_REGINDIR, regsel[$3] ));
  696.         if(((locctr -1) & PAGEBITS) != prevpage)
  697.             fraerror("instruction crosses page boundry");
  698.         }
  699.     ;
  700. genline : KOC_opcode  ',' CONDITION
  701.         {
  702.         genlocrec(currseg, labelloc);
  703.         prevpage = (locctr & PAGEBITS);
  704.         if(prevpage == locctr)
  705.             frawarn("Page Boundary");
  706.         evalr[1].value = $3;
  707.         locctr += geninstr(findgen($1, ST_COND, condsel[$3] ));
  708.         }
  709.     ;
  710. genline : KOC_opcode  ',' CONDITION expr
  711.         {
  712.         genlocrec(currseg, labelloc);
  713.         prevpage = (locctr & PAGEBITS);
  714.         if(prevpage == locctr)
  715.             frawarn("Page Boundary");
  716.         evalr[1].value = $3;
  717.         pevalexpr(2, $4);
  718.         locctr += geninstr(findgen($1, ST_CONDEXP, condsel[$3] ));
  719.         if(((locctr -1) & PAGEBITS) != prevpage)
  720.             fraerror("instruction crosses page boundry");
  721.         }
  722.     ;
  723. genline : KOC_opcode  ',' CONDITION '*' expr 
  724.         {
  725.         genlocrec(currseg, labelloc);
  726.         prevpage = (locctr & PAGEBITS);
  727.         if(prevpage == locctr)
  728.             frawarn("Page Boundary");
  729.         evalr[1].value = $3;
  730.         pevalexpr(2, $5);
  731.         locctr += geninstr(findgen($1, ST_CONDINDIR, condsel[$3] ));
  732.         if(((locctr -1) & PAGEBITS) != prevpage)
  733.             fraerror("instruction crosses page boundry");
  734.         }
  735.     ;
  736. genline : KOC_opcode  expr ',' REGISTER
  737.         {
  738.         genlocrec(currseg, labelloc);
  739.         prevpage = (locctr & PAGEBITS);
  740.         if(prevpage == locctr)
  741.             frawarn("Page Boundary");
  742.         evalr[1].value = $4;
  743.         pevalexpr(2, $2);
  744.         locctr += geninstr(findgen($1, ST_BINDEX, regsel[$4] ));
  745.         if(((locctr -1) & PAGEBITS) != prevpage)
  746.             fraerror("instruction crosses page boundry");
  747.         }
  748.     ;
  749. genline : KOC_opcode  '*' expr ',' REGISTER
  750.         {
  751.         genlocrec(currseg, labelloc);
  752.         prevpage = (locctr & PAGEBITS);
  753.         if(prevpage == locctr)
  754.             frawarn("Page Boundary");
  755.         evalr[1].value = $5;
  756.         pevalexpr(2, $3);
  757.         locctr += geninstr(findgen($1, ST_BINDIRX, regsel[$5] ));
  758.         if(((locctr -1) & PAGEBITS) != prevpage)
  759.             fraerror("instruction crosses page boundry");
  760.         }
  761.     ;
  762. genline : KOC_indexabs  ',' REGISTER  expr
  763.         {
  764.         genlocrec(currseg, labelloc);
  765.         prevpage = (locctr & PAGEBITS);
  766.         if(prevpage == locctr)
  767.             frawarn("Page Boundary");
  768.         evalr[1].value = $3;
  769.         pevalexpr(2, $4);
  770.         evalr[3].value = API_ABS;
  771.         locctr += geninstr(findgen($1, ST_ABSOLUTE, regsel[$3] ));
  772.         if(((locctr -1) & PAGEBITS) != prevpage)
  773.             fraerror("instruction crosses page boundry");
  774.         }
  775.     ;
  776. genline : KOC_indexabs  ',' REGISTER expr ',' REGISTER
  777.         {
  778.         genlocrec(currseg, labelloc);
  779.         prevpage = (locctr & PAGEBITS);
  780.         if(prevpage == locctr)
  781.             frawarn("Page Boundary");
  782.         if($3 != 0)
  783.             fraerror("destination register must be R0");
  784.         evalr[1].value = $6;
  785.         pevalexpr(2, $4);
  786.         evalr[3].value = API_IND;
  787.         locctr += geninstr(findgen($1, ST_ABSOLUTE, regsel[$6] ));
  788.         if(((locctr -1) & PAGEBITS) != prevpage)
  789.             fraerror("instruction crosses page boundry");
  790.         }
  791.     ;
  792. genline : KOC_indexabs  ',' REGISTER expr ',' REGISTER ',' '+'
  793.         {
  794.         genlocrec(currseg, labelloc);
  795.         prevpage = (locctr & PAGEBITS);
  796.         if(prevpage == locctr)
  797.             frawarn("Page Boundary");
  798.         if($3 != 0)
  799.             fraerror("destination register must be R0");
  800.         evalr[1].value = $6;
  801.         pevalexpr(2, $4);
  802.         evalr[3].value = API_INC;
  803.         locctr += geninstr(findgen($1, ST_ABSOLUTE, regsel[$6] ));
  804.         if(((locctr -1) & PAGEBITS) != prevpage)
  805.             fraerror("instruction crosses page boundry");
  806.         }
  807.     ;
  808. genline : KOC_indexabs  ',' REGISTER expr ',' REGISTER ',' '-' 
  809.         {
  810.         genlocrec(currseg, labelloc);
  811.         prevpage = (locctr & PAGEBITS);
  812.         if(prevpage == locctr)
  813.             frawarn("Page Boundary");
  814.         if($3 != 0)
  815.             fraerror("destination register must be R0");
  816.         evalr[1].value = $6;
  817.         pevalexpr(2, $4);
  818.         evalr[3].value = API_DEC;
  819.         locctr += geninstr(findgen($1, ST_ABSOLUTE, regsel[$6] ));
  820.         if(((locctr -1) & PAGEBITS) != prevpage)
  821.             fraerror("instruction crosses page boundry");
  822.         }
  823.     ;
  824. genline : KOC_indexabs  ',' REGISTER '*' expr 
  825.         {
  826.         genlocrec(currseg, labelloc);
  827.         prevpage = (locctr & PAGEBITS);
  828.         if(prevpage == locctr)
  829.             frawarn("Page Boundary");
  830.         evalr[1].value = $3;
  831.         pevalexpr(2, $5);
  832.         evalr[3].value = API_IABS;
  833.         locctr += geninstr(findgen($1, ST_ABSOLUTE, regsel[$3] ));
  834.         if(((locctr -1) & PAGEBITS) != prevpage)
  835.             fraerror("instruction crosses page boundry");
  836.         }
  837.     ;
  838. genline : KOC_indexabs  ',' REGISTER '*' expr ',' REGISTER
  839.         {
  840.         genlocrec(currseg, labelloc);
  841.         prevpage = (locctr & PAGEBITS);
  842.         if(prevpage == locctr)
  843.             frawarn("Page Boundary");
  844.         if($3 != 0)
  845.             fraerror("destination register must be R0");
  846.         evalr[1].value = $7;
  847.         pevalexpr(2, $5);
  848.         evalr[3].value = API_IIND;
  849.         locctr += geninstr(findgen($1, ST_ABSOLUTE, regsel[$7] ));
  850.         if(((locctr -1) & PAGEBITS) != prevpage)
  851.             fraerror("instruction crosses page boundry");
  852.         }
  853.     ;
  854. genline : KOC_indexabs  ',' REGISTER '*' expr ',' REGISTER ',' '+' 
  855.         {
  856.         genlocrec(currseg, labelloc);
  857.         prevpage = (locctr & PAGEBITS);
  858.         if(prevpage == locctr)
  859.             frawarn("Page Boundary");
  860.         if($3 != 0)
  861.             fraerror("destination register must be R0");
  862.         evalr[1].value = $7;
  863.         pevalexpr(2, $5);
  864.         evalr[3].value = API_IINC;
  865.         locctr += geninstr(findgen($1, ST_ABSOLUTE, regsel[$7] ));
  866.         if(((locctr -1) & PAGEBITS) != prevpage)
  867.             fraerror("instruction crosses page boundry");
  868.         }
  869.     ;
  870. genline : KOC_indexabs  ',' REGISTER '*' expr ',' REGISTER ',' '-' 
  871.         {
  872.         genlocrec(currseg, labelloc);
  873.         prevpage = (locctr & PAGEBITS);
  874.         if(prevpage == locctr)
  875.             frawarn("Page Boundary");
  876.         if($3 != 0)
  877.             fraerror("destination register must be R0");
  878.         evalr[1].value = $7;
  879.         pevalexpr(2, $5);
  880.         evalr[3].value = API_IDEC;
  881.         locctr += geninstr(findgen($1, ST_ABSOLUTE, regsel[$7] ));
  882.         if(((locctr -1) & PAGEBITS) != prevpage)
  883.             fraerror("instruction crosses page boundry");
  884.         }
  885.     ;
  886. expr    :    '+' expr %prec KEOP_MUN
  887.             {
  888.                 $$ = $2;
  889.             }
  890.     |    '-' expr %prec KEOP_MUN
  891.             {
  892.                 $$ = exprnode(PCCASE_UN,$2,IFC_NEG,0,0L,
  893.                     SYMNULL);
  894.             }
  895.     |    KEOP_NOT expr
  896.             {
  897.                 $$ = exprnode(PCCASE_UN,$2,IFC_NOT,0,0L,
  898.                     SYMNULL);
  899.             }
  900.     |    KEOP_HIGH expr
  901.             {
  902.                 $$ = exprnode(PCCASE_UN,$2,IFC_HIGH,0,0L,
  903.                     SYMNULL);
  904.             }
  905.     |    KEOP_LOW expr
  906.             {
  907.                 $$ = exprnode(PCCASE_UN,$2,IFC_LOW,0,0L,
  908.                     SYMNULL);
  909.             }
  910.     |    expr '*' expr
  911.             {
  912.                 $$ = exprnode(PCCASE_BIN,$1,IFC_MUL,$3,0L,
  913.                     SYMNULL);
  914.             }
  915.     |    expr '/' expr
  916.             {
  917.                 $$ = exprnode(PCCASE_BIN,$1,IFC_DIV,$3,0L,
  918.                     SYMNULL);
  919.             }
  920.     |    expr '+' expr
  921.             {
  922.                 $$ = exprnode(PCCASE_BIN,$1,IFC_ADD,$3,0L,
  923.                     SYMNULL);
  924.             }
  925.     |    expr '-' expr
  926.             {
  927.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SUB,$3,0L,
  928.                     SYMNULL);
  929.             }
  930.     |    expr KEOP_MOD expr
  931.             {
  932.                 $$ = exprnode(PCCASE_BIN,$1,IFC_MOD,$3,0L,
  933.                     SYMNULL);
  934.             }
  935.     |    expr KEOP_SHL expr
  936.             {
  937.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SHL,$3,0L,
  938.                     SYMNULL);
  939.             }
  940.     |    expr KEOP_SHR expr
  941.             {
  942.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SHR,$3,0L,
  943.                     SYMNULL);
  944.             }
  945.     |    expr KEOP_GT expr
  946.             {
  947.                 $$ = exprnode(PCCASE_BIN,$1,IFC_GT,$3,0L,
  948.                     SYMNULL);
  949.             }
  950.     |    expr KEOP_GE expr
  951.             {
  952.                 $$ = exprnode(PCCASE_BIN,$1,IFC_GE,$3,0L,
  953.                     SYMNULL);
  954.             }
  955.     |    expr KEOP_LT expr
  956.             {
  957.                 $$ = exprnode(PCCASE_BIN,$1,IFC_LT,$3,0L,
  958.                     SYMNULL);
  959.             }
  960.     |    expr KEOP_LE expr
  961.             {
  962.                 $$ = exprnode(PCCASE_BIN,$1,IFC_LE,$3,0L,
  963.                     SYMNULL);
  964.             }
  965.     |    expr KEOP_NE expr
  966.             {
  967.                 $$ = exprnode(PCCASE_BIN,$1,IFC_NE,$3,0L,
  968.                     SYMNULL);
  969.             }
  970.     |    expr KEOP_EQ expr
  971.             {
  972.                 $$ = exprnode(PCCASE_BIN,$1,IFC_EQ,$3,0L,
  973.                     SYMNULL);
  974.             }
  975.     |    expr KEOP_AND expr
  976.             {
  977.                 $$ = exprnode(PCCASE_BIN,$1,IFC_AND,$3,0L,
  978.                     SYMNULL);
  979.             }
  980.     |    expr KEOP_OR expr
  981.             {
  982.                 $$ = exprnode(PCCASE_BIN,$1,IFC_OR,$3,0L,
  983.                     SYMNULL);
  984.             }
  985.     |    expr KEOP_XOR expr
  986.             {
  987.                 $$ = exprnode(PCCASE_BIN,$1,IFC_XOR,$3,0L,
  988.                     SYMNULL);
  989.             }
  990.     |    KEOP_DEFINED SYMBOL
  991.             {
  992.                 $$ = exprnode(PCCASE_DEF,0,IGP_DEFINED,0,0L,$2);
  993.             }
  994.     |    SYMBOL
  995.             {
  996.                 $$ = exprnode(PCCASE_SYMB,0,IFC_SYMB,0,0L,$1);
  997.             }
  998.     |    '$'
  999.             {
  1000.                 $$ = exprnode(PCCASE_PROGC,0,IFC_PROGCTR,0,
  1001.                     labelloc, SYMNULL);
  1002.             }
  1003.     |    CONSTANT
  1004.             {
  1005.                 $$ = exprnode(PCCASE_CONS,0,IGP_CONSTANT,0,$1,
  1006.                     SYMNULL);
  1007.             }
  1008.     |    STRING
  1009.             {
  1010.                 char *sourcestr = $1;
  1011.                 long accval = 0;
  1012.  
  1013.                 if(strlen($1) > 0)
  1014.                 {
  1015.                     accval = chtran(&sourcestr);
  1016.                     if(*sourcestr != '\0')
  1017.                     {
  1018.                         accval = (accval << 8) +
  1019.                             chtran(&sourcestr);
  1020.                     }
  1021.  
  1022.                     if( *sourcestr != '\0')
  1023.                     {
  1024.     frawarn("string constant in expression more than 2 characters long");
  1025.                     }
  1026.                 }
  1027.                 $$ = exprnode(PCCASE_CONS, 0, IGP_CONSTANT, 0,
  1028.                     accval, SYMNULL);
  1029.             }
  1030.     |    '(' expr ')'
  1031.             {
  1032.                 $$ = $2;
  1033.             }
  1034.     ;
  1035.  
  1036.  
  1037.  
  1038. %%
  1039.  
  1040. lexintercept()
  1041. /*
  1042.     description    intercept the call to yylex (the lexical analyzer)
  1043.             and filter out all unnecessary tokens when skipping
  1044.             the input between a failed IF and its matching ENDI or
  1045.             ELSE
  1046.     globals     fraifskip    the enable flag
  1047. */
  1048. {
  1049. #undef yylex
  1050.  
  1051.     int rv;
  1052.  
  1053.     if(fraifskip)
  1054.     {
  1055.         for(;;)
  1056.         {
  1057.  
  1058.             switch(rv = yylex())
  1059.  
  1060.             {
  1061.             case 0:
  1062.             case KOC_END:
  1063.             case KOC_IF:
  1064.             case KOC_ELSE:
  1065.             case KOC_ENDI:
  1066.             case EOL:
  1067.                 return rv;
  1068.             default:
  1069.                 break;
  1070.             }
  1071.         }
  1072.     }
  1073.     else
  1074.         return yylex();
  1075. #define yylex lexintercept
  1076. }
  1077.  
  1078.  
  1079.  
  1080. setreserved()
  1081. {
  1082.  
  1083.     reservedsym("and", KEOP_AND, 0);
  1084.     reservedsym("defined", KEOP_DEFINED,0);
  1085.     reservedsym("ge", KEOP_GE, 0);
  1086.     reservedsym("high", KEOP_HIGH, 0);
  1087.     reservedsym("le", KEOP_LE, 0);
  1088.     reservedsym("low", KEOP_LOW, 0);
  1089.     reservedsym("mod", KEOP_MOD, 0);
  1090.     reservedsym("ne", KEOP_NE, 0);
  1091.     reservedsym("not", KEOP_NOT, 0);
  1092.     reservedsym("or", KEOP_OR, 0);
  1093.     reservedsym("shl", KEOP_SHL, 0);
  1094.     reservedsym("shr", KEOP_SHR, 0);
  1095.     reservedsym("xor", KEOP_XOR, 0);
  1096.     reservedsym("AND", KEOP_AND, 0);
  1097.     reservedsym("DEFINED", KEOP_DEFINED,0);
  1098.     reservedsym("GE", KEOP_GE, 0);
  1099.     reservedsym("HIGH", KEOP_HIGH, 0);
  1100.     reservedsym("LE", KEOP_LE, 0);
  1101.     reservedsym("LOW", KEOP_LOW, 0);
  1102.     reservedsym("MOD", KEOP_MOD, 0);
  1103.     reservedsym("NE", KEOP_NE, 0);
  1104.     reservedsym("NOT", KEOP_NOT, 0);
  1105.     reservedsym("OR", KEOP_OR, 0);
  1106.     reservedsym("SHL", KEOP_SHL, 0);
  1107.     reservedsym("SHR", KEOP_SHR, 0);
  1108.     reservedsym("XOR", KEOP_XOR, 0);
  1109.  
  1110.     /* machine specific token definitions */
  1111.     reservedsym("r0", REGISTER, 0);
  1112.     reservedsym("r1", REGISTER, 1);
  1113.     reservedsym("r2", REGISTER, 2);
  1114.     reservedsym("r3", REGISTER, 3);
  1115.     reservedsym("R0", REGISTER, 0);
  1116.     reservedsym("R1", REGISTER, 1);
  1117.     reservedsym("R2", REGISTER, 2);
  1118.     reservedsym("R3", REGISTER, 3);
  1119.     reservedsym("PLUS", CONDITION, 1);
  1120.     reservedsym("ZERO", CONDITION, 0); 
  1121.     reservedsym("MINUS", CONDITION, 2);
  1122.     reservedsym("GT", CONDITION, 1);
  1123.     reservedsym("EQ", CONDITION, 0); 
  1124.     reservedsym("LT", CONDITION, 2);
  1125.     reservedsym("UN", CONDITION, 3);
  1126.     reservedsym("ALWAYS", CONDITION, 3);
  1127.     reservedsym("plus", CONDITION, 1);
  1128.     reservedsym("zero", CONDITION, 0); 
  1129.     reservedsym("minus", CONDITION, 2);
  1130.     reservedsym("gt", CONDITION, 1);
  1131.     reservedsym("eq", CONDITION, 0); 
  1132.     reservedsym("lt", CONDITION, 2);
  1133.     reservedsym("un", CONDITION, 3);
  1134.     reservedsym("always", CONDITION, 3);
  1135.  
  1136. }
  1137.  
  1138. cpumatch(str)
  1139.     char *str;
  1140. {
  1141.     return TRUE;
  1142. }
  1143.  
  1144.  
  1145. /*
  1146.     description    Opcode and Instruction generation tables
  1147.     usage        Unix, framework crossassembler
  1148.     history        September 25, 1987
  1149. */
  1150.  
  1151. #define NUMOPCODE 102
  1152. #define NUMSYNBLK 105
  1153. #define NUMDIFFOP 128
  1154.  
  1155. int gnumopcode = NUMOPCODE;
  1156.  
  1157. int ophashlnk[NUMOPCODE];
  1158.  
  1159. struct opsym optab[NUMOPCODE+1]
  1160.     = {
  1161.     {"invalid", KOC_opcode, 2, 0 },
  1162.     {"ACON", KOC_ACON, 0, 0 },
  1163.     {"ADDA", KOC_indexabs, 1, 2 },
  1164.     {"ADDI", KOC_opcode, 1, 3 },
  1165.     {"ADDR", KOC_opcode, 2, 4 },
  1166.     {"ADDZ", KOC_opcode, 1, 6 },
  1167.     {"ANDA", KOC_indexabs, 1, 7 },
  1168.     {"ANDI", KOC_opcode, 1, 8 },
  1169.     {"ANDR", KOC_opcode, 2, 9 },
  1170.     {"ANDZ", KOC_opcode, 1, 11 },
  1171.     {"BCFA", KOC_opcode, 2, 12 },
  1172.     {"BCFR", KOC_opcode, 2, 14 },
  1173.     {"BCTA", KOC_opcode, 2, 16 },
  1174.     {"BCTR", KOC_opcode, 2, 18 },
  1175.     {"BDRA", KOC_opcode, 2, 20 },
  1176.     {"BDRR", KOC_opcode, 2, 22 },
  1177.     {"BIRA", KOC_opcode, 2, 24 },
  1178.     {"BIRR", KOC_opcode, 2, 26 },
  1179.     {"BRNA", KOC_opcode, 2, 28 },
  1180.     {"BRNR", KOC_opcode, 2, 30 },
  1181.     {"BSFA", KOC_opcode, 2, 32 },
  1182.     {"BSFR", KOC_opcode, 2, 34 },
  1183.     {"BSNA", KOC_opcode, 2, 36 },
  1184.     {"BSNR", KOC_opcode, 2, 38 },
  1185.     {"BSTA", KOC_opcode, 2, 40 },
  1186.     {"BSTR", KOC_opcode, 2, 42 },
  1187.     {"BSXA", KOC_opcode, 2, 44 },
  1188.     {"BXA", KOC_opcode, 2, 46 },
  1189.     {"BYTE", KOC_BDEF, 0, 0 },
  1190.     {"CHARDEF", KOC_CHDEF, 0, 0 },
  1191.     {"CHARSET", KOC_CHSET, 0, 0 },
  1192.     {"CHARUSE", KOC_CHUSE, 0, 0 },
  1193.     {"CHD", KOC_CHDEF, 0, 0 },
  1194.     {"COMA", KOC_indexabs, 1, 48 },
  1195.     {"COMI", KOC_opcode, 1, 49 },
  1196.     {"COMR", KOC_opcode, 2, 50 },
  1197.     {"COMZ", KOC_opcode, 1, 52 },
  1198.     {"CPSL", KOC_opcode, 1, 53 },
  1199.     {"CPSU", KOC_opcode, 1, 54 },
  1200.     {"DAR", KOC_opcode, 1, 55 },
  1201.     {"DATA", KOC_BDEF, 0, 0 },
  1202.     {"DB", KOC_BDEF, 0, 0 },
  1203.     {"DW", KOC_WDEF, 0, 0 },
  1204.     {"ELSE", KOC_ELSE, 0, 0 },
  1205.     {"END", KOC_END, 0, 0 },
  1206.     {"ENDI", KOC_ENDI, 0, 0 },
  1207.     {"EORA", KOC_indexabs, 1, 56 },
  1208.     {"EORI", KOC_opcode, 1, 57 },
  1209.     {"EORR", KOC_opcode, 2, 58 },
  1210.     {"EORZ", KOC_opcode, 1, 60 },
  1211.     {"EQU", KOC_EQU, 0, 0 },
  1212.     {"FCB", KOC_BDEF, 0, 0 },
  1213.     {"FCC", KOC_SDEF, 0, 0 },
  1214.     {"FDB", KOC_WDEF, 0, 0 },
  1215.     {"HALT", KOC_opcode, 1, 61 },
  1216.     {"IF", KOC_IF, 0, 0 },
  1217.     {"INCL", KOC_INCLUDE, 0, 0 },
  1218.     {"INCLUDE", KOC_INCLUDE, 0, 0 },
  1219.     {"IORA", KOC_indexabs, 1, 62 },
  1220.     {"IORI", KOC_opcode, 1, 63 },
  1221.     {"IORR", KOC_opcode, 2, 64 },
  1222.     {"IORZ", KOC_opcode, 1, 66 },
  1223.     {"LODA", KOC_indexabs, 1, 67 },
  1224.     {"LODI", KOC_opcode, 1, 68 },
  1225.     {"LODR", KOC_opcode, 2, 69 },
  1226.     {"LODZ", KOC_opcode, 1, 71 },
  1227.     {"LPSL", KOC_opcode, 1, 72 },
  1228.     {"LPSU", KOC_opcode, 1, 73 },
  1229.     {"NOP", KOC_opcode, 1, 74 },
  1230.     {"ORG", KOC_ORG, 0, 0 },
  1231.     {"PPSL", KOC_opcode, 1, 75 },
  1232.     {"PPSU", KOC_opcode, 1, 76 },
  1233.     {"REDC", KOC_opcode, 1, 77 },
  1234.     {"REDD", KOC_opcode, 1, 78 },
  1235.     {"REDE", KOC_opcode, 1, 79 },
  1236.     {"RES", KOC_RESM, 0, 0 },
  1237.     {"RESERVE", KOC_RESM, 0, 0 },
  1238.     {"RETC", KOC_opcode, 1, 80 },
  1239.     {"RETE", KOC_opcode, 1, 81 },
  1240.     {"RMB", KOC_RESM, 0, 0 },
  1241.     {"RRL", KOC_opcode, 1, 82 },
  1242.     {"RRR", KOC_opcode, 1, 83 },
  1243.     {"SET", KOC_SET, 0, 0 },
  1244.     {"SPSL", KOC_opcode, 1, 84 },
  1245.     {"SPSU", KOC_opcode, 1, 85 },
  1246.     {"STRA", KOC_indexabs, 1, 86 },
  1247.     {"STRING", KOC_SDEF, 0, 0 },
  1248.     {"STRR", KOC_opcode, 2, 87 },
  1249.     {"STRZ", KOC_opcode, 1, 89 },
  1250.     {"SUBA", KOC_indexabs, 1, 90 },
  1251.     {"SUBI", KOC_opcode, 1, 91 },
  1252.     {"SUBR", KOC_opcode, 2, 92 },
  1253.     {"SUBZ", KOC_opcode, 1, 94 },
  1254.     {"TMI", KOC_opcode, 1, 95 },
  1255.     {"TPSL", KOC_opcode, 1, 96 },
  1256.     {"TPSU", KOC_opcode, 1, 97 },
  1257.     {"WORD", KOC_WDEF, 0, 0 },
  1258.     {"WRTC", KOC_opcode, 1, 98 },
  1259.     {"WRTD", KOC_opcode, 1, 99 },
  1260.     {"WRTE", KOC_opcode, 1, 100 },
  1261.     {"ZBRR", KOC_opcode, 2, 101 },
  1262.     {"ZBSR", KOC_opcode, 2, 103 },
  1263.     { "", 0, 0, 0 }};
  1264.  
  1265. struct opsynt ostab[NUMSYNBLK+1]
  1266.     = {
  1267. /* invalid 0 */ { 0, 1, 0 },
  1268. /* invalid 1 */ { 0xffff, 1, 1 },
  1269. /* ADDA 2 */ { ST_ABSOLUTE, 1, 2 },
  1270. /* ADDI 3 */ { ST_REGEXP, 1, 3 },
  1271. /* ADDR 4 */ { ST_REGEXP, 1, 4 },
  1272. /* ADDR 5 */ { ST_REGINDIR, 1, 5 },
  1273. /* ADDZ 6 */ { ST_REG, 1, 6 },
  1274. /* ANDA 7 */ { ST_ABSOLUTE, 1, 7 },
  1275. /* ANDI 8 */ { ST_REGEXP, 1, 8 },
  1276. /* ANDR 9 */ { ST_REGEXP, 1, 9 },
  1277. /* ANDR 10 */ { ST_REGINDIR, 1, 10 },
  1278. /* ANDZ 11 */ { ST_REG, 3, 11 },
  1279. /* BCFA 12 */ { ST_CONDEXP, 3, 14 },
  1280. /* BCFA 13 */ { ST_CONDINDIR, 3, 17 },
  1281. /* BCFR 14 */ { ST_CONDEXP, 3, 20 },
  1282. /* BCFR 15 */ { ST_CONDINDIR, 3, 23 },
  1283. /* BCTA 16 */ { ST_CONDEXP, 1, 26 },
  1284. /* BCTA 17 */ { ST_CONDINDIR, 1, 27 },
  1285. /* BCTR 18 */ { ST_CONDEXP, 1, 28 },
  1286. /* BCTR 19 */ { ST_CONDINDIR, 1, 29 },
  1287. /* BDRA 20 */ { ST_REGEXP, 1, 30 },
  1288. /* BDRA 21 */ { ST_REGINDIR, 1, 31 },
  1289. /* BDRR 22 */ { ST_REGEXP, 1, 32 },
  1290. /* BDRR 23 */ { ST_REGINDIR, 1, 33 },
  1291. /* BIRA 24 */ { ST_REGEXP, 1, 34 },
  1292. /* BIRA 25 */ { ST_REGINDIR, 1, 35 },
  1293. /* BIRR 26 */ { ST_REGEXP, 1, 36 },
  1294. /* BIRR 27 */ { ST_REGINDIR, 1, 37 },
  1295. /* BRNA 28 */ { ST_REGEXP, 1, 38 },
  1296. /* BRNA 29 */ { ST_REGINDIR, 1, 39 },
  1297. /* BRNR 30 */ { ST_REGEXP, 1, 40 },
  1298. /* BRNR 31 */ { ST_REGINDIR, 1, 41 },
  1299. /* BSFA 32 */ { ST_CONDEXP, 3, 42 },
  1300. /* BSFA 33 */ { ST_CONDINDIR, 3, 45 },
  1301. /* BSFR 34 */ { ST_CONDEXP, 3, 48 },
  1302. /* BSFR 35 */ { ST_CONDINDIR, 3, 51 },
  1303. /* BSNA 36 */ { ST_REGEXP, 1, 54 },
  1304. /* BSNA 37 */ { ST_REGINDIR, 1, 55 },
  1305. /* BSNR 38 */ { ST_REGEXP, 1, 56 },
  1306. /* BSNR 39 */ { ST_REGINDIR, 1, 57 },
  1307. /* BSTA 40 */ { ST_CONDEXP, 1, 58 },
  1308. /* BSTA 41 */ { ST_CONDINDIR, 1, 59 },
  1309. /* BSTR 42 */ { ST_CONDEXP, 1, 60 },
  1310. /* BSTR 43 */ { ST_CONDINDIR, 1, 61 },
  1311. /* BSXA 44 */ { ST_BINDEX, 1, 62 },
  1312. /* BSXA 45 */ { ST_BINDIRX, 1, 63 },
  1313. /* BXA 46 */ { ST_BINDEX, 1, 64 },
  1314. /* BXA 47 */ { ST_BINDIRX, 1, 65 },
  1315. /* COMA 48 */ { ST_ABSOLUTE, 1, 66 },
  1316. /* COMI 49 */ { ST_REGEXP, 1, 67 },
  1317. /* COMR 50 */ { ST_REGEXP, 1, 68 },
  1318. /* COMR 51 */ { ST_REGINDIR, 1, 69 },
  1319. /* COMZ 52 */ { ST_REG, 1, 70 },
  1320. /* CPSL 53 */ { ST_EXP, 1, 71 },
  1321. /* CPSU 54 */ { ST_EXP, 1, 72 },
  1322. /* DAR 55 */ { ST_REGCOMMA, 1, 73 },
  1323. /* EORA 56 */ { ST_ABSOLUTE, 1, 74 },
  1324. /* EORI 57 */ { ST_REGEXP, 1, 75 },
  1325. /* EORR 58 */ { ST_REGEXP, 1, 76 },
  1326. /* EORR 59 */ { ST_REGINDIR, 1, 77 },
  1327. /* EORZ 60 */ { ST_REG, 1, 78 },
  1328. /* HALT 61 */ { ST_INH, 1, 79 },
  1329. /* IORA 62 */ { ST_ABSOLUTE, 1, 80 },
  1330. /* IORI 63 */ { ST_REGEXP, 1, 81 },
  1331. /* IORR 64 */ { ST_REGEXP, 1, 82 },
  1332. /* IORR 65 */ { ST_REGINDIR, 1, 83 },
  1333. /* IORZ 66 */ { ST_REG, 1, 84 },
  1334. /* LODA 67 */ { ST_ABSOLUTE, 1, 85 },
  1335. /* LODI 68 */ { ST_REGEXP, 1, 86 },
  1336. /* LODR 69 */ { ST_REGEXP, 1, 87 },
  1337. /* LODR 70 */ { ST_REGINDIR, 1, 88 },
  1338. /* LODZ 71 */ { ST_REG, 4, 89 },
  1339. /* LPSL 72 */ { ST_INH, 1, 93 },
  1340. /* LPSU 73 */ { ST_INH, 1, 94 },
  1341. /* NOP 74 */ { ST_INH, 1, 95 },
  1342. /* PPSL 75 */ { ST_EXP, 1, 96 },
  1343. /* PPSU 76 */ { ST_EXP, 1, 97 },
  1344. /* REDC 77 */ { ST_REGCOMMA, 1, 98 },
  1345. /* REDD 78 */ { ST_REGCOMMA, 1, 99 },
  1346. /* REDE 79 */ { ST_REGEXP, 1, 100 },
  1347. /* RETC 80 */ { ST_COND, 1, 101 },
  1348. /* RETE 81 */ { ST_COND, 1, 102 },
  1349. /* RRL 82 */ { ST_REGCOMMA, 1, 103 },
  1350. /* RRR 83 */ { ST_REGCOMMA, 1, 104 },
  1351. /* SPSL 84 */ { ST_INH, 1, 105 },
  1352. /* SPSU 85 */ { ST_INH, 1, 106 },
  1353. /* STRA 86 */ { ST_ABSOLUTE, 1, 107 },
  1354. /* STRR 87 */ { ST_REGEXP, 1, 108 },
  1355. /* STRR 88 */ { ST_REGINDIR, 1, 109 },
  1356. /* STRZ 89 */ { ST_REG, 3, 110 },
  1357. /* SUBA 90 */ { ST_ABSOLUTE, 1, 113 },
  1358. /* SUBI 91 */ { ST_REGEXP, 1, 114 },
  1359. /* SUBR 92 */ { ST_REGEXP, 1, 115 },
  1360. /* SUBR 93 */ { ST_REGINDIR, 1, 116 },
  1361. /* SUBZ 94 */ { ST_REG, 1, 117 },
  1362. /* TMI 95 */ { ST_REGEXP, 1, 118 },
  1363. /* TPSL 96 */ { ST_EXP, 1, 119 },
  1364. /* TPSU 97 */ { ST_EXP, 1, 120 },
  1365. /* WRTC 98 */ { ST_REGCOMMA, 1, 121 },
  1366. /* WRTD 99 */ { ST_REGCOMMA, 1, 122 },
  1367. /* WRTE 100 */ { ST_REGEXP, 1, 123 },
  1368. /* ZBRR 101 */ { ST_EXP, 1, 124 },
  1369. /* ZBRR 102 */ { ST_INDIR, 1, 125 },
  1370. /* ZBSR 103 */ { ST_EXP, 1, 126 },
  1371. /* ZBSR 104 */ { ST_INDIR, 1, 127 },
  1372.     { 0, 0, 0 } };
  1373.  
  1374. struct igel igtab[NUMDIFFOP+1]
  1375.     = {
  1376. /* invalid 0 */   { 0 , 0, 
  1377.         "[Xnullentry" },
  1378. /* invalid 1 */   { 0 , 0, 
  1379.         "[Xinvalid opcode" },
  1380. /* ADDA 2 */   { 0 , 0, 
  1381.         "8c.[1#]|;[2=].P.6000&-.dI.[3#]000|x" },
  1382. /* ADDI 3 */   { 0 , 0, 
  1383.         "84.[1#]|;[2=];" },
  1384. /* ADDR 4 */   { 0 , 0, 
  1385.         "88.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R;" },
  1386. /* ADDR 5 */   { 0 , 0, 
  1387.         "88.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R.80|;" },
  1388. /* ADDZ 6 */   { 0 , 0, 
  1389.         "80.[1#]|;" },
  1390. /* ANDA 7 */   { 0 , 0, 
  1391.         "4c.[1#]|;[2=].P.6000&-.dI.[3#]000|x" },
  1392. /* ANDI 8 */   { 0 , 0, 
  1393.         "44.[1#]|;[2=];" },
  1394. /* ANDR 9 */   { 0 , 0, 
  1395.         "48.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R;" },
  1396. /* ANDR 10 */   { 0 , 0, 
  1397.         "48.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R.80|;" },
  1398. /* ANDZ 11 */   { REGMASK , REG1, 
  1399.         "41;" },
  1400. /* ANDZ 12 */   { REGMASK , REG2, 
  1401.         "42;" },
  1402. /* ANDZ 13 */   { REGMASK , REG3, 
  1403.         "43;" },
  1404. /* BCFA 14 */   { CONDMASK , COND0, 
  1405.         "9c.[1#]|;[2=].fIx" },
  1406. /* BCFA 15 */   { CONDMASK , COND1, 
  1407.         "9c.[1#]|;[2=].fIx" },
  1408. /* BCFA 16 */   { CONDMASK , COND2, 
  1409.         "9c.[1#]|;[2=].fIx" },
  1410. /* BCFA 17 */   { CONDMASK , COND0, 
  1411.         "9c.[1#]|;[2=].fI.8000|x" },
  1412. /* BCFA 18 */   { CONDMASK , COND1, 
  1413.         "9c.[1#]|;[2=].fI.8000|x" },
  1414. /* BCFA 19 */   { CONDMASK , COND2, 
  1415.         "9c.[1#]|;[2=].fI.8000|x" },
  1416. /* BCFR 20 */   { CONDMASK , COND0, 
  1417.         "98.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R;" },
  1418. /* BCFR 21 */   { CONDMASK , COND1, 
  1419.         "98.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R;" },
  1420. /* BCFR 22 */   { CONDMASK , COND2, 
  1421.         "98.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R;" },
  1422. /* BCFR 23 */   { CONDMASK , COND0, 
  1423.         "98.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R.80|;" },
  1424. /* BCFR 24 */   { CONDMASK , COND1, 
  1425.         "98.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R.80|;" },
  1426. /* BCFR 25 */   { CONDMASK , COND2, 
  1427.         "98.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R.80|;" },
  1428. /* BCTA 26 */   { 0 , 0, 
  1429.         "1c.[1#]|;[2=].fIx" },
  1430. /* BCTA 27 */   { 0 , 0, 
  1431.         "1c.[1#]|;[2=].fI.8000|x" },
  1432. /* BCTR 28 */   { 0 , 0, 
  1433.         "18.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R;" },
  1434. /* BCTR 29 */   { 0 , 0, 
  1435.         "18.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R.80|;" },
  1436. /* BDRA 30 */   { 0 , 0, 
  1437.         "fc.[1#]|;[2=].fIx" },
  1438. /* BDRA 31 */   { 0 , 0, 
  1439.         "fc.[1#]|;[2=].fI.8000|x" },
  1440. /* BDRR 32 */   { 0 , 0, 
  1441.         "f8.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R;" },
  1442. /* BDRR 33 */   { 0 , 0, 
  1443.         "f8.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R.80|;" },
  1444. /* BIRA 34 */   { 0 , 0, 
  1445.         "dc.[1#]|;[2=].fIx" },
  1446. /* BIRA 35 */   { 0 , 0, 
  1447.         "dc.[1#]|;[2=].fI.8000|x" },
  1448. /* BIRR 36 */   { 0 , 0, 
  1449.         "d8.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R;" },
  1450. /* BIRR 37 */   { 0 , 0, 
  1451.         "d8.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R.80|;" },
  1452. /* BRNA 38 */   { 0 , 0, 
  1453.         "5c.[1#]|;[2=].fIx" },
  1454. /* BRNA 39 */   { 0 , 0, 
  1455.         "5c.[1#]|;[2=].fI.8000|x" },
  1456. /* BRNR 40 */   { 0 , 0, 
  1457.         "58.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R;" },
  1458. /* BRNR 41 */   { 0 , 0, 
  1459.         "58.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R.80|;" },
  1460. /* BSFA 42 */   { CONDMASK , COND0, 
  1461.         "bc.[1#]|;[2=].fIx" },
  1462. /* BSFA 43 */   { CONDMASK , COND1, 
  1463.         "bc.[1#]|;[2=].fIx" },
  1464. /* BSFA 44 */   { CONDMASK , COND2, 
  1465.         "bc.[1#]|;[2=].fIx" },
  1466. /* BSFA 45 */   { CONDMASK , COND0, 
  1467.         "bc.[1#]|;[2=].fI.8000|x" },
  1468. /* BSFA 46 */   { CONDMASK , COND1, 
  1469.         "bc.[1#]|;[2=].fI.8000|x" },
  1470. /* BSFA 47 */   { CONDMASK , COND2, 
  1471.         "bc.[1#]|;[2=].fI.8000|x" },
  1472. /* BSFR 48 */   { CONDMASK , COND0, 
  1473.         "b8.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R;" },
  1474. /* BSFR 49 */   { CONDMASK , COND1, 
  1475.         "b8.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R;" },
  1476. /* BSFR 50 */   { CONDMASK , COND2, 
  1477.         "b8.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R;" },
  1478. /* BSFR 51 */   { CONDMASK , COND0, 
  1479.         "b8.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R.80|;" },
  1480. /* BSFR 52 */   { CONDMASK , COND1, 
  1481.         "b8.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R.80|;" },
  1482. /* BSFR 53 */   { CONDMASK , COND2, 
  1483.         "b8.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R.80|;" },
  1484. /* BSNA 54 */   { 0 , 0, 
  1485.         "7c.[1#]|;[2=].fIx" },
  1486. /* BSNA 55 */   { 0 , 0, 
  1487.         "7c.[1#]|;[2=].fI.8000|x" },
  1488. /* BSNR 56 */   { 0 , 0, 
  1489.         "78.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R;" },
  1490. /* BSNR 57 */   { 0 , 0, 
  1491.         "78.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R.80|;" },
  1492. /* BSTA 58 */   { 0 , 0, 
  1493.         "3c.[1#]|;[2=].fIx" },
  1494. /* BSTA 59 */   { 0 , 0, 
  1495.         "3c.[1#]|;[2=].fI.8000|x" },
  1496. /* BSTR 60 */   { 0 , 0, 
  1497.         "38.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R;" },
  1498. /* BSTR 61 */   { 0 , 0, 
  1499.         "38.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R.80|;" },
  1500. /* BSXA 62 */   { REGMASK , REG3, 
  1501.         "bf;[2=].fIx" },
  1502. /* BSXA 63 */   { REGMASK , REG3, 
  1503.         "bf;[2=].fI.8000|x" },
  1504. /* BXA 64 */   { REGMASK , REG3, 
  1505.         "9f;[2=].fIx" },
  1506. /* BXA 65 */   { REGMASK , REG3, 
  1507.         "9f;[2=].fI.8000|x" },
  1508. /* COMA 66 */   { 0 , 0, 
  1509.         "ec.[1#]|;[2=].P.6000&-.dI.[3#]000|x" },
  1510. /* COMI 67 */   { 0 , 0, 
  1511.         "e4.[1#]|;[2=];" },
  1512. /* COMR 68 */   { 0 , 0, 
  1513.         "e8.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R;" },
  1514. /* COMR 69 */   { 0 , 0, 
  1515.         "e8.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R.80|;" },
  1516. /* COMZ 70 */   { 0 , 0, 
  1517.         "e0.[1#]|;" },
  1518. /* CPSL 71 */   { 0 , 0, 
  1519.         "75;[1=];" },
  1520. /* CPSU 72 */   { 0 , 0, 
  1521.         "74;[1=];" },
  1522. /* DAR 73 */   { 0 , 0, 
  1523.         "94.[1#]|;" },
  1524. /* EORA 74 */   { 0 , 0, 
  1525.         "2c.[1#]|;[2=].P.6000&-.dI.[3#]000|x" },
  1526. /* EORI 75 */   { 0 , 0, 
  1527.         "24.[1#]|;[2=];" },
  1528. /* EORR 76 */   { 0 , 0, 
  1529.         "28.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R;" },
  1530. /* EORR 77 */   { 0 , 0, 
  1531.         "28.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R.80|;" },
  1532. /* EORZ 78 */   { 0 , 0, 
  1533.         "20.[1#]|;" },
  1534. /* HALT 79 */   { 0 , 0, 
  1535.         "40;" },
  1536. /* IORA 80 */   { 0 , 0, 
  1537.         "6c.[1#]|;[2=].P.6000&-.dI.[3#]000|x" },
  1538. /* IORI 81 */   { 0 , 0, 
  1539.         "64.[1#]|;[2=];" },
  1540. /* IORR 82 */   { 0 , 0, 
  1541.         "68.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R;" },
  1542. /* IORR 83 */   { 0 , 0, 
  1543.         "68.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R.80|;" },
  1544. /* IORZ 84 */   { 0 , 0, 
  1545.         "60.[1#]|;" },
  1546. /* LODA 85 */   { 0 , 0, 
  1547.         "0c.[1#]|;[2=].P.6000&-.dI.[3#]000|x" },
  1548. /* LODI 86 */   { 0 , 0, 
  1549.         "04.[1#]|;[2=];" },
  1550. /* LODR 87 */   { 0 , 0, 
  1551.         "08.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R;" },
  1552. /* LODR 88 */   { 0 , 0, 
  1553.         "08.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R.80|;" },
  1554. /* LODZ 89 */   { REGMASK , REG0, 
  1555.         "60;" },
  1556. /* LODZ 90 */   { REGMASK , REG1, 
  1557.         "01;" },
  1558. /* LODZ 91 */   { REGMASK , REG2, 
  1559.         "02;" },
  1560. /* LODZ 92 */   { REGMASK , REG3, 
  1561.         "03;" },
  1562. /* LPSL 93 */   { 0 , 0, 
  1563.         "93;" },
  1564. /* LPSU 94 */   { 0 , 0, 
  1565.         "92;" },
  1566. /* NOP 95 */   { 0 , 0, 
  1567.         "c0;" },
  1568. /* PPSL 96 */   { 0 , 0, 
  1569.         "77;[1=];" },
  1570. /* PPSU 97 */   { 0 , 0, 
  1571.         "76;[1=];" },
  1572. /* REDC 98 */   { 0 , 0, 
  1573.         "30.[1#]|;" },
  1574. /* REDD 99 */   { 0 , 0, 
  1575.         "70.[1#]|;" },
  1576. /* REDE 100 */   { 0 , 0, 
  1577.         "54.[1#]|;[2=];" },
  1578. /* RETC 101 */   { 0 , 0, 
  1579.         "14.[1#]|;" },
  1580. /* RETE 102 */   { 0 , 0, 
  1581.         "34.[1#]|;" },
  1582. /* RRL 103 */   { 0 , 0, 
  1583.         "d0.[1#]|;" },
  1584. /* RRR 104 */   { 0 , 0, 
  1585.         "50.[1#]|;" },
  1586. /* SPSL 105 */   { 0 , 0, 
  1587.         "13;" },
  1588. /* SPSU 106 */   { 0 , 0, 
  1589.         "12;" },
  1590. /* STRA 107 */   { 0 , 0, 
  1591.         "cc.[1#]|;[2=].P.6000&-.dI.[3#]000|x" },
  1592. /* STRR 108 */   { 0 , 0, 
  1593.         "c8.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R;" },
  1594. /* STRR 109 */   { 0 , 0, 
  1595.         "c8.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R.80|;" },
  1596. /* STRZ 110 */   { REGMASK , REG1, 
  1597.         "c1;" },
  1598. /* STRZ 111 */   { REGMASK , REG2, 
  1599.         "c2;" },
  1600. /* STRZ 112 */   { REGMASK , REG3, 
  1601.         "c3;" },
  1602. /* SUBA 113 */   { 0 , 0, 
  1603.         "ac.[1#]|;[2=].P.6000&-.dI.[3#]000|x" },
  1604. /* SUBI 114 */   { 0 , 0, 
  1605.         "a4.[1#]|;[2=];" },
  1606. /* SUBR 115 */   { 0 , 0, 
  1607.         "a8.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R;" },
  1608. /* SUBR 116 */   { 0 , 0, 
  1609.         "a8.[1#]|;[2=]~.P.6000&-.dIQ.1+-.7R.80|;" },
  1610. /* SUBZ 117 */   { 0 , 0, 
  1611.         "a0.[1#]|;" },
  1612. /* TMI 118 */   { 0 , 0, 
  1613.         "f4.[1#]|;[2=];" },
  1614. /* TPSL 119 */   { 0 , 0, 
  1615.         "b5;[1=];" },
  1616. /* TPSU 120 */   { 0 , 0, 
  1617.         "b4;[1=];" },
  1618. /* WRTC 121 */   { 0 , 0, 
  1619.         "b0.[1#]|;" },
  1620. /* WRTD 122 */   { 0 , 0, 
  1621.         "f0.[1#]|;" },
  1622. /* WRTE 123 */   { 0 , 0, 
  1623.         "d4.[1#]|;[2=];" },
  1624. /* ZBRR 124 */   { 0 , 0, 
  1625.         "9b;[1=].dI~.fff>.2000_*|.7R;" },
  1626. /* ZBRR 125 */   { 0 , 0, 
  1627.         "9b;[1=].dI~.fff>.2000_*|.7R.80|;" },
  1628. /* ZBSR 126 */   { 0 , 0, 
  1629.         "bb;[1=].dI~.fff>.2000_*|.7R;" },
  1630. /* ZBSR 127 */   { 0 , 0, 
  1631.         "bb;[1=].dI~.fff>.2000_*|.7R.80|;" },
  1632.     { 0,0,""} };
  1633. /* end fraptabdef.c */
  1634.