home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / program / 177 / c / mwtodri.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-09-15  |  6.3 KB  |  257 lines
  1. /*
  2.     mwtodr.c
  3.  a program to convert from MWC format executables to
  4.  DRI format executables. Rearranges things and convert the the symbol table
  5.  entries.
  6.  
  7. All right reserved David DeGeorge September 5,1987.
  8. This program and it's source may be freely distributed on a not for profit
  9. basis only
  10. */
  11.  
  12.  
  13.  
  14. #include <nout.h>
  15. #include <gemout.h>
  16. #include <stdio.h>
  17. #include <canon.h>
  18.  
  19. /* usefuls */
  20. #define min(a,b) ( a > b ? b : a)
  21. #define READ 0
  22. #define WRITE 1
  23.  
  24. /* defines for flag conversion */
  25. #define DEFINED 0x8000
  26. #define GLOBAL 0x2000
  27. #define DATABASED 0x400
  28. #define TEXTBASED 0x200
  29. #define BSSBASED 0x100
  30.  
  31. char copyright[] = "Copyright 1987 David DeGeorge";
  32. char mwccopyr[] = "Portions of the program copyright 1984 Mark Williams Co.";
  33. /* some constants */
  34. #define BIGBUF 512*32   /* a biggish buffer make it bigger goes faster */
  35. #define NSYM 300    /* number of symbols to do at a wack */
  36. #define SMW sizeof(struct ldsym)    /* 22 MWC symbols */
  37. #define SGM sizeof(struct gemsym)   /* 14 DRI symbols */
  38. long _stksize=4000L;   /* to be safe registers get saved on our stack */
  39.  
  40. /* our globals */
  41. char * buffer;
  42. struct gemohdr gemhead;
  43. struct ldsym *cymbals;
  44. struct ldheader marky;
  45. struct gemsym *gsyms;
  46. long look40();
  47.  
  48.    main ( argc,argv)
  49.    int argc;
  50.    char ** argv;
  51.    {
  52.        int     infd,        /* file descriptors */
  53.             outfd;
  54.         long     syms,        /* counters */
  55.                  nsyms,
  56.                nreloc = 4L;
  57.        char     msg[80];    /* for messages */
  58.        
  59.    /* check to see if enuff arguments and if there are ok */
  60.           if ( argc != 3) usage();
  61.        if(strcmp(argv[1],argv[2])== 0 ) 
  62.         abort("Infile and outfile must be different\n\r");
  63.         
  64.    /* allocate space for the buffers */
  65.        if ( ( buffer = malloc(BIGBUF) ) == (char *) 0 ){
  66.             sprintf(msg,"Can't allocate %d  bytes\n\r",BIGBUF);
  67.             abort(msg);
  68.         }
  69.        if ( (cymbals = malloc(NSYM*SMW )) == (char *) 0 ){
  70.             sprintf(msg,"Can't allocate for symbols");
  71.             abort(msg);
  72.         }
  73.         
  74.        if ( ( gsyms = malloc(NSYM*SGM )) == (char *) 0 ){
  75.             sprintf(msg,"Can't allocate for symbols\n\r");
  76.             abort(msg);
  77.         }
  78.     
  79.    /* open the input file and check to see if executable and
  80.        then if MWC format */        
  81.        if ( (infd = open(argv[1],READ)) < 0 ){
  82.            sprintf(msg,"Can't open %s for reading\n\r",argv[1]);
  83.            abort(msg);
  84.        }
  85.           read( infd,&gemhead,sizeof(gemhead));
  86.            if ( gemhead.g_magic != GEMOMAGIC ) {
  87.                sprintf(msg,"%s is the wrong format\n\r",argv[1]);
  88.                abort(msg);
  89.        }
  90.        
  91.       /* create the output file */
  92.              creat(argv[2],1);
  93.           if ( ( outfd = open(argv[2],WRITE)) < 0) {
  94.            sprintf(msg,"Can't open %s for writing\n\r",argv[2]);
  95.            abort(msg);
  96.        }
  97.        /* write out the header */
  98.         write(outfd,&gemhead,sizeof(gemhead));
  99.        
  100.    /* calculate the amount of space used by the header,text and data segements
  101.        and copy them to the new file */
  102.        syms = gemhead.g_ssize[GO_TEXT] + gemhead.g_ssize[GO_DATA];
  103.         xfer(outfd,infd,syms);    
  104.         
  105.    /* calculate the number of relocation bytes..
  106.     a long followed by bytes until the first 0 */
  107.     
  108.           read(infd,buffer,4);
  109.      nreloc += look40(infd);  /* look for the zero */
  110.      
  111.    /* seek to the MWC header and read it */
  112.     lseek( infd,syms+sizeof(gemhead)+nreloc,0);           
  113.     read (infd,&marky,sizeof(marky));
  114.     if ( _canw(marky.l_magic) != L_MAGIC) {
  115.         sprintf(msg,"%s is not a MWC executable\n\r",argv[1]);
  116.         unlink(argv[2]);
  117.         abort(msg);
  118.     }      
  119.     
  120.    /*  next do the symbols */
  121.       nsyms = _canl(marky.l_ssize[L_SYM])/sizeof(struct ldsym);
  122.       gemhead.g_ssize[GO_SYM] = nsyms * sizeof(struct gemsym);
  123.       convrt(infd,outfd,nsyms);
  124.       
  125. /* write out the relocation bytes */
  126.           syms = sizeof(gemhead);  
  127.        syms += gemhead.g_ssize[GO_TEXT] + gemhead.g_ssize[GO_DATA];          
  128.       lseek(infd,syms,0);
  129.       xfer(outfd,infd,nreloc);
  130.       
  131.   /* fix up the header to show the new sizeof the symbols */      
  132.     lseek(outfd,0L,0);
  133.     write(outfd,&gemhead,sizeof(gemhead));
  134. } 
  135.     
  136. convrt(in,out,n)
  137. int in,out;
  138. long n;
  139.  
  140.  
  141. {  
  142.           long     todo=n;
  143.       int     temp,
  144.           flag,
  145.           did,
  146.           t1;
  147.       char msg[80];
  148.           register int     i,
  149.                   j;
  150.           register char *p,
  151.                   *q;
  152.           register struct gemsym *g;
  153.           register struct ldsym  *l;
  154.  
  155.           while ( todo > 0) {
  156.                t1 = min(todo,NSYM);
  157.             if((did = read(in,cymbals,t1*SMW)) < 0)
  158.                 abort("Read error in convrt\r\n");
  159.               t1=did/SMW;
  160.               j=t1;
  161.               l=cymbals;
  162.               g=gsyms;
  163.               while( j-- > 0 ){
  164.                    flag = _canw(l->ls_type);
  165.                    p = g->gs_name;
  166.                    q = l->ls_id;
  167.                    for ( i=0 ; i < 8 ; i++,p++,q++)*p=*q;
  168.               g->gs_value = _canl(l->ls_addr);
  169.               temp = DEFINED;
  170.              if ( flag & 020 ) temp |= GLOBAL;
  171.               switch( flag & 0xf ) {
  172.                 case L_SHRI:
  173.                 case L_PRVI:
  174.                 case L_BSSI:
  175.                     temp |= TEXTBASED;
  176.                     break;
  177.                 case L_SHRD:
  178.                 case L_PRVD:
  179.                     temp |= DATABASED;
  180.                     break;
  181.                 case L_BSSD:
  182.                     temp |= BSSBASED;
  183.                     break;
  184.                 default:
  185.                     sprintf(msg,
  186.                     "I don't recognize flag %d\r\n",
  187.                     flag & 0xF);
  188.                       write(2,msg,strlen(msg));
  189.                  break;
  190.             }
  191.          g -> gs_type = temp;
  192.           l++;
  193.           g++;
  194.     }
  195.     if( write(out,gsyms,t1*SGM) < 0){
  196.             perror("");
  197.             abort("Write error in cnvrt\r\c");
  198.         }
  199.     todo -= t1;
  200.      }
  201.  
  202. }
  203. xfer(out,in,n)
  204. int in,out;
  205. long n;
  206.  
  207. {   
  208.     register int did;
  209.     register long todo=n;
  210.     
  211.         while( todo > 0L ) {
  212.         if((did = read(in,buffer,(int)min(todo,BIGBUF)))<0){
  213.             perror("");
  214.             abort("Read failure\r\n");
  215.         }
  216.             if (write(out,buffer,did) != did ){
  217.                 perror("");
  218.                 abort("Write failure\n\r");
  219.             }
  220.             todo -= did;
  221.         }
  222. }
  223.  usage()
  224.  {
  225.    char *msg="Usage mwcfile drifile\n\r";
  226.    write(2,msg,strlen(msg));
  227.    exit(1);
  228. }
  229.  
  230. abort(msg)
  231. char * msg;
  232. {
  233.     write(2,msg,strlen(msg));
  234.     exit(1);
  235. }
  236.  
  237.  
  238. long look40(in)   /* look for a zero 
  239.             will leave the file pointer in the wrong place */
  240. int in;
  241. {       register long temp=0L;
  242.      register char *p,*q;
  243.        q = buffer + BIGBUF;
  244.     while ( read(in,buffer,BIGBUF) > 0){
  245.         p=buffer;
  246.     for( p=buffer; p < q ; p++) {
  247.        temp++; 
  248.        if( *p == '\0') goto end ;
  249.        }
  250.  
  251. }
  252. end:
  253.  
  254.     return(temp);
  255.       
  256. }
  257.