home *** CD-ROM | disk | FTP | other *** search
/ Fish 'n' More 2 / fishmore-publicdomainlibraryvol.ii1991xetec.iso / fish / languages / northc_384 / disass / disass.c < prev    next >
C/C++ Source or Header  |  1990-08-30  |  19KB  |  595 lines
  1. /* (c) 1990 Martin Combs */
  2.  
  3. #include <stdio.h>
  4. #define maxfile  20000
  5.   long i, ii, iold;
  6.   long *lp;
  7.   unsigned int hibyte, lobyte, lonib, L76, mode, reg, reg1, size;
  8.   short *wp;
  9.   char p[maxfile], instS[40], opS[20], op1S[40], op2S[20], ascS[20];
  10.   char objS[40];
  11.   char reg1S[4];
  12.   char spaceS[10]="        ";
  13.   char spS[27][12];
  14.   char *ccS[16]={ "t", "f", "hi", "ls", "cc", "cs", "ne", "eq", "vc", "vs",
  15.                   "pl", "mi", "ge", "lt", "gt", "le" };
  16.   char *shiftS[8]= { "asr", "asl", "lsr", "lsl",
  17.                      "roxr", "roxl", "ror", "rol"};
  18. /* activate function test() for trouble shooting */
  19. /*
  20. test()
  21. { printf("\nsize=%d\thibyte=%d\tlobyte=%d\treg=%d\n",size,hibyte,lobyte,reg);
  22.   printf("lonib=%d\tmode=%d\tL76=%d\n",lonib,mode,L76);
  23.   printf("opS=%s\top1S=%s\top2S=%s\n",opS,op1S,op2S);
  24. }
  25. */
  26.  
  27. tab()
  28. { int len;
  29.   for (len=0;len<27;len++)
  30.   { if (!len) strcpy(spS[len],"\t\t\t");
  31.     else if (len < 9) sprintf(spS[len],"%s\t\t",spaceS+len);
  32.     else if (len < 17) sprintf(spS[len],"%s\t",spaceS+len-8);
  33.     else if (len<25) sprintf(spS[len],"%s",spaceS+len-16);
  34.     else spS[len][0]='\0';
  35.   }
  36. }
  37.  
  38. binst()
  39. { switch (L76)
  40.     { case 0: strcpy(instS,"btst"); break;
  41.       case 1: strcpy(instS,"bchg"); break;
  42.       case 2: strcpy(instS,"bclr"); break;
  43.       case 3: strcpy(instS,"bset");
  44.     }
  45. }
  46.  
  47. sizef()
  48. { switch (L76)
  49.      { case 0: strcat(instS,".b"); size=0; break;
  50.        case 1: strcat(instS,".w"); size=1; break;
  51.        case 2: strcat(instS,".l"); size=2;
  52.      }
  53. }
  54.  
  55. sizeff()
  56. { sizef(); eff();
  57. }
  58.  
  59. eff()
  60. { mode = (lobyte&56) >> 3; reg = lobyte & 7; eff1();
  61. }
  62.  
  63. eff1()
  64. { switch (mode)
  65.     { case 0: opS[0]='d'; opS[1]=reg+48; opS[2]='\0'; break;
  66.       case 1: opS[0]='a'; opS[1]=reg+48; opS[2]='\0'; break;
  67.       case 2: opS[0]='('; opS[1]='a'; opS[2]=reg+48; 
  68.               opS[4]=')'; opS[3]='\0'; break;
  69.       case 3: opS[0]='('; opS[1]='a'; opS[2]=reg+48;
  70.               opS[3]=')'; opS[4]='+';opS[5]='\0'; break;
  71.       case 4: opS[0]='-'; opS[1]='('; opS[2]='a'; opS[3]=reg+48;
  72.               opS[4]=')'; opS[5]='\0'; break;
  73.       case 5: i+=2; wp=(short *)&p[i]; sprintf(opS,"%d(a%d)",*wp,reg); break;
  74.       case 6: i+=2; sprintf(opS,"%d(a%d,",p[i+1],reg); ariwi2(); break;
  75.       case 7: grabbag();
  76.     }
  77. }
  78.  
  79. ariwi2()
  80. { char regS[4];
  81.   if (p[i]&128) strcat(opS,"a"); else strcat(opS,"d");
  82.   regS[1]='\0';
  83.   regS[0]=48 + ((p[i] & 112) >> 4);
  84.   strcat(opS,regS);
  85.   if (p[i]&8) strcat(opS,".l)"); else strcat(opS,".w)");
  86. }
  87.  
  88. grabbag()
  89. { switch (reg)
  90.     { case 0: i+=2; wp=(short *)&p[i]; sprintf(opS,"%d",*wp); break;
  91.       case 1: i+=4; lp=(long *)&p[i-2]; sprintf(opS,"%ld",*lp); break;
  92.       case 2: i+=2; wp=(short *)&p[i]; sprintf(opS,"%d(pc)",*wp); break;
  93.       case 3: i+=2; sprintf(opS,"%d(pc,",p[i+1]); ariwi2(); break;
  94.       default: switch (size)
  95.                 { case 0: i+=2; sprintf(opS,"#%d",p[i+1]); break;
  96.                   case 1: i+=2; wp=(short *)&p[i];
  97.                           sprintf(opS,"#%d",*wp); break;
  98.                   case 2: i+=4; lp=(long *)&p[i-2];
  99.                           sprintf(opS,"#%ld",*lp); break;
  100.                 }
  101.     }
  102. }
  103.  
  104. movep()
  105. { if (lobyte & 64) strcpy(instS,"movep.l"); else strcpy(instS,"movep.w");
  106.   dreg();  reg=lobyte & 7; i+=2;
  107.   wp=(short *)&p[i];
  108.   if (lobyte & 128) {strcpy(op1S,reg1S);sprintf(op2S,"%d(a%d)",*wp,reg);}
  109.   else { strcpy(op2S,reg1S); sprintf(op1S,"%d(a%d)",*wp,reg); }
  110. }
  111.  
  112. dreg()
  113. { reg1S[0]='d';
  114.   reg1=(hibyte & 14) >> 1;
  115.   reg1S[1]=reg1+48;
  116. }
  117. areg()
  118. { reg1S[0]='a';
  119.   reg1=(hibyte & 14) >> 1;
  120.   reg1S[1]=reg1+48;
  121. }
  122.  
  123. op0000()
  124. {
  125.   if (hibyte&1) op0000xxx1(); else op0000xxx0();
  126. }
  127. op0000xxx0()
  128. { if (hibyte==8)
  129.       { binst(); i+=2; sprintf(op1S,"#%d",p[i+1]&31);
  130.         eff(); strcpy(op2S,opS); return; }
  131.   if (hibyte==14) { strcpy(instS,"moves"); i+=2;
  132.                     if (p[i]&128) opS[0]='a'; else opS[0]='d';
  133.                     opS[1] = 48 + ((p[i] & 112) >> 4);
  134.                     opS[2] = '\0';
  135.                     wp=(short *)&p[i];
  136.                     if ((*wp)&2048)
  137.                        { strcpy(op1S,opS); sizeff(); strcpy(op2S,opS); }
  138.                     else {strcpy(op2S,opS); sizeff(); strcpy(op1S,opS); }
  139.                     return;
  140.                   }
  141.   switch (hibyte)
  142.     { case 0: strcpy(instS,"ori"); break;
  143.       case 2: strcpy(instS,"andi"); break;
  144.       case 4: strcpy(instS,"subi"); break;
  145.       case 6: strcpy(instS,"addi"); break;
  146.       case 10: strcpy(instS,"eori"); break;
  147.       case 12: strcpy(instS,"cmpi");
  148.     }
  149.   switch (L76)
  150.     { case 0: sprintf(op1S,"#%d",p[i+3]&255); break;
  151.       case 1: wp=(short *)&p[i+2]; sprintf(op1S,"#%d",*wp); break;
  152.       case 2: i+=2; lp=(long *)&p[i]; sprintf(op1S,"#%ld",*lp);
  153.     }
  154.     i+=2; sizeff();
  155.     if (mode==7 && reg==4) { i-=2; if (!L76) { strcpy(op2S,"ccr"); return; }
  156.     else { strcpy(op2S,"sr"); return; }
  157.     }  /* end if (mode==7 etc */
  158.     strcpy(op2S,opS);
  159. }
  160.  
  161. op0000xxx1()
  162. { if ((lobyte & 56)==8) { movep();return;}
  163.   binst();
  164.   dreg();
  165.   strcpy(op1S,reg1S);
  166.   eff();
  167.   strcpy(op2S,opS);
  168. }
  169.  
  170. op0001()
  171. { strcpy(instS,"move.b"); size=0; move();
  172. }
  173.  
  174. op0010()
  175. { size=2; move();
  176. }
  177.  
  178. op0011()
  179. { size=1; move();
  180. }
  181.  
  182. move()
  183. { unsigned int inst;
  184.   inst=hibyte*256+lobyte;
  185.   if (size) { strcpy(instS,"move");
  186.               if ((inst & 448)==64) strcat(instS,"a");
  187.               if (size==2) strcat(instS,".l");
  188.               else strcat(instS,".w");
  189.               }
  190.   eff(); strcpy(op1S,opS); mode=(inst & 448)>>6; reg=(inst & 3584) >> 9;
  191.   eff1(); strcpy(op2S,opS);
  192. }
  193.  
  194. op0100()
  195. { if (hibyte & 1) op0100xxx1(); else op0100xxx0();
  196. }
  197.  
  198. op0100xxx0()
  199. { int flag=1, lb240;
  200.   switch (lonib)
  201.     { case 0:  if (L76==3) { strcpy(instS,"move"); strcpy(op1S,"sr");
  202.                           eff(); strcpy(op2S,opS); }
  203.                else {strcpy(instS,"negx"); sizeff(); strcpy(op1S,opS); }
  204.                break;
  205.       case 2:  if (L76==3) {strcpy(instS,"move"); strcpy(op1S,"ccr");
  206.                            eff(); strcpy(op2S,opS); }
  207.                else { strcpy(instS,"clr"); sizeff(); strcpy(op1S,opS);}
  208.                break;
  209.       case 4:  if (L76==3) { strcpy(instS,"move"); eff(), strcpy(op1S,opS);
  210.                             strcpy(op2S,"ccr"); }
  211.                else { strcpy(instS,"neg"); sizeff(); strcpy(op1S,opS); }
  212.                break;
  213.       case 6:  if (L76==3) {strcpy(instS,"move"); eff(); strcpy(op1S,opS);
  214.                             strcpy(op2S,"sr"); }
  215.                else {strcpy(instS,"not"); sizeff(); strcpy(op1S,opS);}
  216.                break;
  217.       case 8:  op01001000(); break;
  218.       case 10: op01001010(); break;
  219.       case 12: movem(); break;
  220.       default: flag=0;
  221.     }
  222.   if (flag) return;
  223.   lb240=lobyte & 240;
  224.   switch (lb240)
  225.     { case 64: strcpy(instS,"trap"); sprintf(op1S,"#%d",lobyte&15); break;
  226.       case 80: op1S[0]='a'; op1S[1]=48+(lobyte&7); op1S[2]='\0';
  227.                if (lobyte & 8) strcpy(instS,"unlk");
  228.                else { strcpy(instS,"link"); i+=2;
  229.                       wp=(short *)&p[i]; sprintf(op2S,"#%d",*wp); }
  230.                break;
  231.       case 96: strcpy(instS,"move");
  232.                opS[0]='a'; opS[1]=48+(lobyte&7); opS[2]='\0';
  233.                if (lobyte & 8) { strcpy(op1S,"usp"); strcpy(op2S,opS); }
  234.                else { strcpy(op1S,opS); strcpy(op2S,"usp"); }
  235.                break;
  236.       default: flag=1;
  237.     }
  238.   if (!flag) return;
  239.   switch (lobyte)
  240.     { case 112: strcpy(instS,"reset"); break;
  241.       case 113: strcpy(instS,"nop");  break;
  242.       case 114: strcpy(instS,"stop"); wp=(short *)&p[i+2];
  243.                 sprintf(op1S,"#%d",*wp); i+=2; break;
  244.       case 115: strcpy(instS,"rte"); break;
  245.       case 116: strcpy(instS,"rtd"); i+=2; wp=(short *)&p[i];
  246.                 sprintf(op1S,"#%d",*wp);break;
  247.       case 117: strcpy(instS,"rts"); break;
  248.       case 118: strcpy(instS,"trapv"); break;
  249.       case 119: strcpy(instS,"rtr"); break;
  250.       case 122: strcpy(instS,"movec"); i+=2; movec();
  251.                 strcpy(op2S,opS); break;
  252.       case 123: strcpy(instS,"movec"); i+=2; movec(); strcpy(op2S,op1S);
  253.                 strcpy(op1S,opS); break;
  254.       default: flag=0;
  255.     }
  256.   if (flag) return;
  257.   if (L76==2) { strcpy(instS,"jsr"); eff(); strcpy(op1S,opS); return; }
  258.   if (L76==3) { strcpy(instS,"jmp"); eff(); strcpy(op1S,opS);  }
  259. }
  260.  
  261. movec()
  262. { int contreg;
  263.   if (p[i]&128) opS[0]='a'; else opS[0]='d';
  264.   opS[1]=48 + ((p[i] & 112) >> 4);
  265.   opS[2]='\0';
  266.   wp=(short *)&p[i]; contreg=(*wp)&4095;
  267.   switch (contreg)
  268.    { case 0: strcpy(op1S,"sfc"); break;
  269.      case 1: strcpy(op1S,"dfc"); break;
  270.      case 2048: strcpy(op1S,"usp"); break;
  271.      case 2049: strcpy(op1S,"vbr"); break;
  272.    }
  273. }
  274.  
  275. op0100xxx1()
  276. { if (L76==2) { strcpy(instS,"chk"); dreg(); }
  277.   if (L76==3) { strcpy(instS,"lea"); areg(); }
  278.   eff(); strcpy(op1S,opS); strcpy(op2S,reg1S); return;
  279. }
  280.  
  281. op01001000()
  282. { if (!L76) {strcpy(instS,"nbcd"); eff(); strcpy(op1S,opS); return; }
  283.   if ((L76==1) && (!(lobyte & 56))) strcpy(instS,"swap");
  284.   else strcpy(instS,"pea");
  285.   if (L76==1) { eff(); strcpy(op1S,opS); return; }
  286.   if (!(lobyte&56)) { strcpy(instS,"ext");
  287.                       if (L76==2) strcat(instS,".w");
  288.                       else if (L76==3) strcat(instS,".l");
  289.                       op1S[0]='d'; op1S[1]=48+(lobyte&7);
  290.                       op1S[2]='\0'; return; }
  291.   movem();
  292. }
  293.  
  294. op01001010()
  295. { if (lobyte==252) { strcpy(instS,"illegal"); return; }
  296.   if (L76==3) { strcpy(instS,"tas"); eff(); strcpy(op1S,opS); return; }
  297.   strcpy(instS,"tst"); sizeff(); strcpy(op1S,opS);
  298. }
  299.  
  300. movem()
  301. { char rdS[20], raS[20], registerlistS[20];
  302.   register j;
  303.   int bm, bm1=0;
  304.   if (lobyte & 64) strcpy(instS,"movem.l"); else strcpy(instS,"movem.w");
  305.   eff();
  306.   i+=2; wp=(short *)&p[i]; bm=*wp;
  307.   registerlistS[0]='d';  registerlistS[1]='\0';
  308.   if (mode==4)
  309.     { for (j=0; j<16; j++) if (bm & 1<<j) bm1= bm1 | 1<<(15-j);
  310.       bm=bm1; }
  311.   rdS[1]='\0';
  312.   for (j=0;j<8;j++)
  313.     if (bm & 1<<j) { rdS[0]=48 + j; strcat(registerlistS,rdS); }
  314.   if (strlen(registerlistS) < 2) registerlistS[0]='\0';
  315.   rdS[0]='a'; rdS[1]='\0';
  316.   raS[1]='\0';
  317.   for (j=8;j<16;j++)
  318.     if (bm & 1<<j) { raS[0]=40+j; strcat(rdS,raS); }
  319.   if (strlen(rdS) > 2) strcat(registerlistS,rdS);
  320.   if (lonib==8) { strcpy(op1S,registerlistS); strcpy(op2S,opS); }
  321.   else { strcpy(op1S,opS); strcpy(op2S,registerlistS); }
  322. }
  323.  
  324. op0101()
  325. { int quick;
  326.   if (L76==3) { strcpy(instS,ccS[lonib]);
  327.      if ((lobyte&56)==8) { dbcc(); return; }
  328.      else { strcpy(opS,"s"); strcat(opS,instS); strcpy(instS,opS);
  329.             eff(); strcpy(op1S,opS); return; }
  330.   }
  331.   if (lonib & 1) strcpy(instS,"subq"); else strcpy(instS,"addq");
  332.   sizeff(); strcpy(op2S,opS);
  333.   quick=(lonib & 14) >> 1;
  334.   if (!quick) quick=8;
  335.   op1S[0]='#'; op1S[1]=48+quick; op1S[2]='\0';
  336. }
  337.  
  338. dbcc()
  339. { if (lonib==1) strcpy(instS,"dbra");
  340.   else { strcpy(opS,"db"); strcat(opS,instS); strcpy(instS,opS); }
  341.   op1S[0]='d'; op1S[1]=48 + (lobyte & 7); op1S[2]='\0';
  342.   i+=2; figurelabel();  sprintf(op2S,"%d",*wp);
  343.   strcat(op2S,opS);
  344. }
  345.  
  346. op0110()
  347. { if (!lonib) strcpy(instS,"bra");
  348.   else if (lonib==1) strcpy(instS,"bsr");
  349.   else { strcpy(instS,"b"); strcat(instS,ccS[lonib]);}
  350.   if (!lobyte) { i+=2; strcat(instS,".w"); figurelabel();
  351.                  sprintf(op1S,"%d%s",*wp,opS); return; }
  352.   strcat(instS,".s");
  353.   sprintf(op1S,"%d   (%ld)",p[i+1],iold + 2 + p[i+1]);
  354. }
  355.  
  356. figurelabel()
  357. { wp=(short *)&p[i];
  358.  sprintf(opS,"   (%ld)",iold + 2 + *wp);
  359. }
  360.  
  361. op0111()
  362. { strcpy(instS,"moveq"); sprintf(op1S,"#%d",p[i+1]);
  363.   dreg(); strcpy(op2S,reg1S);
  364. }
  365.  
  366. op1000()
  367. { if (L76==3) { if (hibyte & 1) strcpy(instS,"divs");
  368.                 else strcpy(instS,"divu");
  369.                 size=1; dreg(); eff(); strcpy(op1S,opS);
  370.                 strcpy(op2S, reg1S); return; }
  371.   if (hibyte & 1) { if (!(lobyte & 48)) { strcpy(instS,"sbcd"); dreg();
  372.                        if (lobyte & 8) { sprintf(op1S,"-(a%d)",lobyte & 7);
  373.                                          sprintf(op2S,"-(a%d)",reg1); }
  374.                        else { sprintf(op1S,"d%d",lobyte & 7);
  375.                               strcpy(op2S,reg1S); }
  376.                                          }
  377.                     else { strcpy(instS,"or"); dreg(); sizeff();
  378.                            strcpy(op1S,reg1S); strcpy(op2S,opS); }
  379.                    }
  380.    else { strcpy(instS,"or"); dreg(); sizeff();
  381.           strcpy(op1S,opS); strcpy(op2S,reg1S); }
  382. }
  383.  
  384. op1001()
  385. { if (L76==3) { if (lonib & 1) { strcpy(instS,"suba.l"); size=2; }
  386.                 else {strcpy(instS,"suba.w"); size=1; }
  387.       areg(); eff(); strcpy(op1S,opS); strcpy(op2S,reg1S); return;  }
  388.   if (!(lonib & 1)) { strcpy(instS,"sub"); dreg(); sizeff();
  389.                       strcpy(op1S,opS); strcpy(op2S,reg1S); }
  390.  
  391.   if (lonib & 1) { if (!(lobyte & 48)) { strcpy(instS,"subx");
  392.                                          sizef(); dreg();
  393.                        if (lobyte & 8) { sprintf(op1S,"-(a%d)",lobyte & 7);
  394.                                 sprintf(op2S,"-(a%d)",reg1); }
  395.                      else { sprintf(op1S,"d%d",lobyte & 7);
  396.                             strcpy(op2S,reg1S); }
  397.                     }
  398.                    else { strcpy(instS,"sub"); sizeff(); dreg();
  399.                          strcpy(op1S,reg1S); strcpy(op2S,opS); }
  400.   }
  401. }
  402.  
  403. op1011()
  404. { if (L76==3) { strcpy(instS,"cmpa");
  405.       if (lonib & 1) { size=2; strcat(instS,".l"); }
  406.       else { size=1; strcat(instS,".w"); }
  407.       areg(); eff(); strcpy(op1S,opS); strcpy(op2S,reg1S); return; }
  408.   if (lonib & 1) { mode=(lobyte & 56) >> 3;
  409.                    if (mode==1) { strcpy(instS,"cmpm"); sizeff(); dreg();
  410.                      sprintf(op1S,"(%s)+",opS);
  411.                      sprintf(op2S,"(a%d)+",reg1); }
  412.                    else { strcpy(instS,"eor"); sizeff(); dreg();
  413.                           strcpy(op1S,reg1S); strcpy(op2S,opS); }
  414.                   }
  415.   else { strcpy(instS,"cmp"); sizeff(); dreg();
  416.          strcpy(op1S,opS); strcpy(op2S,reg1S); }
  417. }
  418.  
  419. op1100()
  420. { if (L76==3)  {
  421.     if (lonib & 1) strcpy(instS,"muls"); else strcpy(instS,"mulu");
  422.     size=1; dreg(); eff(); strcpy(op1S,opS); strcpy(op2S,reg1S); return; }
  423.   if (!(lonib & 1)) { strcpy(instS,"and"); dreg(); sizeff();
  424.                       strcpy(op1S,opS); strcpy(op2S,reg1S); return; }
  425.   if (!(lobyte & 48)) {
  426.     if (!L76) { strcpy(instS,"abcd"); dreg(); eff();
  427.       if (mode==1) { sprintf(op1S,"-(%s)",opS);
  428.                      sprintf(op2S,"-(a%d)",reg1); return; }
  429.       else { strcpy(op1S,opS); strcpy(op2S,reg1S); return; }
  430.     }
  431.     strcpy(instS,"exg"); eff(); dreg();
  432.     if (L76==2) { strcpy(op1S,reg1S); strcpy(op2S,opS); return; }
  433.     if (mode==1) { strcpy(op1S,opS); sprintf(op2S,"a%d",reg1); }
  434.     else { strcpy(op1S,opS); strcpy(op2S,reg1S); }
  435.     return;
  436.   }
  437.   strcpy(instS,"and"); dreg(); sizeff();
  438.   strcpy(op1S,reg1S); strcpy(op2S,opS);
  439. }
  440.  
  441. op1101()
  442. { if (L76==3) { strcpy(instS,"adda");
  443.      if (lonib & 1) { size=2; strcat(instS,".l"); }
  444.      else { size=1; strcat(instS,".w");  }
  445.      areg(); eff(); strcpy(op1S,opS); strcpy(op2S,reg1S); return;
  446.      }
  447.   if (!(lonib & 1)) { strcpy(instS,"add"); dreg(); sizeff();
  448.                     strcpy(op1S,opS); strcpy(op2S,reg1S); return; }
  449.   if (lobyte & 48) {strcpy(instS,"add"); sizeff(); dreg();
  450.                     strcpy(op1S,reg1S); strcpy(op2S,opS); return; }
  451.   strcpy(instS,"addx"); sizeff(); dreg();
  452.   if (mode==1) { sprintf(op1S,"-(%s)",opS); sprintf(op2S,"-(a%d)",reg1); }
  453.   else { strcpy(op1S,opS); strcpy(op2S,reg1S); }
  454. }
  455.  
  456. op1110()
  457. { int sh;
  458.   if (L76==3) { sprintf(instS,"%s.w",shiftS[lonib]); eff();
  459.                 strcpy(op1S,opS); return; }
  460.   dreg(); sprintf(op2S,"d%d",lobyte & 7);
  461.   sh= ((lobyte & 24) >> 2) + (lonib & 1);
  462.   strcpy(instS,shiftS[sh]);
  463.   sizef();
  464.   if (lobyte & 32) { strcpy(op1S,reg1S); return; }
  465.   if (!reg1) reg1=8;
  466.   sprintf(op1S,"#%d",reg1);
  467. }
  468.  
  469. genasc()
  470. { int asc, k=0;
  471.   for (ii=iold; ii<i; ii++)
  472.     { asc=p[ii];
  473.       if ((asc>31) && (asc<127)) ascS[k++]=asc; else ascS[k++]=166;
  474.     }
  475.   ascS[k]='\0';
  476. }
  477.  
  478. genobj()
  479. { int hinib, lonib, k=0;
  480.   for (ii=iold; ii<i; ii++)
  481.     { hinib=p[ii]&255; lonib=hinib & 15; hinib=hinib >> 4;
  482.       if (lonib<10) lonib=48+lonib; else lonib=55+lonib;
  483.       if (hinib<10) hinib=48+hinib; else hinib=55+hinib;
  484.       objS[k++]=hinib; objS[k++]=lonib; objS[k++]=' ';
  485.     }
  486.   objS[k]='\0';
  487. }
  488.  
  489. main(argc, argv)
  490. int argc;
  491. char **argv;
  492. {  register long  maxi=0, line=0;
  493.    register char ch;
  494.    FILE *fromfile, *tofile;
  495.    unsigned int hinib;
  496.    char *fromname, *toname, outname[40];
  497.  
  498.    if (argc < 2 || argc > 3)
  499.      {
  500.        printf("Useage: disass fromfile <tofile>\n");
  501.        printf("If tofile omitted, output will be directed to monitor.\n");
  502.        printf("If tofile specified, .asm will be appended to tofile.\n");
  503.        printf("\nWarning!! Output file may be about 13 times as big as \n");
  504.        printf("input file. Make sure you have enough memory.\n");
  505.        printf("Maximum input file size set for 20,000 bytes.\n");
  506.        printf("For maximum speed, send output to ram:.\n");
  507.        exit(4);
  508.      }
  509.   fromfile = fopen(argv[1], "r");
  510.   if (fromfile == NULL )
  511.      {
  512.        printf("Can't open: %s\n", argv[1]);
  513.        exit(4);
  514.      }
  515.   if (argc==3)
  516.      { sprintf(outname,"%s.asm",argv[2]);
  517.        tofile = fopen(outname, "w");
  518.        if (tofile == NULL )
  519.          { printf("Can't open: %s\n", argv[2]);
  520.            exit(4); }
  521.        printf("%s opened\n",argv[2]);
  522.        fprintf(tofile,"PC\tINST\tOPERANDS\t\tASCII\t HEX\n");
  523.      }
  524.   printf("Reading %s\n",argv[1]);
  525.   ch=fgetc(fromfile);
  526.   while (!feof(fromfile)  && maxi<maxfile)
  527.     {
  528.       p[maxi++]=ch;
  529.       ch=fgetc(fromfile);
  530.     }
  531.  
  532.   printf("number of bytes loaded %ld\n\n",maxi);
  533.   fclose( fromfile);  printf("Input file %s closed.\n\n",argv[1]);
  534.   do
  535.   { printf("Enter a starting PC (program counter) between 0 and %ld ",maxi-2);
  536.     fflush(stdout);
  537.     scanf("%ld",&i); }
  538.   while (i<0 || i>maxi-2);
  539.   if (i%2) i--; /* only even PC allowed */
  540.   if (argc==2) printf("\nPC\tINST\tOPERANDS\t\tASCII\t HEX\n");
  541.   tab();
  542.   while (i<maxi)
  543.   { /* main loop */
  544.   iold=i;
  545.   hibyte=p[i]&255; lobyte=p[i+1]&255;
  546.   L76=lobyte>>6&15;
  547.   hinib=hibyte>>4; lonib=hibyte&15;
  548.   instS[0]='\0'; op1S[0]='\0'; op2S[0]='\0';     /* initialize strings */
  549.   switch (hinib)
  550.     { case 0: op0000(); break;
  551.       case 1: op0001(); break;
  552.       case 2: op0010(); break;
  553.       case 3: op0011(); break;
  554.       case 4: op0100(); break;
  555.       case 5: op0101(); break;
  556.       case 6: op0110(); break;
  557.       case 7: op0111(); break;
  558.       case 8: op1000(); break;
  559.       case 9: op1001(); break;
  560.       /* no case 10  or 15 */
  561.       case 11: op1011() ; break;
  562.       case 12: op1100() ; break;
  563.       case 13: op1101() ; break;
  564.       case 14: op1110() ; break;
  565.  
  566.       default: strcpy(instS,"INVALID");
  567.     }   /* end of switch */
  568.   if (strlen(op1S)) if (strlen(op2S))
  569.        { strcpy(opS,","); strcat(opS,op2S); strcat(op1S,opS); }
  570.   if (argc==2)
  571.     { i+=2;
  572.       printf("%5ld\t%s\t%s%s",iold,instS,op1S,spS[strlen(op1S)]);
  573.       genasc();
  574.       genobj();
  575.       if (i-iold>6) printf("%s  %s\n",ascS,objS);
  576.       else printf("%s\t%s\n",ascS,objS);
  577.     }
  578.   else
  579.     { if (!(++line % 100))  printf("%ld\r",line);
  580.       i+=2;
  581.       fprintf(tofile,"%5ld\t%s\t%s%s",iold,instS,op1S,spS[strlen(op1S)]);
  582.       genasc();
  583.       genobj();
  584.       if (i-iold>6) fprintf(tofile,"%s  %s\n",ascS,objS);
  585.       else fprintf(tofile,"%s\t%s\n",ascS,objS);
  586.     }
  587.  
  588.   } /* end of main while loop */
  589.  
  590.   if (argc==3)
  591.     { fclose( tofile );
  592.       printf("\nFinished.  Output file %s closed.\n",outname); }
  593.   exit(0);
  594. }
  595.