home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / UTILITY / FILE / EXEHEX.ZIP / EXEHEX.C next >
Encoding:
C/C++ Source or Header  |  1991-03-30  |  12.9 KB  |  509 lines
  1. /************************************************************************
  2.  * exehex.c -    This program converts Microsoft .EXE files to Intel    *
  3.  *        HEX files suitable for burning into EPROM.  Like the    *
  4.  *        loader in MSDOS, exehex performs any necessary        *
  5.  *        relocation of segments in the .EXE file.        *
  6.  ************************************************************************/
  7.  
  8. /************************************************************************
  9.  * Copyright 1991, Charles F. Harris, C.F. Harris - Consulting.        *
  10.  *                                    *
  11.  * You may use this program for any purpose Commercial or Private with    *
  12.  * following exceptions:                        *
  13.  *                                    *
  14.  * 1) You may not sell this program without my written permission.    *
  15.  * 2) You must leave this header comment unmodified, and intact.    *
  16.  * 3) You must clearly identify any modifications that you make.    *
  17.  *                                    *
  18.  * This program is provided without any warantees or support, and is    *
  19.  * to be used at your own risk.                        *
  20.  ************************************************************************/
  21.  
  22. /************************************************************************
  23.  * This program was designed to run on 80x86 type machines, and to be    *
  24.  * compiled with TURBO C++ V1.00. (that is not to say that it is    *
  25.  * written in C++)                            *
  26.  * I can be reached at: chuck@eng.umd.edu                *
  27.  * or at:    Chuck Harris                        *
  28.  *        C.F. Harris - Consulting                *
  29.  *        9308 Canterbury Riding                    *
  30.  *        Laurel, Maryland 20723                    *
  31.  ************************************************************************/
  32.  
  33. #include <dir.h>
  34. #include <stdio.h>
  35. #include <stdlib.h>
  36. #include <stdarg.h>
  37. #include <string.h>
  38. #include <io.h>
  39.  
  40. #define ERR(s, c)    if(opterr){\
  41.     char errbuf[2];\
  42.     errbuf[0] = c; errbuf[1] = '\n';\
  43.     (void) write(2, argv[0], (unsigned)strlen(argv[0]));\
  44.     (void) write(2, s, (unsigned)strlen(s));\
  45.     (void) write(2, errbuf, 2);}
  46.  
  47. #define DATAREC 0
  48. #define EXADDR    2
  49. #define ENDREC    1
  50.  
  51.  
  52. struct EXEHDR {
  53.     unsigned signature;        /* linker signature */
  54.     unsigned image_rsize;        /* length of image mod 512 */
  55.     unsigned file_nblks;        /* number of 512 byte blocks in file */
  56.     unsigned num_rels;        /* number of relocation items */
  57.     unsigned header_size;        /* size in paragraphs */
  58.     unsigned minheap_size;        /* min num paragraphs in heap */
  59.     unsigned maxheap_size;        /* max num paragraphs in heap */
  60.     unsigned stackseg_offset;    /* offset of stack seg in load module */
  61.     unsigned initial_SP;        /* initial value of stack register */
  62.     unsigned checksum;        /* neg sum of all words in file */
  63.     unsigned initial_IP;        /* initial value of instruction ptr */
  64.     unsigned codeseg_offset;    /* offset of code seg in load module */
  65.     unsigned reltbl_offset;        /* offset of first relocation item */
  66.     unsigned overlay_num;        /* overlay number (0 == resident part) */
  67. } exehdr;
  68.  
  69. typedef struct RELTBL {
  70.     unsigned rel_offset;
  71.     unsigned rel_segment;
  72. } RELTBL;
  73.  
  74. int    opterr = 1;
  75. int    optind = 1;
  76. int    optopt;
  77. char    *optarg;
  78.  
  79. char *tempfile = "exehexXXXXXX";    /* template for mktemp() */
  80. char *tmpfname = 0;            /* name of temp file */
  81.  
  82. FILE *fopen(),*fpi,*fpo,*fpt;
  83. int ABORT(char *reason, ...);
  84.  
  85. unsigned char intelstring[100];
  86. unsigned segment = 0, offset = 0;
  87. unsigned imagelen = 0;
  88. unsigned debug = 0;
  89. unsigned no_end_record = 0;
  90.  
  91. RELTBL *reloc_tbl;
  92.  
  93. main(argc,argv)
  94. int argc;
  95. char **argv;
  96. {
  97.     discover_options(argc,argv);
  98.     open_files(argc,argv);
  99.     read_exe_header();
  100.     read_relocation_table();
  101.     copy_image_to_temp();
  102.     relocate_image();
  103.     write_hex_file();
  104.     remove_temp_file();
  105. }
  106.  
  107. discover_options(argc,argv)
  108. int argc;
  109. char **argv;
  110. {
  111.     char *ourargs = "o:O:s:S:dDN?Hh";
  112.     int opt;
  113.  
  114.     while((opt=getopt(argc,argv,ourargs)) != EOF){
  115.         switch(opt){
  116.         case 'd':
  117.         case 'D':
  118.             fprintf(stderr,"DEBUG level is: %d\n",++debug);
  119.             break;
  120.         case 's':
  121.         case 'S':
  122.             sscanf(optarg,"%x",&segment);
  123.             if(debug>=1){
  124.                 fprintf(stderr,"Segment= 0x%X\n",segment);
  125.             }
  126.             break;
  127.         case 'o':
  128.         case 'O':
  129.             sscanf(optarg,"%x",&offset);
  130.             if(debug>=1){
  131.                 fprintf(stderr,"Offset= 0x%X\n",offset);
  132.             }
  133.             break;
  134.         case 'N':
  135.             no_end_record++;
  136.             if(debug>=1){
  137.                 fprintf(stderr,"No End Record\n");
  138.             }
  139.             break;
  140.         case '?':
  141.         case 'h':
  142.         case 'H':
  143.             how_to_use_message();
  144.             break;
  145.         default:
  146.             ABORT("Unknown argument");
  147.         }
  148.     }
  149. }
  150.  
  151. /*
  152.  * getopt a wonderful little function that handles the command line.
  153.  * available courtesy of AT&T.
  154.  */
  155.  
  156. int
  157. getopt(argc, argv, opts)
  158. int    argc;
  159. char    **argv, *opts;
  160. {
  161.     static int sp = 1;
  162.     register int c;
  163.     register char *cp;
  164.  
  165.     if(sp == 1)
  166.         if(optind >= argc ||
  167.            argv[optind][0] != '-' || argv[optind][1] == '\0')
  168.             return(EOF);
  169.         else if(strcmp(argv[optind], "--") == NULL) {
  170.             optind++;
  171.             return(EOF);
  172.         }
  173.     optopt = c = argv[optind][sp];
  174.     if(c == ':' || (cp=strchr(opts, c)) == NULL) {
  175.         ERR(": illegal option -- ", c);
  176.         if(argv[optind][++sp] == '\0') {
  177.             optind++;
  178.             sp = 1;
  179.         }
  180.         return('?');
  181.     }
  182.     if(*++cp == ':') {
  183.         if(argv[optind][sp+1] != '\0')
  184.             optarg = &argv[optind++][sp+1];
  185.         else if(++optind >= argc) {
  186.             ERR(": option requires an argument -- ", c);
  187.             sp = 1;
  188.             return('?');
  189.         } else
  190.             optarg = argv[optind++];
  191.         sp = 1;
  192.     } else {
  193.         if(argv[optind][++sp] == '\0') {
  194.             sp = 1;
  195.             optind++;
  196.         }
  197.         optarg = NULL;
  198.     }
  199.     return(c);
  200. }
  201.  
  202. open_files(argc,argv)
  203. int argc;
  204. char **argv;
  205. {
  206.     int argind, files_found;
  207.  
  208.     argc--,argv++;            /* skip the program name */
  209.     for(argind=0,files_found=0; argind<argc; argind++){
  210.         if(argv[argind][0] == '-') continue;
  211.         if(debug>=1){
  212.             fprintf(stderr,"Argument is: %s\n",argv[argind]);
  213.         }
  214.         files_found++;
  215.         
  216.         if(files_found==1 && !(fpi=fopen(argv[argind],"rb"))){
  217.             ABORT("opening %s",argv[argind]);
  218.         }
  219.         else if(files_found==2 && !(fpo=fopen(argv[argind],"wb"))){
  220.             ABORT("opening %s",argv[argind]);
  221.         }
  222.         else if(files_found > 2){
  223.             ABORT("too many file arguments\n");
  224.         }
  225.     }
  226.     if(files_found == 0){
  227.         ABORT("need a file to work on!");
  228.     }
  229.     else if(files_found == 1){
  230.         fpo = stdout;
  231.     }
  232.     tmpfname = mktemp(tempfile);
  233.     if(!(fpt=fopen(tmpfname,"wb+"))){
  234.         ABORT("can't open temporary file: %s",tmpfname);
  235.     }
  236. }
  237.  
  238. read_exe_header()
  239. {
  240.     if(fread(&exehdr,sizeof(struct EXEHDR),1,fpi) != 1){
  241.         ABORT("couldn't read exe header");
  242.     }
  243.     if(debug>=1){
  244.         print_exe_header();
  245.     }
  246.     if(exehdr.signature != 0x5a4d){
  247.         ABORT("bad exe signature:[0x%X]",exehdr.signature);
  248.     }
  249.     imagelen  = exehdr.file_nblks*512 - exehdr.header_size*16;
  250.     imagelen -= (exehdr.image_rsize == 4) ? 0 : exehdr.image_rsize;
  251.     if(debug>=1){
  252.         fprintf(stderr,"binary image length is: 0x%X,(%dd)\n",imagelen,imagelen);
  253.     }
  254. }
  255.  
  256. print_exe_header()
  257. {
  258.     fprintf(stderr,"EXE HEADER:\n");
  259.     fprintf(stderr,"->signature       = 0x%X\n",exehdr.signature);
  260.     fprintf(stderr,"->image_rsize     = 0x%X\n",exehdr.image_rsize);
  261.     fprintf(stderr,"->file_nblks      = 0x%X\n",exehdr.file_nblks);
  262.     fprintf(stderr,"->num_rels        = 0x%X\n",exehdr.num_rels);
  263.     fprintf(stderr,"->header_size     = 0x%X\n",exehdr.header_size);
  264.     fprintf(stderr,"->minheap_size    = 0x%X\n",exehdr.minheap_size);
  265.     fprintf(stderr,"->maxheap_size    = 0x%X\n",exehdr.maxheap_size);
  266.     fprintf(stderr,"->stackseg_offset = 0x%X\n",exehdr.stackseg_offset);
  267.     fprintf(stderr,"->initial_SP      = 0x%X\n",exehdr.initial_SP);
  268.     fprintf(stderr,"->checksum        = 0x%X\n",exehdr.checksum);
  269.     fprintf(stderr,"->initial_IP      = 0x%X\n",exehdr.initial_IP);
  270.     fprintf(stderr,"->codeseg_offset  = 0x%X\n",exehdr.codeseg_offset);
  271.     fprintf(stderr,"->reltbl_offset   = 0x%X\n",exehdr.reltbl_offset);
  272.     fprintf(stderr,"->overlay_num     = 0x%X\n",exehdr.overlay_num);
  273. }
  274.  
  275. read_relocation_table()
  276. {
  277.     int i;
  278.  
  279.     if(exehdr.num_rels == 0) return;    /* can't do much here */
  280.  
  281.     reloc_tbl = (RELTBL *)malloc(exehdr.num_rels * sizeof(RELTBL));
  282.     if(!reloc_tbl){
  283.         ABORT("can't malloc reloc_tbl");
  284.     }
  285.     if(fseek(fpi,(long)exehdr.reltbl_offset,SEEK_SET) != 0){
  286.         ABORT("couldn't fseek to relocation tbl");
  287.     }
  288.     if(fread(reloc_tbl, sizeof(RELTBL) * exehdr.num_rels, 1, fpi) != 1){
  289.         ABORT("couldn't read relocation table");
  290.     }
  291.     if(debug>=1){
  292.         fprintf(stderr,"RELOCATION TABLE\n");
  293.         for(i=0;i<exehdr.num_rels;i++){
  294.             fprintf(stderr,"seg= 0x%X, off= 0x%X\n",reloc_tbl[i].rel_segment, reloc_tbl[i].rel_offset);
  295.         }
  296.     }
  297. }
  298.  
  299. copy_image_to_temp()
  300. {
  301.     unsigned char bytes;
  302.     unsigned char data[32];
  303.  
  304.     if(fseek(fpi, (long)exehdr.header_size * 16, SEEK_SET) != 0){
  305.         ABORT("couldn't fseek() to data image");
  306.     }
  307.     while((bytes = fread(data,1,32,fpi)) == 32){
  308.         if(fwrite(data,1,32,fpt) != 32){
  309.             ABORT("couldn't write temp file");
  310.         }
  311.         bytes = 0;
  312.     }
  313.     if(bytes > 0){                /* any fraction remaining? */
  314.         if(fwrite(data,1,bytes,fpt) != bytes){
  315.             ABORT("couldn't write temp file");
  316.         }
  317.     }
  318. }
  319.  
  320. relocate_image()
  321. {
  322.     long iptr;            /* image pointer */
  323.     int i;
  324.     unsigned rel_word;
  325.  
  326.     for(i=0; i<exehdr.num_rels; i++){
  327.         iptr = reloc_tbl[i].rel_segment*16 + reloc_tbl[i].rel_offset;
  328.         if(fseek(fpt, iptr, SEEK_SET) != 0){
  329.             ABORT("couldn't fseek() to rel item");
  330.         }
  331.         if(fread(&rel_word,sizeof(unsigned),1,fpt) != 1){
  332.             ABORT("couldn't read rel item");
  333.         }
  334.         rel_word += segment;        /* relocate rel_word */
  335.         if(fseek(fpt, iptr, SEEK_SET) != 0){
  336.             ABORT("couldn't fseek() to rel item");
  337.         }
  338.         if(fwrite(&rel_word,sizeof(unsigned),1,fpt) != 1){
  339.             ABORT("couldn't write back rel item");
  340.         }
  341.     }
  342. }
  343.  
  344. write_hex_file()
  345. {
  346.     unsigned data[32];
  347.     unsigned char bytes;
  348.     unsigned address = offset;
  349.  
  350.     if(fseek(fpt, (long)0, SEEK_SET) != 0){
  351.         ABORT("couldn't fseek() to data image 0");
  352.     }
  353.     write_extended_address_record(segment);
  354.     while((bytes = fread(data,1,32,fpt)) == 32){
  355.         write_data_record(address,bytes,data);
  356.         address += bytes;
  357.         bytes = 0;
  358.     }
  359.     if(bytes > 0){                /* any fraction remaining? */
  360.         write_data_record(address,bytes,data);
  361.     }
  362.     if(!no_end_record){
  363.         write_end_record(0);
  364.     }
  365. }
  366.  
  367. write_data_record(address,datalen,data)
  368. unsigned address;
  369. unsigned char datalen;
  370. unsigned char data[];
  371. {
  372.     build_hex_record(DATAREC,address,datalen,data);
  373.     fputs(intelstring,fpo);
  374. }
  375.  
  376. write_extended_address_record(usba)
  377. unsigned usba;
  378. {
  379.     unsigned char data[2];
  380.  
  381.     data[0] = hi_byte(usba);
  382.     data[1] = lo_byte(usba);
  383.     build_hex_record(EXADDR,0,2,data);
  384.     fputs(intelstring,fpo);
  385. }
  386.  
  387. write_end_record(start)
  388. unsigned start;
  389. {
  390.     build_hex_record(ENDREC,start,0,(char *)0);
  391.     fputs(intelstring,fpo);
  392. }
  393.  
  394. build_hex_record(type,loadaddress,datalen,data)
  395. unsigned char type;
  396. unsigned loadaddress;
  397. unsigned char datalen;
  398. unsigned char data[];
  399. {
  400.     int checksum = 0;
  401.     int i,j;
  402.  
  403.     intelstring[0] = ':';
  404.     intelstring[1] = hex_lo_hi(datalen);
  405.     intelstring[2] = hex_lo_lo(datalen);
  406.     checksum += datalen;
  407.  
  408.     intelstring[3] = hex_hi_hi(loadaddress);
  409.     intelstring[4] = hex_hi_lo(loadaddress);
  410.     intelstring[5] = hex_lo_hi(loadaddress);
  411.     intelstring[6] = hex_lo_lo(loadaddress);
  412.     checksum += hi_byte(loadaddress);
  413.     checksum += lo_byte(loadaddress);
  414.  
  415.     intelstring[7] = hex_lo_hi(type);
  416.     intelstring[8] = hex_lo_lo(type);
  417.     checksum += type;
  418.  
  419.     for(i=9,j=0; j<datalen; i+=2,j++){
  420.         intelstring[i]   = hex_lo_hi(data[j]);
  421.         intelstring[i+1] = hex_lo_lo(data[j]);
  422.         checksum += data[j];
  423.     }
  424.     checksum = -checksum;
  425.     intelstring[i+0] = hex_lo_hi(checksum);
  426.     intelstring[i+1] = hex_lo_lo(checksum);
  427.     intelstring[i+2] = '\r';
  428.     intelstring[i+3] = '\n';
  429.     intelstring[i+4] = '\0';
  430. }
  431.  
  432. static char hextable[] = "0123456789ABCDEF";
  433.  
  434. hex_hi_hi(n)
  435. unsigned n;
  436. {
  437.     return hextable[ (hi_byte(n)>>4)&0xf ];
  438. }
  439.  
  440. hex_hi_lo(n)
  441. unsigned n;
  442. {
  443.     return hextable[ hi_byte(n)&0xf ];
  444. }
  445.  
  446. hex_lo_hi(n)
  447. unsigned n;
  448. {
  449.     return hextable[ (lo_byte(n)>>4)&0xf ];
  450. }
  451.  
  452. hex_lo_lo(n)
  453. unsigned n;
  454. {
  455.     return hextable[ lo_byte(n)&0xf ];
  456. }
  457.  
  458. hi_byte(n)
  459. unsigned n;
  460. {
  461.     return ((n>>8) & 0xff);
  462. }
  463.  
  464. lo_byte(n)
  465. unsigned n;
  466. {
  467.     return (n & 0xff);
  468. }
  469.  
  470. ABORT(char *reason, ...)
  471. {
  472.     va_list argptr;
  473.  
  474.     va_start(argptr, reason);
  475.     fputs("ERROR: ",stderr);
  476.     vfprintf(stderr, reason, argptr);
  477.     va_end(argptr);
  478.  
  479.     remove_temp_file();
  480.     how_to_use_message();        /* which also exits program */
  481. }
  482.  
  483. remove_temp_file()
  484. {
  485.     if(tmpfname){
  486.         fclose(fpt);
  487.         remove(tmpfname);
  488.     }
  489. }
  490.     
  491. how_to_use_message()
  492. {
  493.     fprintf(stderr,"\n");
  494.     fprintf(stderr,"EXEHEX - This program converts Microsoft .EXE files\n");
  495.     fprintf(stderr,"         into Intel HEX files suitable for burning\n");
  496.     fprintf(stderr,"         into EPROM.\n\n");
  497.     fprintf(stderr,"EXEHEX:  [-D][-Sxxxx][-Oxxxx][-N][-H][-?] infile [outfile]\n");
  498.     fprintf(stderr,"where -Sxxxx sets the start segment to xxxx.\n");
  499.     fprintf(stderr,"      -Oxxxx sets the start offset  to xxxx.\n");
  500.     fprintf(stderr,"      -N     prevents the sending of an end record\n");
  501.     fprintf(stderr,"             (useful when making the jump vector)\n");
  502.     fprintf(stderr,"      -D     turns on some debugging messages (should be first).\n");
  503.     fprintf(stderr,"      -?     sends this message\n");
  504.     fprintf(stderr,"      -H     sends this message\n\n");
  505.     fprintf(stderr,"the default options are -S0000 -O00000\n");
  506.     fprintf(stderr,"(All numbers must be in hex, segments in paragraphs)\n");
  507.     exit(1);
  508. }
  509.