home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / cpm / utils / asmutl / reloc23.lbr / RELOC.CQ / RELOC.C
Encoding:
C/C++ Source or Header  |  1986-05-06  |  7.6 KB  |  248 lines
  1. /*-----------------------------------------------------------------------------
  2.  
  3.                 R E L O C . C
  4.                 =============
  5.  
  6.     Part of a system for generating self-relocating programs.
  7.  
  8.     (See RELOC.DOC for full details of method and application)
  9.  
  10.     COPYRIGHT NOTICE    (C) 1982   John Hastwell-Batten
  11.  
  12. These programs have been submitted to the public domain and may be  copied and
  13. used without restriction.  All I ask is  that I get the credit for dreaming up
  14. this particular method for the quick and easy generation of a page-relocatable 
  15. program.
  16.  
  17. 1.   My name  must  be  retained in  all source  code  (original  or modified)
  18.  
  19. 2.   This copyright notice must be included in and retained in all source code 
  20.      and documentation pertaining to this system.
  21.  
  22.                              John Hastwell-Batten
  23.                                Tesseract RCPM+
  24.                                  Dural, NSW
  25.                                   AUSTRALIA
  26.                                 (02) 651-1404
  27.  
  28.                               1st November, 1982
  29.  
  30. Acknowledgement
  31.  
  32. In  testing those relocations which overlay specified portions of CP/M I  have 
  33. made  use of John Woolner's CCP protection scheme obtained via  Bill  Bolton's 
  34. RCPM  system.   Without  the CCP protection the verification of the  relocator 
  35. module  would have been exceedingly difficult as the standard program  testing 
  36. tools  all  overlay  the CCP which,  in the case of  the  CP/M  overlays,  the 
  37. relocator expects to be intact.
  38.  
  39. -----------------------------------------------------------------------------*/
  40.  
  41. #include bdscio.h
  42.  
  43. #define    COPY        TRUE
  44. #define DISCARD        FALSE
  45.  
  46. #define CCPOFFSET    -8        /*  8 pages below BDOS */
  47. #define BDOSOFFSET     0
  48. #define BIOSOFFSET    14        /* 14 pages above BDOS */
  49. #define IMPLICIT    0x100
  50. #define PAGEMASK    0xFF
  51.  
  52. char
  53.     b100[BUFSIZ], b200[BUFSIZ], b300[BUFSIZ];
  54. char
  55.     bitmap[8192];
  56. int
  57.     c, c3;
  58. unsigned
  59.     codelen, i, relparam, relword();
  60.  
  61. main(argc,argv)
  62.   int  argc;
  63.   char *argv[];
  64. {
  65.   puts("Self-relocating-program generator - version 2.3 (27/12/84)\n");
  66.   puts("\n(C)1982,1984: John Hastwell-Batten,\n\t Tesseract RCPM+,\n");
  67.   puts("\t Dural NSW.\n\t (02) 651-1404\n");
  68.  
  69. /* Open the 2 input files and the output code file */
  70.  
  71.   if (argc < 2) {
  72.       puts("\nNo output file name specified\n");
  73.       usage();
  74.       exit();  }
  75.  
  76.   if (fopen("ORG200.COM",b200) < 0) {
  77.       puts("\nORG200 linked code file is missing\n");
  78.       exit();  }
  79.   else if (fopen("ORG300.COM",b300) < 0) {
  80.       puts("\nORG300 linked code file is missing\n");
  81.       exit();  }
  82.   else if (fcreat(argv[1],b100) < 0) {
  83.       printf("\nCannot open output %s file",argv[1]);
  84.       exit();  }
  85.  
  86. /* First establish the relocation parameter for the relocator module.
  87.  
  88.    The relocator starts with a jump to base+5 to skip over the parameter.
  89.    (For most processors on which this program will be run, the jump is
  90.    a 3-byte instruction.)  The relocation parameter is in the next two
  91.    bytes.
  92.  
  93.    It would be most convenient to write the object code for the jump
  94.    from this module but to do so is slightly less general in that this
  95.    module must assume knowledge of the processor's instruction set.
  96.  
  97.    Instead, we copy the first three bytes from the relocator module,
  98.    replace the next two bytes with the relocation parameter, and then
  99.    copy the rest of the relocator.  It is just a little bit messy.    */
  100.  
  101.    for (i=0; i<3; i++)
  102.      relmod(COPY);        /* Copy first 3 bytes */
  103.  
  104.    for (; i<5; i++)
  105.      relmod(DISCARD);        /* Discard next 2 bytes */
  106.  
  107.    if (argc > 2)        /* i.e. if relocation parameter specified */
  108.      relparam = relword(argv[2],argv[1]);
  109.    else {
  110.      relparam = 0;
  111.      printf("\n%s will load below the BDOS\n",argv[1]);
  112.     }
  113.  
  114.    putw(relparam,b100);        /* Stuff in the relocation parameter */
  115.    printf("Relocation parameter is %x\n",relparam);
  116.  
  117. /* Now copy the remainder of the first 0xFE bytes (relocator module)
  118.    from ORG200 to the output code file */
  119.  
  120.   for (i=5; i<0xFE; i++)
  121.     relmod(COPY);
  122.  
  123. /* Now get the code length and write it to the output file */
  124.  
  125.   codelen = getw(b200);
  126.   putw(codelen,b100);
  127.   codelen -= 0x200;
  128.   printf("Relocatable code is %xh long\n",codelen);
  129.  
  130. /* Skip over all the leading junk in ORG300 */
  131.  
  132.   for (i=0; i<0x1FE; i++) {
  133.     if (getc(b300) == EOF) {
  134.       puts("\nRelocatable program missing from ORG300\n");
  135.       exit(); } }
  136.  
  137. /* Check to see that the ORG200 & ORG300 code is at least the same length */
  138.  
  139.   if (getw(b300)-0x300 != codelen) {
  140.     puts("\nLength of relocatable code in ORG200 and ORG300 is different\n");
  141.     exit(); }
  142.  
  143. /* If we get this far then we are ready to build the bit map */
  144.  
  145.   setmem(&bitmap[0],8192,0);
  146.  
  147.   for (i=0; i<codelen; i++) {
  148.     if (((c=getc(b200))==EOF) | ((c3=getc(b300))==EOF)) {
  149.       puts("\nPremature EOF reading relocatable code\n");
  150.       exit(); }
  151.     putc(c,b100);    /* Copy ORG200 to output */
  152.     if (c != c3)
  153.       setbit(i); }
  154.  
  155. /* Input ORG200 file now copied to output. Close input files and append
  156.    bitmap to the output file */
  157.  
  158.   fclose(b200);
  159.   fclose(b300);
  160.  
  161. /* Bitmap is (codelen+7) div 8 bytes long */
  162.  
  163.   codelen = (codelen+7) >> 3;
  164.   for (i=0; i<codelen; i++)
  165.     putc(bitmap[i],b100);
  166.  
  167. /* Wrap up */
  168.  
  169.   fflush(b100);
  170.   fclose(b100);        }
  171.         
  172. /****************************************************************************/
  173.  
  174. relmod(copy)
  175.     int   copy;
  176. {
  177.     int   c;
  178.  
  179.     if ((c=getc(b200)) == EOF) {
  180.       puts("\nPremature EOF copying relocator program\n");
  181.       exit();              }
  182.  
  183.     if (copy)
  184.       putc(c,b100);
  185. }
  186.  
  187. /****************************************************************************/
  188.  
  189. setbit(bitno)        /* sets a bit in the bitmap */
  190.   unsigned bitno; {
  191. /*printf("Setting bit %xh, changing from %xh",bitno,bitmap[(bitno>>3)]);*/
  192.   bitmap[(bitno / 8)] |= (1 << (7-(bitno % 8)));
  193. /*printf(" to %xh\n",bitmap[(bitno>>3)]);*/
  194. }
  195.  
  196. /****************************************************************************/
  197.  
  198. usage() {    /* Display a quick summary of how to invoke RELOC */
  199.  
  200.       puts("\nUsage: RELOC <.COM file name> [option]\n\n");
  201.       puts("Option can be any of:-\n");
  202.       puts("\t<empty>\t    => relocate below BDOS\n");
  203.       puts("\t-\t    => relocate below CCP\n");
  204.       puts("\tBIOS\t    => overlay BIOS\n");
  205.       puts("\tBDOS\t    => overlay BDOS\n");
  206.       puts("\tCCP\t    => overlay CCP\n");
  207.       puts("\thex number  => relocate to specific address\n");    }
  208.  
  209. /***************************************************************************/
  210.  
  211. relword(where,what)
  212.     char  where[], what[];
  213. {
  214.   unsigned   addr;
  215.   char       *x;
  216.  
  217.   for (x=where;*x++;)
  218.     *x = toupper(*x);
  219.  
  220.   if (!(strcmp(where,"-"))) {
  221.     printf("\n%s will load below the CCP\n",what);
  222.     return(CCPOFFSET & PAGEMASK);
  223.                 }
  224.   if (!(strcmp(where,"BIOS"))) {
  225.     printf("\n%s will overlay the BIOS\n",what);
  226.     return(BIOSOFFSET & PAGEMASK | IMPLICIT);
  227.                    }
  228.   if (!(strcmp(where,"BDOS"))) {
  229.     printf("\n%s will overlay the BDOS\n",what);
  230.     return(BDOSOFFSET & PAGEMASK | IMPLICIT);
  231.                    }
  232.   if (!(strcmp(where,"CCP"))) {
  233.     printf("\n%s will overlay the CCP\n",what);
  234.     return(CCPOFFSET & PAGEMASK | IMPLICIT);
  235.                   }
  236.   sscanf(where,"%x",&addr);
  237.   if (addr % 0x100) {
  238.     puts("\nCode destination must be on a 100h boundary\n");
  239.     exit();        }
  240.   if (addr < 0x200) { 
  241.     puts("\nCode cannot be relocated to an address below 200h\n");
  242.     exit();        }
  243.   printf("\n%s will load at %xh\n",what,addr);
  244.   return(addr);
  245. }
  246.  
  247. /****************************************************************************/
  248.