home *** CD-ROM | disk | FTP | other *** search
/ Micro R&D 1 / MicroRD-CD-ROM-Vol1-1994.iso / hardware / drivr / ibmk.lha / ibmk / a51.c next >
C/C++ Source or Header  |  1991-04-12  |  23KB  |  1,550 lines
  1. #include "a51.h"
  2. void convert();
  3. void hexs();
  4.  
  5. void cleanexit(t)
  6. char t[80];
  7. {
  8.     int x;
  9.     LINK tl;
  10.         tl=tag_list;
  11.         x=0;
  12.         hexsflag=0;
  13.         while (tl!=(LINK) NULL)
  14.         {
  15.             if (x==0) fprintf(f_lst,"\n");
  16.             else fprintf(f_lst,"\t");
  17.             hexs(tl->value);
  18.             fprintf(f_lst,"%s\t%s",tl->tag,hexstr);
  19.             tl=tl->next;
  20.         }
  21.         fprintf(f_lst,"\n\n");
  22.         fclose(f_lst);
  23.     printf("****%d\t%s\n",line,buffer);
  24.     printf("ERROR:%s\n",t);
  25.     exit();
  26. }
  27.  
  28. void warn(t)
  29. char t[80];
  30. {
  31.     printf("++++%d\t%s\n",line,buffer);
  32.     printf("WARNING:%s\n",t);
  33.     return;
  34. }
  35.  
  36. void strnullcpy(t,u,n)
  37. char t[80];
  38. char u[80];
  39. int n;
  40. {
  41.     strncpy(t,u,n);
  42.     t[n]='\0';
  43.     return;
  44. }
  45.  
  46. void hack(n)
  47. int n;
  48. {
  49.     int x;
  50.     for (x=0;x<=80;x++)
  51.         s[x]=s[x+n];
  52.     pos-=n;
  53.     return;
  54. }
  55.  
  56. char hexc(n)
  57. int n;
  58. {
  59.     if ((n+=48)>57) n+=7;
  60.     return((char) n);
  61. }
  62.  
  63. void hexs(l)
  64. long l;
  65. {
  66.     long m;
  67.     char t[7];
  68.     m=l;
  69.     t[0]=hexc(m/1048576);
  70.     m%=1048576;
  71.     t[1]=hexc(m/65536);
  72.     m%=65536;
  73.     t[2]=hexc(m/4096);
  74.     m%=4096;
  75.     t[3]=hexc(m/256);
  76.     m%=256;
  77.     t[4]=hexc(m/16);
  78.     m%=16;
  79.     t[5]=hexc(m);
  80.     t[6]='\0';
  81.     if (l>65535) {strcpy(hexstr,t);return;}
  82.     if ((l>255)||(hexsflag==1)) {strcpy(hexstr,&t[2]);return;}
  83.     strcpy(hexstr,&t[4]);
  84.     return;
  85. }
  86.  
  87. void showcode()
  88. {
  89.     int x,y;
  90.     int flag;
  91.     char filename[80];
  92.     char longstr[80];
  93.     strcpy(filename,basename);
  94.     f_hex=fopen(strcat(filename,".hex"),"w");
  95.     if (f_hex==(FILE *) NULL)
  96.         {
  97.         printf("Could not open file.hex for write.");
  98.         return;
  99.         }
  100.     for (x=0;x<32767-16;x+=16)
  101.     {
  102.         flag=0;
  103.         for (y=0;y<=15;y++)
  104.             if (mem[x+y]!=0) flag=1;
  105.         if (flag==1)
  106.         {
  107.             hexsflag=1;
  108.             hexs(x);
  109.             hexsflag=0;
  110.             strcpy(longstr,hexstr);
  111.             strcat(longstr,":    ");
  112.             for (y=0;y<=15;y++)
  113.             {
  114.                 hexs(mem[x+y]);
  115.                 strcat(longstr,hexstr);
  116.                 strcat(longstr," ");
  117.                 if (y==7) strcat(longstr," ");
  118.             }
  119.             fprintf(f_hex,"%s\n",longstr);
  120.         }
  121.     }
  122.     fclose(f_hex);
  123.     return;
  124. }    
  125.  
  126. void codeit(t)
  127. char t[80];
  128. {
  129.     char sht[3];
  130.     char tdup[80];
  131.     char buf[80];
  132.     char tdup2[80];
  133.     int ad,x,y;
  134.     strcpy(tdup,t);    
  135.     if (pass==1) return;
  136.     hexsflag=1;
  137.     hexs(addr);
  138.     hexsflag=0;
  139.     sht[2]='\0';
  140.     strcpy(buf,buffer);
  141.     if (strlen(buffer)>50) strnullcpy(buf,buffer,50);
  142.     strcpy(tdup2,tdup);
  143.     if (strlen(tdup)>6) strnullcpy(tdup2,tdup,6);
  144.     fprintf(f_lst,"%5d %4s  %6s   %s\n",line,hexstr,tdup2,buf);
  145.     
  146.     if (tdup[0]!=' ')
  147.     {
  148.         ad=addr;
  149.         for (x=0;x<strlen(tdup);x+=2)
  150.         {
  151.             y=tdup[x]-48;
  152.             if (y>9) y-=7;
  153.             value=y*16;
  154.             y=tdup[x+1]-48;
  155.             if (y>9) y-=7;
  156.             value+=y;    
  157.             mem[ad++]=value;
  158.         }
  159.     }
  160.     return;
  161. }
  162.  
  163. int tag_defined(t)
  164. char t[80];
  165. {
  166.     LINK    list;
  167.     list=tag_list;
  168.     while (list!=(LINK) NULL)
  169.     {
  170.         if (strcmp(t,list->tag)==0)
  171.             return(1);
  172.         list=list->next;
  173.     }
  174.     return(0);
  175. } 
  176.     
  177. void add_tag(val) 
  178. int val;
  179. {
  180.     LINK    list;
  181.     list=tag_list;
  182.     if (list!=(LINK) NULL)
  183.         while (list->next!=(LINK) NULL)
  184.             list=list->next;
  185.     if (list==(LINK) NULL)
  186.     {
  187.         tag_list=(LINK) malloc(sizeof(ELEM));
  188.         strcpy(tag_list->tag,name);
  189.         tag_list->value=val;
  190.         tag_list->next=(LINK) NULL;
  191.     }
  192.     else
  193.     {
  194.         list->next=(LINK) malloc(sizeof(ELEM));
  195.         strcpy(list->next->tag,name);
  196.         list->next->value=val;
  197.         list->next->next=(LINK) NULL;
  198.     }
  199.     return;
  200. } 
  201.  
  202. int validtag(t)
  203. char t[80];
  204. {
  205.     int x;
  206.     for (x=0;x<strlen(t);x++)
  207.     {
  208.         if ((
  209.         ((s[x]>='A')&&(s[x]<='Z'))||
  210.         ((s[x]>='0')&&(s[x]<='9'))||
  211.         (s[x]=='_')
  212.         )==0)
  213.             return(0);
  214.     }
  215.     return(1);
  216. }
  217.         
  218. void gettag(x)
  219. int x;
  220. {
  221.     strnullcpy(name,s,x);
  222.     if (validtag(name)==0)
  223.         cleanexit("Tag contains extranneous characters.");
  224.     if (pass==1)
  225.     {
  226.         if (tag_defined(name)) cleanexit("Tag already defined.");
  227.         add_tag(addr);
  228.     }
  229.     hack(x+1);
  230.     return;
  231. }
  232.  
  233. int testbase(b,c)
  234. int b;
  235. char c;
  236. {
  237.     int n;
  238.     n=((int) c)-48;
  239.  if (n<0) return(-1);
  240.     if ((n>9)&&(n<17)) return(-1);
  241.     if (n>9) n-=7;
  242.     if (n>(b-1)) return(-1);
  243.     return(n);
  244. }
  245.  
  246. void convert(base)
  247. int base;
  248. {
  249.     int x;
  250.     value=0;
  251.     while ((x=testbase(base,s[0]))>=0)
  252.     {
  253.         hack(1);
  254.         value*=base;
  255.         value+=x;
  256.     }
  257.     return;
  258. }
  259.  
  260. int lookup()
  261. {
  262.     LINK    list;
  263.     list=tag_list;
  264.     while (list!=(LINK) NULL)
  265.     {
  266.         if (strcmp(list->tag,name)==0) return(list->value);
  267.         list=list->next;
  268.     }
  269.     cleanexit("Lookup on identifier failed.");
  270. }
  271.  
  272. int regist(t)
  273. char t[80];
  274. {
  275.     if (strcmp(t,"AB")==0) return(18);
  276.     if (strcmp(t,"A")==0) return(1);
  277.     if (strcmp(t,"DPTR")==0) return(4);
  278.     if (t[0]=='R')
  279.         if (((t[1]>='0')&&(t[1]<='7'))&&(t[2]=='\0'))
  280.             return( ((int) t[1]) -38);
  281.     if (strcmp(t,"C")==0) return(3);
  282.     if (strcmp(t,"@DPTR")==0) return(5);
  283.     if (strcmp(t,"@R0")==0) return(8);
  284.     if (strcmp(t,"@R1")==0) return(9);
  285.     return(0);
  286. }
  287.  
  288. int getexp()
  289. {
  290.     int flag,x;
  291.     value=0;
  292.     flag=0;
  293.     if (s[0]=='#')
  294.     {
  295.         hack(1);
  296.         flag=1;
  297.     }
  298.     if (strncmp(s,"H'",2)==0)
  299.     {
  300.         hack(2);
  301.         convert(16,s);
  302.         return(7-flag);
  303.     }
  304.     if (strncmp(s,"B'",2)==0)
  305.     {
  306.         hack(2);
  307.         convert(2,s);
  308.         return(7-flag);
  309.     }
  310.     x=0;
  311.     if (testbase(10,s[0])>=0)
  312.     {
  313.         while(testbase(16,s[x])>=0) x++;
  314.         if (s[x]=='H') {convert(16,s);hack(1);return(7-flag);}
  315.         if (s[x-1]=='B') {convert(2,s);hack(1); return(7-flag);}
  316.         convert(10,s); return(7-flag);
  317.     }
  318.     if (s[0]=='\'')
  319.     {
  320.         hack(1);
  321.         if (s[1]!='\'') cleanexit("Need another single quote.");
  322.         value=(int) s[0];
  323.         hack(2);
  324.         if (flag==0)
  325.         {
  326.             warn("Character constants not advisable here.");
  327.             return(7);
  328.         }
  329.         return(6);
  330.     }
  331.     x=0;
  332.     while (
  333.     (s[0]!=',')&&
  334.     (s[0]!='\0')&&
  335.     (s[0]!='+')&&
  336.     (s[0]!='*')&&
  337.     (s[0]!='-')&&
  338.     (s[0]!=';')&&
  339.     (s[0]!=' ')
  340.     )
  341.     {
  342.         name[x++]=s[0];
  343.         hack(1);
  344.     }
  345.     name[x]='\0';
  346.     while (s[0]==' ') hack(1);
  347.     x=regist(name);
  348.     if (x>0) return(x);
  349.     if (tag_defined(name)==0)
  350.     {
  351.         if (pass==1) {value=0;return(7-flag);}
  352.         cleanexit("Need to define this expression.");
  353.     }
  354.     value=lookup();
  355.     return(7-flag);
  356. }
  357.         
  358. int getbyte()
  359. {
  360.     int v,x,firstx;
  361.     char c;
  362.     x=getexp();    
  363.     v=value;
  364.     firstx=x;
  365.     while ((s[0]=='+')||(s[0]=='-')||(s[0]=='*'))
  366.     {
  367.         c=s[0];
  368.         hack(1);
  369.         x=getexp();
  370.         if (x!=firstx) cleanexit("Expression types must match.");
  371.         switch(c) {
  372.             case '+':
  373.                 v+=value;
  374.                 break;
  375.             case '-':
  376.                 v-=value;
  377.                 break;
  378.             case '*':
  379.                 v*=value;
  380.                 break;
  381.             default:
  382.                 break;
  383.             }
  384.     }
  385.     realvalue=v;
  386.     value=v;
  387.     if (value<-65536) cleanexit("Value out of range.");
  388.     if (value<-128) value+=65536;
  389.     if (value<0) value+=256;
  390.     if (value>65535) cleanexit("Value out of range.");
  391.     return(x);
  392. }
  393.  
  394. void equate()
  395. {
  396.     char left[80];
  397.     int x;
  398.     hack(5);
  399.     x=0;
  400.     while ((s[x]!=',')&&(s[x]!='\0')) x++;
  401.     if (s[x]!=',') cleanexit("Equate needs a comma.");
  402.     strnullcpy(left,s,x);
  403.     if (regist(left)>0) cleanexit("Cannot use registers in equate.");
  404.     hack(x+1);
  405.     codeit("  ->");
  406.     if (pass==2)
  407.     {
  408.         x=getbyte();
  409.         return;
  410.     }
  411.     if (tag_defined(left)==1)
  412.         cleanexit("Identifier already defined.");
  413.     if (getbyte()!=7) cleanexit("Value must be a byte/word.");
  414.     strcpy(name,left);
  415.     add_tag(value);
  416.     return;
  417. }
  418.  
  419. void origin()
  420. {
  421.     hack(5);
  422.     if (getbyte()!=7) cleanexit("Must be byte/word.");
  423.     if (pass==2) codeit("  ->");
  424.     addr=value;
  425.     return;
  426. }
  427.  
  428. void defbyte()
  429. {
  430.     hack(4);
  431.     if (getbyte()!=7) cleanexit("Must be byte.");
  432.     if (value>255) cleanexit("Byte value out of range.");
  433.     if (pass==2)
  434.     {
  435.         hexs(value);
  436.         codeit(hexstr);
  437.     }
  438.     addr+=1;
  439.     return;
  440. }
  441.  
  442. void defword()
  443. {
  444.     hack(4);
  445.     if (getbyte()!=7) cleanexit("Must be word.");
  446.     if (pass==2)
  447.     {
  448.         hexsflag=1;
  449.         hexs(value);
  450.         hexsflag=0;
  451.         codeit(hexstr);
  452.     }
  453.     addr+=2;
  454.     return;
  455. }
  456.  
  457. void defmsg()
  458. {
  459.     char t[80];
  460.     int x;
  461.     hack(4);
  462.     if (s[0]!='\'')
  463.         cleanexit("Must start with single quote.");
  464.     hack(1);
  465.     t[0]='\0';
  466.     for (x=0;x<=pos;x++)
  467.     {
  468.         if (s[x]=='\'')
  469.         {
  470.             if (pass==2) codeit(t);
  471.             addr+=x;
  472.             hack(x+1);
  473.             return;
  474.         }
  475.         if (pass==2)
  476.         {
  477.             hexs(s[x]);
  478.             strcat(t,hexstr);
  479.         }
  480.     }
  481.     cleanexit("Must end with single quote.");
  482. }
  483.  
  484. void reserve()
  485. {
  486.     hack(4);
  487.     if (getbyte()!=7) cleanexit("Must be byte/word.");
  488.     if (pass==2) codeit("  ->");
  489.     addr+=value;
  490.     return;
  491. }
  492.  
  493. void endassm()
  494. {
  495.     hack(4);
  496.     return;
  497. }
  498.  
  499. void getdirec()
  500. {
  501.     if (strncmp(s,".EQU",4)==0) {equate();return;}
  502.     if (strncmp(s,".ORG",4)==0) {origin();return;}
  503.     if (strncmp(s,".DB",3)==0) {defbyte();return;}
  504.     if (strncmp(s,".DW",3)==0) {defword();return;}
  505.     if (strncmp(s,".DM",3)==0) {defmsg();return;}
  506.     if (strncmp(s,".RS",3)==0) {reserve();return;}
  507.     if (strncmp(s,".END",3)==0) {endassm();return;}
  508.     cleanexit("Compiler directive not understood.");
  509. }
  510.  
  511. void get2()
  512. {
  513.     mi=1;
  514.     lop=getbyte();
  515.     lval=value;
  516.     if ((lop==6)||(lop==7)) mi++;
  517.     if (lval>255) cleanexit("Left operator value > 255.");
  518.     if (s[0]!=',')
  519.         cleanexit("This statement needs two operands.");
  520.     hack(1);
  521.     rop=getbyte();
  522.     rval=value;
  523.     if ((rop==6)||(rop==7)) mi++;
  524.     if (rval>255) cleanexit("Right operator value > 255.");
  525.     return;
  526. }
  527.  
  528. void get1()
  529. {
  530.     mi=1;
  531.     lop=getbyte();
  532.     lval=value;
  533.     if ((lop==6)||(lop==7)) mi++;
  534.     if (lval>255) cleanexit("Operator value > 255.");
  535.     return;
  536. }
  537.  
  538. void addr11()
  539. {
  540.     lop=getbyte();
  541.     if (lop!=7) cleanexit("Operand must be an address.");
  542.     if (pass==1) {value=0;return;}
  543.     if ((value&63488)!=(addr&63488))
  544.         cleanexit("11 bit address out of range.");
  545.     value&=2047;
  546.     return;
  547. }
  548.  
  549. void addr16()
  550. {
  551.     lop=getbyte();
  552.     if (lop!=7) cleanexit("Operand must be an address.");
  553.     return;
  554. }
  555.  
  556. void data16()
  557. {
  558.     lop=getbyte();
  559.     if (lop!=6) cleanexit("Operand must be data.");
  560.     return;
  561. }
  562.  
  563. int getrel()
  564. {
  565.     int x,r;
  566.     x=getbyte();
  567.     if (x!=7) cleanexit("Operand must be an address.");
  568.     if (pass==1) {return(0);} 
  569.     r=realvalue-(addr+mi);
  570.     if (r<-128) cleanexit("Relative offset < -128.");
  571.     if (r>127) cleanexit("Relative offset > 127.");
  572.     if (r<0) r+=256;
  573.     return(r);
  574. }
  575.  
  576.  
  577. void ljmp()
  578. {
  579.     hack(5);
  580.     addr16();
  581.     hexs(02*65536+value);
  582.     codeit(hexstr);
  583.     addr+=3;
  584. }
  585.  
  586. void form0(n)
  587. int n;
  588. {
  589.     mi=2;
  590.     hexs(n*256+getrel());
  591.     codeit(hexstr);
  592.     addr+=mi;
  593. }
  594.  
  595. void sjmp()
  596. {
  597.     hack(5);
  598.     form0(128);
  599. }
  600.  
  601. jc()
  602. {
  603.     hack(3);
  604.     form0(64);
  605. }
  606.  
  607. jnc()
  608. {
  609.     hack(4);
  610.     form0(80);
  611. }
  612.  
  613. void form1(n)
  614. int n;
  615. {
  616.     get1();
  617.     mi++;
  618.     if (lop!=7) cleanexit("Left operand must be bit address.");
  619.     if (s[0]!=',') cleanexit("This command needs two operands.");
  620.     hack(1);
  621.     hexs(n*65536+lval*256+getrel());
  622.     codeit(hexstr);
  623.     addr+=mi;
  624. }
  625.  
  626. void jb()
  627. {
  628.     hack(3);
  629.     form1(32);
  630. }
  631.  
  632. void jnb()
  633. {
  634.     hack(4);
  635.     form1(48);
  636. }
  637.  
  638. void jbc()
  639. {
  640.     hack(4);
  641.     form1(16);
  642. }
  643.     
  644. void form2(n)
  645. int n;
  646. {
  647.     int x,y;
  648.     addr11();
  649.     x=(value/256)<<5;
  650.     x+=n;
  651.     y=(value%256);
  652.     hexs(x*256+y);
  653.     codeit(hexstr);
  654.     addr+=2;
  655. }
  656.  
  657. void ajmp()
  658. {
  659.     hack(5);
  660.     form2(1);
  661.     }
  662.  
  663. void acall()
  664. {
  665.     hack(6);
  666.     form2(17);
  667. }
  668.  
  669. void lcall()
  670. {
  671.     hack(6);
  672.     addr16();
  673.     hexs(18*65536+value);
  674.     codeit(hexstr);
  675.     addr+=3;
  676. }
  677.  
  678. void jz()
  679. {
  680.     hack(3);
  681.     form0(96);
  682. }
  683.  
  684. void jnz()
  685. {
  686.     hack(4);
  687.     form0(112);
  688. }
  689.  
  690. void djnz()
  691. {
  692.     hack(5);
  693.     get1();
  694.     if (s[0]!=',') cleanexit("This statement needs two operands.");
  695.     hack(1);
  696.     mi++;
  697.     if (lop==7)
  698.     {
  699.         hexs(213*65536+lval*256+getrel());
  700.         codeit(hexstr);
  701.         addr+=mi;
  702.         return;
  703.     }
  704.     if ((lop>=10)&&(lop<=17))
  705.     {
  706.         hexs((216-10+lop)*256+getrel());
  707.         codeit(hexstr);
  708.         addr+=mi;
  709.         return;
  710.     }
  711.     cleanexit("Left operand must be a direct addr or Rn.");
  712. }
  713.  
  714. void cjne()
  715. {
  716.     hack(5);
  717.     get2();
  718.     if (s[0]!=',') cleanexit("This statement needs 3 operands.");
  719.     hack(1);
  720.     mi++;
  721.     if (lop==1)
  722.     {
  723.         if (rop==6)
  724.         {
  725.             hexs(180*65536+rval*256+getrel());
  726.             codeit(hexstr);
  727.             addr+=mi;
  728.             return;
  729.         }
  730.         if (rop==7)
  731.         {
  732.             hexs(181*65536+rval*256+getrel());
  733.             codeit(hexstr);
  734.             addr+=mi;
  735.             return;
  736.         }
  737.         cleanexit("Middle operand must be # or $.");
  738.     }
  739.     if ((lop>=8)&&(lop<=17))
  740.     {
  741.         if (rop!=6) cleanexit("Middle operand must be #.");
  742.         hexs((182-8+lop)*65536+rval*256+getrel());
  743.         codeit(hexstr);
  744.         addr+=mi;
  745.         return;
  746.     }
  747.     cleanexit("Left operand must be A,@Ri, or Rn.");
  748. }
  749.  
  750. void movdptr()
  751. {
  752.     hack(8);
  753.     if (s[0]!=',') cleanexit("Comma needed.");
  754.     hack(1);
  755.     data16();
  756.     hexs(144*65536+value);
  757.     codeit(hexstr);
  758.     addr+=3;
  759.     return;
  760. }
  761.  
  762. void form4(n)
  763. int n;
  764. {
  765.     get2();
  766.     if (lop!=1) cleanexit("Left operand must be A.");
  767.     if ((rop>=6)&&(rop<=17))
  768.     {
  769.         hexs(n-6+rop);
  770.         if ((rop==6)||(rop==7))
  771.         {
  772.             hexs((n-6+rop)*256+rval);
  773.         }
  774.         codeit(hexstr);
  775.         addr+=mi;
  776.         return;
  777.     }
  778.     cleanexit("Right operand must be #,$,@Ri, or Rn.");
  779. }
  780.  
  781. void addc()
  782. {
  783.     hack(5);
  784.     form4(52);
  785. }
  786.  
  787. void add()
  788. {
  789.     hack(4);
  790.     form4(36);
  791. }
  792.  
  793. void subb()
  794. {
  795.     hack(5);
  796.     form4(148);
  797. }
  798.  
  799. void inc()
  800. {
  801.     hack(4);
  802.     get1();
  803.     if (lop==1) lop=6;
  804.     if ((lop>=6)&&(lop<=17))
  805.     {
  806.         hexs(4-6+lop);
  807.         if (lop==7)
  808.             hexs((4-6+lop)*256+lval);
  809.         codeit(hexstr);
  810.         addr+=mi;
  811.         return;
  812.     }
  813.     if (lop==4)
  814.     {
  815.         hexs(163);
  816.         codeit(hexstr);
  817.         addr+=mi;
  818.         return;
  819.     }
  820.     cleanexit("Operand must be A,$,@Ri, Rn, or DPTR.");
  821. }
  822.  
  823. void dec()
  824. {
  825.     hack(4);
  826.     get1();
  827.     if (lop==1) lop=6;
  828.     if ((lop>=6)&&(lop<=17))
  829.     {
  830.         hexs(20-6+lop);
  831.         if (lop==7)
  832.             hexs((20-6+lop)*256+lval);
  833.         codeit(hexstr);
  834.         addr+=mi;
  835.         return;
  836.     }
  837.     cleanexit("Operand must be A,$,@Ri, or Rn.");
  838. }
  839.  
  840. void mul()
  841. {
  842.     hack(4);
  843.     get1();
  844.     if (lop!=18) cleanexit("Operand must be AB.");
  845.     hexs(164);
  846.     codeit(hexstr);
  847.     addr++;
  848. }
  849.  
  850. void div()
  851. {
  852.     hack(4);
  853.     get1();
  854.     if (lop!=18) cleanexit("Operand must be AB.");
  855.     hexs(132);
  856.     codeit(hexstr);
  857.     addr++;
  858. }
  859.  
  860. void da()
  861. {
  862.     hack(3);
  863.     get1();
  864.     if (lop!=1) cleanexit("Operand must be A.");
  865.     hexs(212);
  866.     codeit(hexstr);
  867.     addr++;
  868. }
  869.  
  870. void form5(n,m,o,p)
  871. int n;
  872. int m;
  873. int o;
  874. int p;
  875. {
  876.     get2();
  877.     if (lop==1)
  878.     {
  879.         if ((rop>=6)&&(rop<=17))
  880.         {
  881.             hexs(n-8+rop);
  882.             if ((rop==6)||(rop==7))
  883.                 hexs((m-6+rop)*256+rval);
  884.             codeit(hexstr);
  885.             addr+=mi;
  886.             return;
  887.         }
  888.         cleanexit("Right OP must be #,$,@Ri, or Rn.");
  889.     }
  890.     if (lop==7)
  891.     {
  892.         if (rop==1)
  893.         {
  894.             hexs(o*256+lval);
  895.             codeit(hexstr);
  896.             addr+=mi;
  897.             return;
  898.         }
  899.         if (rop==6)
  900.         {
  901.             hexs((o+1)*65536+lval*256+rval);
  902.             codeit(hexstr);
  903.             addr+=mi;
  904.             return;
  905.         }
  906.         cleanexit("Right operand must be A or #.");
  907.     }
  908.     if (lop==3)
  909.     {
  910.         if (rop==7)
  911.         {
  912.             hexs(p*256+rval);
  913.             codeit(hexstr);
  914.             addr+=mi;
  915.             return;
  916.         }
  917.         cleanexit("Right operand must be bit address.");
  918.     }
  919.     cleanexit("Left operand must be A, C, or $.");
  920. }
  921.  
  922. void orl()
  923. {
  924.     hack(4);
  925.     form5(70,68,66,114);
  926. }
  927.  
  928. void anl()
  929. {
  930.     hack(4);
  931.     form5(86,84,82,130);
  932. }
  933.  
  934. void xrl()
  935. {
  936.     hack(4);
  937.     get2();
  938.     if (lop==1)
  939.     {
  940.         if ((rop>=6)&&(rop<=17))
  941.         {
  942.             hexs(100-6+rop);
  943.             if ((rop==6)||(rop==7))
  944.                 hexs((100-6+rop)*256+rval);
  945.             codeit(hexstr);
  946.             addr+=mi;
  947.             return;
  948.         }
  949.         cleanexit("Right OP must be #,$,@Ri, or Rn.");
  950.     }
  951.     if (lop==7)
  952.     {
  953.         if (rop==1)
  954.         {
  955.             hexs(98*256+lval);
  956.             codeit(hexstr);
  957.             addr+=mi;
  958.             return;
  959.         }
  960.         if (rop==6)
  961.         {
  962.             hexs(99*65536+lval*256+rval);
  963.             codeit(hexstr);
  964.             addr+=mi;
  965.             return;
  966.         }
  967.         cleanexit("Right operand must be A or #.");
  968.     }
  969.     cleanexit("Left operand must be A or $.");
  970. }
  971.  
  972. void form6(n,m,o)
  973. int m,n,o;
  974. {
  975.     get1();
  976.     if (lop==1)
  977.     {
  978.         hexs(n);
  979.         codeit(hexstr);
  980.         addr++;
  981.         return;
  982.     }
  983.     if (lop==3)
  984.     {
  985.         hexs(m);
  986.         codeit(hexstr);
  987.         addr++;
  988.         return;
  989.     }
  990.     if (lop==7)
  991.     {
  992.         hexs(o*256+lval);
  993.         codeit(hexstr);
  994.         addr+=2;
  995.         return;
  996.     }
  997.     cleanexit("Operand must be A, C, or $.");
  998. }
  999.  
  1000. void clr()
  1001. {
  1002.     hack(4);
  1003.     form6(228,195,194);
  1004. }
  1005.  
  1006. void cpl()
  1007. {
  1008.     hack(4);
  1009.     form6(244,179,178);
  1010. }
  1011.  
  1012. void setb()
  1013. {
  1014.     hack(5);
  1015.     get1();
  1016.     if (lop==3)
  1017.     {
  1018.         hexs(211);
  1019.         codeit(hexstr);
  1020.         addr++;
  1021.         return;
  1022.     }
  1023.     if (lop==7)
  1024.     {
  1025.         hexs(210*256+lval);
  1026.         codeit(hexstr);
  1027.         addr+=2;
  1028.         return;
  1029.     }
  1030.     cleanexit("Operand must be C or $.");
  1031. }
  1032.  
  1033. void form7(n)
  1034. int n;
  1035. {
  1036.     get1();
  1037.     if (lop!=1) cleanexit("Operand must be A.");
  1038.     hexs(n);
  1039.     codeit(hexstr);
  1040.     addr++;
  1041. }
  1042.  
  1043. void rl()
  1044. {
  1045.     hack(3);
  1046.     form7(35);
  1047. }
  1048.  
  1049. void rlc()
  1050. {
  1051.     hack(4);
  1052.     form7(51);
  1053. }
  1054.  
  1055. void rr()
  1056. {
  1057.     hack(3);
  1058.     form7(3);
  1059. }
  1060.  
  1061. void rrc()
  1062. {
  1063.     hack(4);
  1064.     form7(19);
  1065. }
  1066.  
  1067. void swap()
  1068. {
  1069.     hack(5);
  1070.     form7(196);
  1071. }
  1072.  
  1073. void mov()
  1074. {
  1075.     hack(4);
  1076.     get2();
  1077.     if (lop==1)
  1078.     {
  1079.         if ((rop>=7)&&(rop<=17))
  1080.         {
  1081.             hexs(229-7+rop);
  1082.             if (rop==7)
  1083.                 hexs(229*256+rval);
  1084.             codeit(hexstr);
  1085.             addr+=mi;
  1086.             return;
  1087.         }
  1088.         if (rop==6)
  1089.         {
  1090.             hexs(116*256+rval);
  1091.             codeit(hexstr);
  1092.             addr+=mi;
  1093.             return;
  1094.         }
  1095.         cleanexit("Right operand must be #,$,@Ri, or Rn.");
  1096.     }
  1097.     if ((lop>=8)&&(lop<=17))
  1098.     {
  1099.         if (rop==1)
  1100.         {
  1101.             hexs(245-8+lop);
  1102.             if (lop==7)
  1103.                 hexs((245-8+lop)*256+rval);
  1104.             codeit(hexstr);
  1105.             addr+=mi;
  1106.             return;
  1107.         }
  1108.         if (rop==7)
  1109.         {
  1110.             hexs((166-8+lop)*256+rval);
  1111.             codeit(hexstr);
  1112.             addr+=mi;
  1113.             return;
  1114.         }
  1115.         if (rop==6)
  1116.         {
  1117.             hexs((118-8+lop)*256+rval);
  1118.             codeit(hexstr);
  1119.             addr+=mi;
  1120.             return;
  1121.         }
  1122.         cleanexit("Right operand must be A,#, or $.");
  1123.     }
  1124.     if (lop==7)
  1125.     {
  1126.         if ((rop>=7)&&(rop<=17))
  1127.         {
  1128.             hexs((133-7+rop)*256+lval);
  1129.             if (rop==7)
  1130.                 hexs(133*65536+lval*256+rval);
  1131.             codeit(hexstr);
  1132.             addr+=mi;
  1133.             return;
  1134.         }
  1135.         if (rop==6)
  1136.         {
  1137.             hexs(117*65536+lval*256+rval);
  1138.             codeit(hexstr);
  1139.             addr+=mi;
  1140.             return;
  1141.         }
  1142.         if (rop==3)
  1143.         {
  1144.             hexs(146*256+lval);
  1145.             codeit(hexstr);
  1146.             addr+=mi;
  1147.             return;
  1148.         }
  1149.         if (rop==1)
  1150.         {
  1151.             hexs(245*256+lval);
  1152.             codeit(hexstr);
  1153.             addr+=mi;
  1154.             return;
  1155.         }
  1156.         cleanexit("Right operand must be #,$, @Ri, or Rn.");
  1157.     }
  1158.     if (lop==3)
  1159.     {
  1160.         if (rop!=7) cleanexit("Right operand must be bit addr.");
  1161.         hexs(162*256+rval);
  1162.         codeit(hexstr);
  1163.         addr+=mi;
  1164.         return;
  1165.     }
  1166.     cleanexit("Left operand must be A,$, or C.");
  1167. }
  1168.  
  1169. void movx()
  1170. {
  1171.     hack(5);
  1172.     get2();
  1173.     if (lop==1)
  1174.     {
  1175.         if (rop==5)
  1176.         {
  1177.             hexs(224);
  1178.             codeit(hexstr);
  1179.             addr++;
  1180.             return;
  1181.         }
  1182.         if (rop==8)
  1183.         {
  1184.             hexs(226);
  1185.             codeit(hexstr);
  1186.             addr++;
  1187.             return;
  1188.         }
  1189.         if (rop==9)
  1190.         {
  1191.             hexs(227);
  1192.             codeit(hexstr);
  1193.             addr++;
  1194.             return;
  1195.         }
  1196.         cleanexit("Right operand must be @Ri, or @DPTR.");
  1197.     }
  1198.     if (lop==5)
  1199.     {
  1200.         if (rop!=1) cleanexit("Right OP must be A.");
  1201.         hexs(240);
  1202.         codeit(hexstr);
  1203.         addr++;
  1204.         return;
  1205.     }
  1206.     if (lop==8)
  1207.     {
  1208.         if (rop!=1) cleanexit("Right OP must be A.");
  1209.         hexs(242);
  1210.         codeit(hexstr);
  1211.         addr++;
  1212.         return;
  1213.     }
  1214.     if (lop==9)
  1215.     {
  1216.         if (rop!=1) cleanexit("Right OP must be A.");
  1217.         hexs(243);
  1218.         codeit(hexstr);
  1219.         addr++;
  1220.         return;
  1221.     }
  1222.     cleanexit("Left operand must be A,@Ri, or @DPTR.");
  1223. }
  1224.  
  1225. void pop()
  1226. {
  1227.     hack(4);
  1228.     get1();
  1229.     if (lop!=7) cleanexit("Operand must be direct byte.");
  1230.     hexs(208*256+lval);
  1231.     codeit(hexstr);
  1232.     addr+=mi;
  1233. }
  1234.  
  1235. void push()
  1236. {
  1237.     hack(5);
  1238.     get1();
  1239.     if (lop!=7) cleanexit("Operand must be direct byte.");
  1240.     hexs(192*256+lval);
  1241.     codeit(hexstr);
  1242.     addr+=mi;
  1243. }
  1244.  
  1245. void form8(n)
  1246. int n;
  1247. {
  1248.     hexs(n);
  1249.     codeit(hexstr);
  1250.     addr++;
  1251.     return;
  1252. }
  1253.  
  1254. void ret()
  1255. {
  1256.     hack(3);
  1257.     form8(34);
  1258. }
  1259.  
  1260. void reti()
  1261. {
  1262.     hack(4);
  1263.     form8(50);
  1264. }
  1265.  
  1266. void nop()
  1267. {
  1268.     hack(3);
  1269.     form8(0);
  1270. }
  1271.  
  1272. void xch()
  1273. {
  1274.     hack(4);
  1275.     get2();
  1276.     if (lop!=1) cleanexit("Left operand must be A.");
  1277.     if ((rop>=7)&&(rop<=17))
  1278.     {
  1279.         hexs(197-7+rop);
  1280.         if (rop==7) hexs((197-7+rop)*256+rval);
  1281.         codeit(hexstr);
  1282.         addr+=mi;
  1283.         return;
  1284.     }
  1285.     cleanexit("Right operand must be $,@Ri, or Rn.");
  1286. }
  1287.  
  1288. void xchd()
  1289. {
  1290.     hack(5);
  1291.     get2();
  1292.     if (lop!=1) cleanexit("Left operand must be A.");
  1293.     if ((rop>=8)&&(rop<=17))
  1294.     {
  1295.         hexs(214-8+rop);
  1296.         codeit(hexstr);
  1297.         addr++;
  1298.         return;
  1299.     }
  1300.     cleanexit("Right operand must be @Ri.");
  1301. }
  1302.  
  1303. void movcadptr()
  1304. {
  1305.     hack(14);
  1306.     hexs(147);
  1307.     codeit(hexstr);
  1308.     addr++;
  1309. }
  1310.  
  1311. void movcapc()
  1312. {
  1313.     hack(12);
  1314.     hexs(131);
  1315.     codeit(hexstr);
  1316.     addr++;
  1317. }
  1318.  
  1319. void jmpadptr()
  1320. {
  1321.     hack(11);
  1322.     hexs(115);
  1323.     codeit(hexstr);
  1324.     addr++;
  1325. }
  1326.  
  1327. void opcode()
  1328. {
  1329.     if (strncmp(s,"ADDC ",5)==0) {addc();return;}
  1330.     if (strncmp(s,"ADD ",4)==0) {add();return;}
  1331.     if (strncmp(s,"SUBB ",5)==0) {subb();return;}
  1332.     if (strncmp(s,"INC ",4)==0) {inc();return;}
  1333.     if (strncmp(s,"DEC ",4)==0) {dec();return;}
  1334.     if (strncmp(s,"MUL ",4)==0) {mul();return;}
  1335.     if (strncmp(s,"DIV ",4)==0) {div();return;}
  1336.     if (strncmp(s,"DA ",3)==0) {da();return;}
  1337.     if (strncmp(s,"ANL ",4)==0) {anl();return;}
  1338.     if (strncmp(s,"ORL ",4)==0) {orl();return;}
  1339.     if (strncmp(s,"XRL ",4)==0) {xrl();return;}
  1340.     if (strncmp(s,"CPL ",4)==0) {cpl();return;}
  1341.     if (strncmp(s,"RLC ",4)==0) {rlc();return;}
  1342.     if (strncmp(s,"RR ",3)==0) {rr();return;}
  1343.     if (strncmp(s,"RRC ",4)==0) {rrc();return;}
  1344.     if (strncmp(s,"RL ",3)==0) {rl();return;}
  1345.     if (strncmp(s,"SWAP ",5)==0) {swap();return;}
  1346.     if (strncmp(s,"MOVX ",5)==0) {movx();return;}
  1347.     if (strncmp(s,"MOV DPTR",8)==0) {movdptr();return;}
  1348.     if (strncmp(s,"MOVC A,@A+DPTR",14)==0) {movcadptr();return;}
  1349.     if (strncmp(s,"MOVC A,@A+PC",12)==0) {movcapc();return;}
  1350.     if (strncmp(s,"JMP @A+DPTR",11)==0) {jmpadptr();return;}
  1351.     if (strncmp(s,"MOV ",4)==0) {mov();return;}
  1352.     if (strncmp(s,"PUSH ",5)==0) {push();return;}
  1353.     if (strncmp(s,"POP ",4)==0) {pop();return;}
  1354.     if (strncmp(s,"XCHD ",5)==0) {xchd();return;}
  1355.     if (strncmp(s,"XCH ",4)==0) {xch();return;}
  1356.     if (strncmp(s,"CLR ",4)==0) {clr();return;}
  1357.     if (strncmp(s,"SETB ",5)==0) {setb();return;}
  1358.     if (strncmp(s,"JC ",3)==0) {jc();return;}
  1359.     if (strncmp(s,"JNC ",4)==0) {jnc();return;}
  1360.     if (strncmp(s,"JNB ",4)==0) {jnb();return;}
  1361.     if (strncmp(s,"JBC ",4)==0) {jbc();return;}
  1362.     if (strncmp(s,"JB ",3)==0) {jb();return;}
  1363.     if (strncmp(s,"ACALL ",6)==0) {acall();return;}
  1364.     if (strncmp(s,"LCALL ",6)==0) {lcall();return;}
  1365.     if (strncmp(s,"RETI",4)==0) {reti();return;}
  1366.     if (strncmp(s,"RET",3)==0) {ret();return;}
  1367.     if (strncmp(s,"SJMP ",5)==0) {sjmp();return;}
  1368.     if (strncmp(s,"LJMP ",5)==0) {ljmp();return;}
  1369.     if (strncmp(s,"AJMP ",5)==0) {ajmp();return;}
  1370.     if (strncmp(s,"JZ ",3)==0) {jz();return;}
  1371.     if (strncmp(s,"JNZ ",4)==0) {jnz();return;}
  1372.     if (strncmp(s,"CJNE ",5)==0) {cjne();return;}
  1373.     if (strncmp(s,"DJNZ ",5)==0) {djnz();return;}
  1374.     if (strncmp(s,"NOP",3)==0) {nop();return;}
  1375.     if ((s[0]>32)&&(s[0]<127)) 
  1376.         warn("Syntax Error.");
  1377.     return;
  1378. }
  1379.  
  1380. void assemble()
  1381. {
  1382.     int x,y;
  1383.     while (s[0]==' ') hack(1);
  1384.     if (s[0]==';') {codeit("  **"); return;}
  1385.     y=(-1); x=0;
  1386.     do
  1387.     {
  1388.         if (s[x]==';')        
  1389.             y=x;
  1390.         x++;
  1391.     } while ((x<=pos)&&(y<0));
  1392.     if (y>=0)
  1393.     {
  1394.         s[y]='\0';
  1395.         pos=y;
  1396.     }
  1397.  
  1398.     while (s[0]==':')
  1399.     {
  1400.     warn (": at beginning of line.");
  1401.     hack(1);
  1402.     }
  1403.     
  1404.     for (x=0;x<=pos;x++)
  1405.         if (s[x]==':')
  1406.         {
  1407.             if (pass==1) gettag(x);
  1408.             else hack(x+1);
  1409.             while (s[0]==' ') hack(1);
  1410.             if (s[0]=='\0') codeit(" --]");
  1411.         }
  1412.     while (s[0]==' ') hack(1);    
  1413.     if (s[0]=='.') {getdirec();return;}
  1414.     opcode();
  1415.     return;
  1416. }
  1417.  
  1418. int getline()
  1419. {
  1420.     int x;
  1421.     x=0;
  1422.     while ((c=fgetc(f))<32)
  1423.     {
  1424.         if (c=='\n')
  1425.              {strcpy(buffer,"    ");line++;codeit("     ");}
  1426.         if (c==EOF) return(-1);
  1427.     }
  1428.     buffer[x++]=c;
  1429.     while ((c=fgetc(f))!='\n')
  1430.         buffer[x++]=c;
  1431.     buffer[x]='\0';
  1432.     return(x);
  1433. }
  1434.  
  1435. void main(argc,argv)
  1436. int argc;
  1437. char *argv[];
  1438. {
  1439.     int n,x,y,last,white;
  1440.     char filename[80];
  1441.     LINK tl;
  1442.     tag_list=(LINK) NULL;
  1443.     printf("8051 assembler by Eric Rudolph, 1991. Version 1.\n");
  1444.     strcpy(basename,argv[1]);
  1445.     strcpy(filename,basename);
  1446.     f=fopen("a51.equ","r");
  1447.     if (f==(FILE *) NULL)
  1448.         printf("Could not find asm.equ file.\n");
  1449.     else
  1450.         do
  1451.         {
  1452.             fscanf(f,"%s",name);
  1453.             fscanf(f,"%d",&value);
  1454.             if (value>0) add_tag(value);
  1455.         } while (value>0);
  1456.     for (x=0;x<32767;x++)
  1457.         mem[x]=0;
  1458.     
  1459.     f=fopen(filename,"r");
  1460.     hexsflag=0;
  1461.     if (f!=(FILE *) NULL)
  1462.     {
  1463.         printf("PASS1\n");
  1464.         addr=0;pass=1;line=0;
  1465.         do
  1466.         {
  1467.             n=getline();
  1468.             if (n>0)
  1469.             {
  1470.                 line++;
  1471.                 y=0;
  1472.                 last=1;
  1473.                 for (x=0;x<=n;x++)
  1474.                 {
  1475.                     white=0;
  1476. if ((buffer[x]==' ')||(buffer[x]=='\t'))
  1477.     white=1;
  1478. if ((white==1)&&(last==0))
  1479.     s[y++]=' ';
  1480. if (white==0)
  1481. {
  1482.     s[y]=buffer[x];
  1483.     if ((buffer[x]>='a')&&(buffer[x]<='z')) s[y]-=32;
  1484.     y++;
  1485. }
  1486.                     last=white;
  1487.                 }
  1488.                 pos=strlen(s);
  1489.                 if (s[pos-1]==' ') {s[pos-1]='\0';pos--;}
  1490.                 assemble();
  1491.             }
  1492.         } while (n>=1);
  1493.         fclose(f);
  1494.         printf("PASS2\n");
  1495.         f=fopen(filename,"r");
  1496.         strcat(filename,".lst");
  1497.         f_lst=fopen(filename,"w");
  1498.         if (f_lst==(FILE *) NULL) cleanexit("Can't open .lst for write.");
  1499.         addr=0;pass=2;line=0;
  1500.         do
  1501.         {
  1502.             n=getline();
  1503.             if (n>0)
  1504.                 {
  1505.                 line++;
  1506.                 y=0;
  1507.                 last=1;
  1508.                 for (x=0;x<=n;x++)
  1509.                 {
  1510.                     white=0;
  1511. if ((buffer[x]==' ')||(buffer[x]=='\t'))
  1512.     white=1;
  1513. if ((white==1)&&(last==0))
  1514.     s[y++]=' ';
  1515. if (white==0)
  1516. {
  1517.     s[y]=buffer[x];
  1518.     if ((buffer[x]>='a')&&(buffer[x]<='z')) s[y]-=32;
  1519.     y++;
  1520. }
  1521.                     last=white;
  1522.                 }
  1523.                 pos=strlen(s);
  1524.                 if (s[pos-1]==' ') {s[pos-1]='\0';pos--;}
  1525.                 assemble();
  1526.             }
  1527.         } while (n>=1);
  1528.         fprintf(f_lst,"=============================\n");
  1529.         tl=tag_list;
  1530.         x=0;
  1531.         hexsflag=0;
  1532.         while (tl!=(LINK) NULL)
  1533.         {
  1534.             if (x==0) fprintf(f_lst,"\n");
  1535.             else fprintf(f_lst,"\t");
  1536.             hexs(tl->value);
  1537.             fprintf(f_lst,"%s\t%s",tl->tag,hexstr);
  1538.             tl=tl->next;
  1539.         }
  1540.         fprintf(f_lst,"\n\n");
  1541.         fclose(f_lst);
  1542.         showcode();
  1543.         printf("END OF ASSEMBLY.\n");
  1544.     }
  1545.     else 
  1546.         printf("No such file.\n");
  1547.     
  1548. }
  1549.  
  1550.