home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 300-399 / ff345.lzh / X2X / x2x_3.c < prev    next >
C/C++ Source or Header  |  1990-04-16  |  20KB  |  812 lines
  1. /*SCCS header -          %W%   %G%                                     */
  2. /************************************************************************ 
  3. *                                                                       * 
  4. *                      Filename:        x2x_3.c                         *      
  5. *                       Version:        0.0                             * 
  6. *                       Author :        Gary Duncan                     * 
  7. *                    24 Inkster St                   *
  8. *                    Kambah ACT 2902                 *
  9. *                    Australia                       *
  10. *                                                                       * 
  11. *-----------------------------------------------------------------------* 
  12. * 
  13. * Modification record 
  14. * ------------------- 
  15. * 
  16. * Date         By whom             Change 
  17. * ----         -------             ------ 
  18. * 
  19. * 12 Apr 89     GMD                AMIGA'd
  20. * 
  21. *------------------------------------------------------------------------ 
  22.  
  23.  
  24. * 
  25. *------------------------------------------------------------------------------ 
  26. * Contents 
  27. * ------- 
  28. *+ 
  29. *+              dos_fname       gens output file name if under DOS 
  30. *+              func1           exitsif Func 1 key hit ( DOS only ) 
  31. *+              get_rstart      looks for DLL record start 
  32. *+              sol_params      solicits for input params 
  33. *+              com_params      processes command line parameters              
  34. *+              open_ifile      opens input file 
  35. *+              open_ofile      opens output file  
  36. *+              gen_csum        builds and writes checksum record 
  37. *+              date            reformats SCCS vers / date  
  38. *+              usage           error message - 
  39. *+  
  40. * 
  41. ******************************************************************************/ 
  42.  
  43. #include "x2x_amiga.h"
  44. #include "x2x_data.c"
  45.  
  46.  
  47. /*************************************************************************** 
  48.  
  49.  
  50.   Function :            dos_fname     
  51.  
  52.  
  53.   Purpose  :           cater for limited file name length etc in MS_DOS 
  54.                        ( PC application ) 
  55.  
  56.   Entry    : 
  57.  
  58.  
  59.   Returns  :     TRUE -  
  60.  
  61.                  FALSE-  
  62.  
  63. ***************************************************************************/ 
  64.  
  65.  
  66.  
  67. int dos_fname () 
  68.  
  69.  
  70.  
  71. { 
  72. #ifdef AMIGA 
  73.  
  74.  
  75. int j = 0 ; 
  76. int k = 0 ; 
  77. uchar ch ; 
  78.  
  79. while ( ch = ofile[j]) 
  80.   { 
  81.      if ( ch == '.' ) 
  82.         break ; 
  83.  
  84.      ++j ; 
  85.   } 
  86.  
  87.  ofile [j] = '\0' ; 
  88.  strcat ( ofile , sfx[opftype] ) ;   /* append suffix */ 
  89.  
  90.  if ( strcmp ( ofile , ifile ) )      /* ensure difference */ 
  91.      return ;                       /* some , exit */ 
  92.  
  93.  /*-- in file name ...XYZ.EXT , start replacing from X <- with & until 
  94.   *      uniqueness , or exhaustion 
  95.   */ 
  96.  
  97.  while ( --j ) 
  98.      { 
  99.         ofile [j] = '&' ;     /* god , this is tedious.... */        
  100.  
  101.         if ( strcmp ( ofile , ifile ) )      /* ensure difference */ 
  102.           return ;                       /* some , exit */ 
  103.  
  104.      } 
  105.  
  106.   fprintf ( stderr , "Too many &s in input file name !\n" ) ; 
  107.   exit( 1 ) ; 
  108.  
  109.  
  110. #endif  
  111. } 
  112.  
  113. #if 0
  114.  
  115. /*************************************************************************** 
  116.  
  117.  
  118.   Function :      func1 
  119.  
  120.   Purpose  :      looks for Func1 from  keyboard 
  121.  
  122.   Entry    : 
  123.  
  124.   Returns  :     TRUE -  found it 
  125.  
  126.                  FALSE- 
  127.  
  128.  
  129.  
  130. ****************************************************************************/ 
  131.  
  132.  
  133. int  func1 () 
  134.  
  135.  
  136.  
  137. { 
  138. #ifdef AMIGA 
  139.  
  140. uchar ch ; 
  141.  
  142.    if ( scr_poll () != -1 ) 
  143.      { 
  144.       ch = scr_getc () ; 
  145.        
  146.       if ( ch == (0x3B | 0x80 ) ) 
  147.          return ( TRUE ) ;           /* found it */ 
  148.      } 
  149.  
  150. #endif 
  151.  
  152.    return (FALSE ) ; 
  153. } 
  154. #endif
  155.  
  156. /*************************************************************************** 
  157.  
  158.  
  159.   Function :       get_rstart     
  160.  
  161.  
  162.   Purpose  :       search for DLL record start given header char 
  163.  
  164.   Entry    :       header chara ( : / % S Q ) 
  165.  
  166.  
  167.   Returns  :      if found , exits from program otherwise 
  168.  
  169.                  
  170.  
  171. ***************************************************************************/ 
  172.  
  173.  
  174. int get_rstart ( ich ) 
  175.  
  176. uchar ich ; 
  177.  
  178. { 
  179.  int j = 0 ; 
  180.  int cch = 0 ; 
  181.  
  182.       while ( ich != cch )               /* search for record start  */ 
  183.     { 
  184.           if (  ( cch=Ichar() ) == -1 )  /* get chara from input file */ 
  185.             { 
  186.                 fprintf ( stderr , "Unexpected EOF on input file" ) ; 
  187.                 exit (1) ; 
  188.         } 
  189.            if ( j++ > 100 )   /* nominal length of  search */ 
  190.             { 
  191.                 fprintf ( stderr ,  
  192.             "Can't find a record header chara ( %c ) in 100 chara search!\n" , 
  193.                    ich  ) ; 
  194.                 exit (1) ; 
  195.         } 
  196.  
  197.     } 
  198. } 
  199.  
  200. /*************************************************************************** 
  201.  
  202.  
  203.   Function :       sol_params 
  204.  
  205.  
  206.   Purpose  :       solicits user for parameters 
  207.  
  208.   Entry    :        
  209.  
  210.  
  211.   Returns  :       
  212.  
  213.                  
  214.  
  215. ***************************************************************************/ 
  216.  
  217.  
  218.  
  219. int  sol_params ()  
  220.  
  221.  
  222. { 
  223. int  kk ; 
  224.  
  225.  
  226.  /*------------------ get input DLL file ---------------------------*/ 
  227.  
  228.    printf("Input file name ? " ); 
  229.    gets ( ifile ) ; 
  230.  
  231.    open_ifile ( ifile )  ;            /* open file - determine type */ 
  232.  
  233.  /*------------------ get output DLL file type ---------------------------*/ 
  234.  
  235.  kk = 0 ; 
  236.  while ( !kk ) 
  237.    { 
  238.      printf ( 
  239.        "\nOutput file type ( I, M1, M2, M3, T, Tx  ) ?  " )  ; 
  240.      gets ( kbuf ) ; 
  241.       
  242.      switch ( kk = kbuf[0] )           /* announce input file type */ 
  243.        { 
  244.         case 'i' :                 /* INTEL */ 
  245.         case 'I' :                 /* INTEL */ 
  246.                  opftype = 0 ; 
  247.                  break ; 
  248.         case 'm' :                 /* MOTOROLAs */ 
  249.         case 'M' :                 /* MOTOROLAs */ 
  250.                  opftype = 0 ; 
  251.                  switch ( kbuf[1] - '0' ) 
  252.           { 
  253.           case 3 :  ++opftype ; 
  254.                   case 2 :  ++opftype ; 
  255.                   case 1 :  ++opftype ; 
  256.                      xoMaddr = opftype +1 ;  /* addr len */  
  257.                      break ; 
  258.           default : 
  259.                       kk = 0 ;              /* force error */                  
  260.           } 
  261.                  break ; 
  262.  
  263.     case 't' : 
  264.         case 'T' :                 /* TEKTRONIX */ 
  265.                   
  266.                  ( kbuf[1] == 'x' ) ? (opftype = 5) : (opftype = 4 ) ; 
  267.  
  268.                  break ; 
  269.  
  270.         default : 
  271.                      kk = 0 ;      /* error - loop */ 
  272.  
  273.         }  
  274.    } 
  275.  
  276.  /*----------------- create o/p file -------------------------*/ 
  277.  
  278.   open_ofile ( ifile ) ; 
  279.  
  280. /*------------ now solicit record data length --------------------------*/ 
  281.  
  282.  while (1) 
  283.    {   
  284.       reclen = 0 ; 
  285.       printf (   
  286.        "\nRecord data length ( Max = 255 , default = 16 bytes) ?  " ) ; 
  287.       gets ( opbuf ) ; 
  288.       if ( !strlen (opbuf) )      /* RET means default  */ 
  289.       { 
  290.              reclen = 16 ; 
  291.              break ; 
  292.       } 
  293.       kk = sscanf ( opbuf , "%d" , &reclen  ) ; 
  294.        
  295.       if ( (reclen > 0)  && (reclen < 256 ) ) 
  296.         break ; 
  297.     } 
  298.  
  299.    /*----- adjust reclen if MOTOROLA and overflow ---------------------------*/ 
  300.  
  301.    if ( (xoMaddr + reclen) > 255 )    /* 1 byte length only ! */ 
  302.      { 
  303.        reclen = 255 - xoMaddr ;      /* adjust */ 
  304.        fprintf ( stderr , 
  305.         "Rec length overflow , data length adjusted to %d \n" , reclen ) ; 
  306.      } 
  307.  
  308. } 
  309.  
  310. /*************************************************************************** 
  311.  
  312.  
  313.   Function :       open_ifile 
  314.  
  315.  
  316.   Purpose  :       opens input file , announces type 
  317.  
  318.   Entry    :        
  319.  
  320.  
  321.   Returns  :      file ptr 
  322.  
  323.                  
  324.  
  325. ***************************************************************************/ 
  326.  
  327. int open_ifile ( ptr ) 
  328.  
  329. char *ptr ; 
  330.  
  331.  
  332. { 
  333.  
  334.    if(( iffp = open( ptr , O_RDONLY)) < 0)    /* source file */ 
  335.     { 
  336.         fprintf(stderr,"Error: unable to open '%s'\n",  ifile); 
  337.         exit(1); 
  338.     } 
  339.  
  340.  /*---------------- validate file type -------------------------------*/ 
  341.  
  342.  ipftype = get_rtype (  ) ;    /* get DLL file type */ 
  343.  
  344.  switch ( ipftype )           /* announce input file type */ 
  345.    { 
  346.    case 0 :                 /* INTEL */ 
  347.    case 1 :                 /* MOTOROLAs  */ 
  348.    case 2 : 
  349.    case 3 : 
  350.    case 4 :                 /* TEKTRONIX */ 
  351.    case 5 :                 /* TEKTRONIX - extended  */ 
  352.        break ; 
  353.  
  354.    default : 
  355.               fprintf ( stderr , "Unknown input file type\n" ); 
  356.               exit (1) ; 
  357.    }  
  358.  
  359.   printf (  "\nInput file type is :  %s" , iipftype[ ipftype ] ) ; 
  360.  
  361.  } 
  362.  
  363. /*************************************************************************** 
  364.  
  365.  
  366.   Function :           com_params        
  367.  
  368.  
  369.   Purpose  :           scans command line for invocation parameters 
  370.                        - does things with them 
  371.  
  372.   Entry    :        
  373.  
  374.  
  375.   Returns  :           mode type ( 2 or 3 )       
  376.  
  377.                  
  378.  
  379. ***************************************************************************/ 
  380.  
  381. int com_params ( count , ptr ) 
  382. int count ; 
  383. char **ptr ; 
  384.  
  385.  
  386. { 
  387. char *argptr ; 
  388. char *iptr ; 
  389. int ch ; 
  390. int mode = 2 ; 
  391.  
  392. while ( --count )                   /* scan the input params , if any */ 
  393.   { 
  394.    argptr = *++ptr ; 
  395.    if ( *argptr++ == '-' ) 
  396.      { 
  397.       switch ( *argptr++ )           /* look for the param */ 
  398.        { 
  399.        case 'I' : 
  400.        case 'i' :                  /*  Input file name */ 
  401.  
  402.             open_ifile ( iptr = argptr ) ;   /* open it */ 
  403.             break ; 
  404.  
  405.        case 'D' :                  /* dots ?? */ 
  406.        case 'd' :     
  407.  
  408.             pdots = 1;             /* no */ 
  409.             break ; 
  410.  
  411.        case 'O' : 
  412.        case 'o' :                 /* Output file type */ 
  413.        
  414.            switch ( *argptr++ ) 
  415.          { 
  416.              case 'i' : 
  417.          case 'I' :           /* INTEL  */ 
  418.                 opftype = 0 ;               
  419.                 break ; 
  420.  
  421.          case 'm' : 
  422.          case 'M' :           /* MOTOROLA */ 
  423.                 ch = *argptr - '0' ; 
  424.                 opftype = 0 ; 
  425.                 switch (ch) 
  426.                   { 
  427.           case 3 :   ++opftype ; 
  428.           case 2 :   ++opftype ; 
  429.           case 1 :   ++opftype ; 
  430.                        xoMaddr = opftype + 1; 
  431.                        break ; 
  432.               default : 
  433.                        usage () ; 
  434.                        exit (1) ; 
  435.  
  436.           } 
  437.                 break ; 
  438.                  
  439.          case 'T' :           /* TEKTRONIX  */ 
  440.                 opftype = 4 ;               
  441.                 break ; 
  442.  
  443.          case 't' :           /* TEKTRONIX - extended  */ 
  444.                 opftype = 5 ;               
  445.                 break ; 
  446.                
  447.              } 
  448.            break ; 
  449.  
  450.        case 'S' : 
  451.        case 's' :                 /*  record length */ 
  452.          reclen = atoi ( argptr ) ;     
  453.          if ( !reclen || (reclen > 255) ) 
  454.        { 
  455.               usage () ; 
  456.               exit (1) ; 
  457.        } 
  458.          break ;  
  459.  
  460.        case 'C' :             /* Checksum generation */ 
  461.        case 'c' : 
  462.  
  463.          opftype = 0 ;        /* set o/p file type = INTEL */ 
  464.          if ( xmode == 3 )        
  465.                   /* ensure INTEL file if mode 3 ( checksum gen ) */ 
  466.            { 
  467.              if ( ipftype != 0 ) 
  468.                { 
  469.                  fprintf ( stderr , "File must be INTEL format!\n" ) ; 
  470.                  exit (1) ; 
  471.            } 
  472.            } 
  473.          if ( !(mallocptr = malloc ( (long)(64*1024) ))  )    /* get a K64 byte array */ 
  474.             { 
  475.               fprintf ( stderr , "Malloc fail!\n" ) ; 
  476.               exit (1) ; 
  477.             } 
  478.          for ( aa=0 ; aa < 64*1024L ; ++aa )    /* init with FFs */ 
  479.             { 
  480.               *(mallocptr+aa) = 0xFF ; 
  481.             } 
  482.          mode = 3 ;                /* set mode type */ 
  483.          break ; 
  484.        
  485.       case 'R' :                    /* checksum mode - optional ROM size */ 
  486.       case 'r' : 
  487.          romsize = atoi ( argptr ) ; 
  488.          switch ( romsize )    /* yes , validate ROM size */ 
  489.       { 
  490.            case 2 : 
  491.        case 4 : 
  492.         case 8 : 
  493.        case 16 : 
  494.        case 32: 
  495.        case 64: 
  496.               break ;               /* valid sizes s*/ 
  497.       default : 
  498.               fprintf ( stderr , "Invalid ROM size !\n" ) ; 
  499.               exit (1) ; 
  500.       } 
  501.         break ; 
  502.  
  503.       case 'P' :                    
  504.       case 'p' : 
  505.                                  /* checksum mode - dump printable charas 
  506.                                     to "temp.x2x" ; used for getting EMU 
  507.                                     screen dumps in manual preparation */ 
  508.         xpflag = TRUE ; 
  509.         if(( tffp= open( "temp.x2x" ,  
  510.                   O_RDWR | O_CREAT | O_TRUNC , 0666)) < 0 )     
  511.            { 
  512.              fprintf(stderr,"Error: unable to open temp.x2x\n" ); 
  513.              exit(1); 
  514.            } 
  515.         break ; 
  516.  
  517.       default :               /* Invalid para */ 
  518.           { 
  519.            usage () ; 
  520.            exit (1) ; 
  521.           }   
  522.     } 
  523.     } 
  524.   else                    /* no "-" sign , error */ 
  525.    { 
  526.      usage (); 
  527.      exit (1) ; 
  528.    } 
  529.  } 
  530.  
  531.  
  532.  /*--------  verify params ---------------------*/ 
  533.  
  534.  if ( (!iffp) || (opftype == -1 ) )   /* ensure enough params */ 
  535.    { 
  536.      usage () ; 
  537.      exit (1) ; 
  538.    } 
  539.  open_ofile ( iptr ) ;              /* open output file */ 
  540.  
  541.  if ( mode == 3 )       /* checksum mode ? */ 
  542.     { 
  543.       return ( mode ) ; 
  544.     } 
  545.  
  546.    /*----- adjust reclen if MOTOROLA and overflow ---------------------------*/ 
  547.  
  548.    if ( (xoMaddr + reclen) > 255 )    /* 1 byte length only ! */ 
  549.        reclen = 255 - xoMaddr ;      /* adjust */ 
  550.  
  551.  
  552.   return ( mode ) ;   
  553. } 
  554.  
  555. /*************************************************************************** 
  556.  
  557.  
  558.   Function :            open_ofile        
  559.  
  560.  
  561.   Purpose  :            gens o/p file name and opens same 
  562.  
  563.   Entry    :        
  564.  
  565.  
  566.   Returns  :       
  567.  
  568.                  
  569.  
  570. ***************************************************************************/ 
  571.  
  572. int open_ofile ( iptr ) 
  573.  
  574. char *iptr ; 
  575.  
  576. { 
  577.  
  578.   strcpy ( ofile , iptr ) ;        /* create a o/p file */  
  579.  
  580. /*---------------- muck around if using stone-age MS_DOS on PC ------*/ 
  581.  
  582. #ifdef AMIGA 
  583.     dos_fname () ; /* MS_DOS :chara file-names, only one '.' allowed , yuk ..*/ 
  584. #else 
  585.   strcat ( ofile , sfx[opftype] ) ;   /* append suffix */ 
  586. #endif    
  587.  
  588.   if(( offp= open( ofile , O_RDWR | O_CREAT | O_TRUNC , 0666)) < 0 )     
  589.     { 
  590.         fprintf(stderr,"Error: unable to open '%s'\n" , ofile ); 
  591.         exit(1); 
  592.     } 
  593.  
  594.   printf (  "\nOutput file is :  %s  ( %s )\n" ,  
  595.                                ofile ,iipftype[opftype] ) ;  
  596.  
  597. } 
  598.  
  599. /*************************************************************************** 
  600.  
  601.  
  602.   Function :           gen_csum 
  603.  
  604.  
  605.   Purpose  :           builds and writes checksum record to disc 
  606.                  
  607.  
  608.   Entry    :           
  609.  
  610.  
  611.   Returns  :           
  612.                                
  613.  
  614.  
  615. ****************************************************************************/ 
  616.  
  617.  
  618. int gen_csum ()  
  619.  
  620.  
  621. { 
  622. int j , k  ; 
  623. int addr = (long)romsize*1024 -2 ; 
  624.             
  625.  
  626.   /*------------ now calc ROM checksum ----------------------------*/ 
  627.  
  628.   for ( j=0 , csum=0 ; j < addr  ; j +=2 ) 
  629.     { 
  630.        csum += *(uchar *)(mallocptr + j) ; 
  631.        csum += ((int)*(uchar *)(mallocptr + j + 1)) << 8 ; 
  632.     } 
  633.  
  634.   /* ----------- now calc record checksum -----------------------*/ 
  635.  
  636.   k = 2 + (addr&0xFF) + (addr>>8) + (csum&0xFF) + (csum>>8) ; 
  637.   k = -k ; 
  638.  
  639.   /*------------- now build record ------------------------------*/ 
  640.  
  641.     opbuf[0] = ':' ; 
  642.     opbuf[1] = '0' ; 
  643.     opbuf[2] = '2' ;    /* length */ 
  644.      
  645.  
  646.    j = convc2 ( addr >> 8 ) ;           /* load addr - hi */ 
  647.    opbuf [IRADDR] = j >> 8 ; 
  648.    opbuf [IRADDR+1] = j & 0xFF ; 
  649.  
  650.    j = convc2 ( addr ) ;                /* load addr - lo */ 
  651.    opbuf [IRADDR+2] = j >> 8 ; 
  652.    opbuf [IRADDR+3] = j & 0xFF ; 
  653.  
  654.    j = convc2 ( csum  ) ;               /* ROM checksum  - lo */ 
  655.    opbuf [IRDATA] = j >> 8 ; 
  656.    opbuf [IRDATA+1] = j & 0xFF ; 
  657.  
  658.    j = convc2 ( csum >> 8 ) ;           /* ROM checksum -  hi */ 
  659.    opbuf [IRDATA+2] = j >> 8 ; 
  660.    opbuf [IRDATA+3] = j & 0xFF ; 
  661.  
  662.    j = convc2 ( k ) ;                /* record checksum  */ 
  663.    opbuf [IRDATA+4] = j >> 8 ; 
  664.    opbuf [IRDATA+5] = j & 0xFF ; 
  665.  
  666.    opbuf [xdllen=IRDATA+6] = '\n' ;        /* append RETURN  to  record */ 
  667.  
  668.   /*--------------now write record to disc ----------------------------------*/ 
  669.  
  670.     ++datarecs ; 
  671.     ++oprecs ; 
  672.     totchars += 2 ;                  /* update total data chara count */ 
  673.  
  674.     rite_rec ( offp , opbuf , ++xdllen ) ;   /* write it */ 
  675.  
  676.  
  677. } 
  678.  
  679. /*************************************************************************** 
  680.  
  681.   Function :       date  
  682.  
  683.   Purpose  :       plants SCCS Vers #/build date in banner 
  684.  
  685.   Entry    :       ptr to start of vers/date in banner 
  686.  
  687.   Exit conditions:  ptr to rehacked string  
  688.  
  689.  
  690.  
  691. ****************************************************************************/ 
  692.  
  693. char *date ( optr ) 
  694.  
  695. char *optr ;                   /* ptr to date line */ 
  696.  
  697. { 
  698.  
  699. static char month[] = "JanFebMarAprMayJunJulAugSepOctNovDec" ; 
  700.  
  701. /*                     0123456789012345678901234                       */ 
  702. static char copy[]  = "[ V x.x   -   dd mmm yy ]" ;      /* build, copy out*/ 
  703.  
  704. int j , k  ; 
  705. char ch ; 
  706. char *iptr ; 
  707.  
  708.  
  709. /*---------------------------------------------------------------------------*/ 
  710.  
  711.    iptr = &sccs_id[0] ; 
  712.    while ( *iptr++ == ' ' ) ;    /* look for start of SCCS vers. # */ 
  713.    --iptr   ; 
  714.       
  715.    /*----------- copy Vers # to build buffer---------------------------*/ 
  716.  
  717.    j = 4 ;                           /* start of Vers in build buffer */ 
  718.    while ( (ch = *iptr++) != ' ' )    
  719.         copy[j++] = ch ; 
  720.  
  721.    /*---------------- get Months, convert and put in buffer-------------*/ 
  722.  
  723.    while ( (ch = *iptr++) == ' ' ) ;  /* look for start of months */ 
  724.    --iptr ; 
  725.  
  726.    j = 0 ; 
  727.    while ( (ch = *iptr++) != '/' )    /* 1 or 2 charas   */ 
  728.      { 
  729.          j = 10*j + (ch - '0') ;          /* yes */ 
  730.      } 
  731.  
  732.    j = 3 * (j-1) ;                     /* index to start of "mmm" charas */ 
  733.  
  734.    for ( k=0 ; k < 3 ; ++k , ++j ) 
  735.       copy [17+k] = month[j] ;         /* copy 3 charas to buffer */ 
  736.  
  737.    /*---------------- get days, and put in buffer-----------------------*/ 
  738.  
  739.    copy[15] = *iptr++ ;                    /* days - 1 */ 
  740.    if ( (ch = *iptr++) != '/' ) 
  741.       { 
  742.          copy[14] = copy[15] ;         /* shuffle up */ 
  743.          copy[15] = ch ;                /* days 2 - if there */ 
  744.        } 
  745.     ++iptr; 
  746.  
  747.    /*---------------- get years,  and put in buffer-----------------------*/ 
  748.  
  749.    copy[21] = *iptr++ ;                    
  750.    copy[22] = *iptr++ ;                    
  751.  
  752.    return ( copy ) ;    /* return with ptr to string */ 
  753.     
  754. } 
  755.  
  756. /*************************************************************************** 
  757.  
  758.  
  759.   Function :           usage 
  760.  
  761.  
  762.   Purpose  :          prints calling params for "emu" 
  763.                  
  764.  
  765.   Entry    :           
  766.  
  767.  
  768.   Returns  :           
  769.                                
  770.  
  771.  
  772. ****************************************************************************/ 
  773.  
  774.  
  775. int usage () 
  776.  
  777. { 
  778. static char *rats[] = { 
  779. "\n", 
  780. "Usage 1 & 2 :\n", 
  781. "-----------\n", 
  782. " Converts a given ASCII-hex file in Down-Line Load (DLL) format to another\n", 
  783. " or the same  DLL format . \n", 
  784. " ( Note that record checksums are not verified in the source file - this\n", 
  785. "   means that a record  can be altered and the file regenerated without the\n", 
  786. "   tedium of having to recalculate the checksum ).\n", 
  787. "\n", 
  788. "usage <1> : x2x   ( parameters are solicited )", 
  789. "\n", 
  790. "usage <2> : x2x -Ifilename -Otype [-Sxxx] \n",
  791. "\n", 
  792. "     (O)utput file types  : \n" , 
  793. "                       I  = Intel\n", 
  794. "                       M1 = Motorola S1\n", 
  795. "                       M2 = Motorola S2\n", 
  796. "                       M3 = Motorola S3\n", 
  797. "                       T  = Tektronix\n", 
  798. "                       t  = Tektronix-extended\n", 
  799. "     xxx = record data length ( 1-255 , def=16 )\n" ,  
  800. "\n", 
  801. "" 
  802. } ; 
  803.  
  804. int j = 0 ; 
  805. char *ptr ; 
  806.  
  807.  
  808.   while ( *(ptr = rats[j++])  ) 
  809.     printf ( "%s", ptr ) ; 
  810.  
  811. } 
  812.