home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 373.lha / X2X / x2x_main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-05-05  |  16.0 KB  |  570 lines
  1. /*SCCS header -          %W%   %G%                                     */
  2. /************************************************************************ 
  3. *                                                                       * 
  4. *                      Filename:        x2x_main.c                      *      
  5. *                       Version:        0.0                             * 
  6. *                       Author :        Gary Duncan                     * 
  7. *                    24 Inkster St                   *
  8. *                    Kambah ACT 2902                 *
  9. *                    Australia                       *
  10. *                                                                       * 
  11. *-----------------------------------------------------------------------*/
  12.  
  13. #include "x2x_amiga.h"
  14. #include "x2x_data.c"
  15. extern uchar Ichar();
  16. extern char *MakeDate[] ;
  17. /*************************************************************************
  18. * 
  19. * Modification record 
  20. * ------------------- 
  21. * 
  22. * Date         By whom             Change 
  23. * ----         -------             ------ 
  24. * 
  25. * 12 Apr 89     GMD                AMIGA'd
  26. * 
  27. *------------------------------------------------------------------------ 
  28. *  
  29. *    This program will convert a given file in Down-Line Load (DLL) format 
  30. *    to another (or the same)  DLL format .  
  31. * 
  32. *    The DLL formats are the usual ASCII_hex formats of  
  33. *    INTEL / TEKTRONIX ( and extended) /  MOTOROLA (S1-3)  
  34. * 
  35. *    If no input params , the program solicits for :- 
  36. * 
  37. *        1) Input File name ( which it then scans to determine DLL format) 
  38. *        2) Output file DLL format 
  39. *        3) Output DLL record DATA length ( 0 < len < 256 ) 
  40. * 
  41. *   ( In MOTOROLA format , prompts are made for addr length , ie 2,3, 4 bytes)  
  42. * 
  43. *      else ( if there are params ) , it is invoked as follows :- 
  44. * 
  45. *      x2x -Ifilename -Otype [-Srecord_data_length] 
  46. * 
  47. *      type :  I=INTEL , T=TEKTRONIX ,t= TEKTRONIX (extended) 
  48. *              M1=MOTOROLA (S1) , M2=MOTOROLA (S2) M3=MOTOROLA (S3) 
  49. *     
  50. * 
  51. * Output file name generation 
  52. *----------------------------- 
  53. * 
  54. * VAX 
  55. * 
  56. *    The input file name then has ".xi / .xt / .xm2,3,or4 / or .xq appended 
  57. *    to form the output file name. Note that no overwrite check is done. 
  58. *    e.g  fred.xi -> fred.xi.xi -> fred.xi.xi.x(whatever) etc  
  59. * 
  60. * PC 
  61. * 
  62. *    A filename in wonderful MS_DOS is limited to the form of :- 
  63. *    <8 charas max>.< 3 charas max> thus appending ( appension ?) to 
  64. *    avoid ambiguity is not possible thus we progressively "backspace" 
  65. *    from the "." separator looking for a non-'&' chara which is then 
  66. *    transformed to '&'. 
  67. *    e.g   (INTEL to INTEL ) , abcdef.xi -> abcde&.xi -> abcd&&.xi etc  
  68.  
  69. *     
  70. *    Note that there is no restriction on cross-conversion ; ie you can 
  71. *    use this program to produce a file of the same format but of a different  
  72. *    data length. ( This could be useful because utilities such as  AZTEC  
  73. *    'hex86' program only create DLL records  with the boring length of 16)  
  74. * 
  75. *    Whilst running , the program displays dots before the eyes to soothe 
  76. *    those who are nervous about silent programs. 
  77. * 
  78. * 
  79. * On Completion 
  80. * ------------- 
  81. *                 ... some nice stats are presented. Note that the  
  82. *                checksum is a one_byte_sum_with_carry_wrap of the data  
  83. *                bytes ( a la MICE ) so if using the MICE you can verify  
  84. *                the Down Line Load with its memory checksum command (T). 
  85. *                ( valid only for contiguous load , of course )  
  86. * 
  87. ************************************************************************* 
  88. * 
  89. *                                                                       * 
  90. *         This program  will run on a uVAX or IBM PC                    * 
  91. *                                                                       * 
  92. *  VAX build    :   cc -o x2x x2x.c        ( produces x2x* )            * 
  93. *                                                                       * 
  94. *  IBM PC  "    :   cc -DAMIGA x2x.c                                    * 
  95. *                   ln x2x.o \lib\c.lib \lib\s.lib                      * 
  96. *                                              ( produces x2x.exe )     * 
  97. *                                                                       * 
  98. *                                                                       * 
  99. ************************************************************************* 
  100.  
  101. * 
  102. ############################################################################# 
  103. # 
  104. #  Examples of ACSII-hex formats for :- 
  105. # 
  106. #    INTEL 
  107. #    MOTOROLA 
  108. #    TEKTRONIX ( inc extended format ) 
  109. # 
  110. # 
  111. #  Note: the INTEL example (data length 16dec bytes) is the reference. 
  112. #      : in following "byte" =  binary value of 2 ASCII-hex charas 
  113. #                               hi nibble = 1st byte  
  114. # 
  115. ############################################################################# 
  116.  
  117. # 
  118. # Format :  INTEL 
  119. # 
  120.  
  121. :LLAAAATTdd..ddCC 
  122.  
  123. LL   = # of data bytes  
  124. AAAA = 16 bit address 
  125. TT   = type  
  126.         0 = data 
  127.         1 = end record 
  128.         2 = Upper Segment Base Address (USBA) 
  129.         3 = start address record ( data length = 4 bytes) 
  130.  
  131. CC   = checksum ( = -ve sum of record : ie sum of all byte-pairs = 0 ) 
  132. dd = ASCII-hex charas 
  133.  
  134. USBA format = :02000002ssssCC 
  135. ( following data records will be have (16 * ssss) added to their load addr) 
  136.  
  137.  
  138. ---------------------------------------------------------------------------- 
  139.  
  140. :020000020500??                              # type 2 record , base = 500H 
  141. :1012340090FAFCE96B002020202020202020202090  # type 0 record (data) 
  142.                                              #      (load addr = 1234H) 
  143. :00000001FF                                  # type 1 record (end) 
  144.  
  145. # above converted to :- 
  146.  
  147. :1062340090FAFCE96B002020202020202020202040    <<EXAMPLE 
  148. :00000001FF 
  149.  
  150. #----------------------------------------------------------------------------- 
  151. # 
  152. #  MOTOROLA - all use S9 as end record 
  153. # 
  154. # 
  155. # Format :  Motorola ( S1 , 16 bit address ) 
  156. # 
  157.     |<-------------- LL ---------------->| 
  158. S1LLAAAAdd..ddCC                             << Format 
  159.  
  160. LL = 2 + (# of data bytes) + 1    
  161. AAAA = address 
  162. CC = ~( LL + (AA .. + AA) + ( data bytes ))  : Note 1's complement! 
  163.  
  164.  
  165. S1LLAAAAdd..ddCC                              << Format 
  166. S113623490FAFCE96B00202020202020202020203C    <<EXAMPLE 
  167. S9030000FC 
  168.  
  169. #----------------------------------------------------------------------------- 
  170. # 
  171. # Format :  Motorola ( S2 , 24 bit address ) 
  172. # 
  173. S2LLAAAAAAdd..ddCC                              << Format 
  174. S21400623490FAFCE96B00202020202020202020203B    <<EXAMPLE 
  175. S904000000FB 
  176.  
  177. #----------------------------------------------------------------------------- 
  178. # 
  179. # Format :  Motorola ( S3 , 32 bit address ) 
  180. # 
  181. STLLAAAAAAAAdd..ddCC                              << Format 
  182. S3150000623490FAFCE96B00202020202020202020203A    <<EXAMPLE 
  183. S90500000000FA 
  184.  
  185. #----------------------------------------------------------------------------- 
  186. # 
  187. # Format :  Tektronix 
  188. # 
  189. #  Note checksum algorithm 
  190. # 
  191. /AAAALLRRdd..ddCC    << Format 
  192.  
  193. AAAA = load address 
  194. LL   = record length ( # of data bytes : 0 = last record ) 
  195. RR   = load checksum ( = sum of previous 6 de-ASCII'd CHARAS ) 
  196. CC   = data    "     ( sum of de-ASCII'D CHARAS ) 
  197.  
  198. /AAAALLRRdd..ddCC                              << Format 
  199. /6234101090FAFCE96B002020202020202020202079    <<EXAMPLE 
  200. /00000000 
  201.  
  202. #----------------------------------------------------------------------------- 
  203. # 
  204. # Format :  Tektronix (extended) 
  205. # 
  206. #  Note checksum algorithm 
  207. # 
  208. %LLTCCky......ydd..dd    << Format 
  209.  
  210. LL = length ( all charas after % ) 
  211. T  = type chara ( 6 = data , 8 = end ) 
  212. CC = checksum   ( sum of all de-ASCII'd CHARAS = 0 ) 
  213. k  = # of address charas, max 8 ( = 4 bytes ) 
  214. y...y = 'k' address charas 
  215. xx =  data as usual 
  216.  
  217.   
  218. %LLTCCky......ydd..dd    << Format 
  219.  
  220. %2E6A680000623490FAFCE96B0020202020202020202020    <<EXAMPLE 
  221. %0E81E800000000 
  222.  
  223.  
  224. * 
  225. *------------------------------------------------------------------------------ 
  226. * Contents 
  227. * ------- 
  228. *+ 
  229. *+              main            exec bit..           
  230. *+              getc2           gets byte from 2 ASCII hex bytes 
  231. *+              convc2          converts 2 ASCII hex bytes to a byte 
  232. *+              get_hex         converts ASCII hex chara to binary 
  233. *+              Ichar           gets chara from input file 
  234. *+  
  235. * 
  236. ******************************************************************************/ 
  237.  
  238.  
  239.  
  240. /*------------------------------------------------------------------------*/ 
  241.  
  242. main (argc,argv) 
  243. int argc; 
  244. char *argv[]; 
  245.  
  246. { 
  247. int temp ; 
  248.  
  249.  
  250.  /*----------------------- announce program / vers -------------------------*/ 
  251.  
  252.  
  253.  printf ( "\nX2X - %s : written by Gary Duncan\n" , MakeDate[0]  ) ; 
  254.  
  255.  iffp = 0 ; 
  256.  opftype = -1 ;                 /* invalidate things */ 
  257.  
  258.  if ( argc == 1 )                /* no params , solicit for them */ 
  259.    sol_params () ;          
  260.  else                            /* use command line params then */ 
  261.    xmode = com_params ( argc , argv ) ; 
  262.  
  263.  
  264.  /*------------------------   build o/p file here -------------------------*/ 
  265.  
  266.  f_reset () ; 
  267.  
  268.  xlen = 1 ;  
  269.  while ( xlen )                      /* loop to process input file  */ 
  270.    {  
  271.  #if 0
  272.      if ( func1 () )                /* PC only - exit on FUNC1   */ 
  273.        exit (1) ; 
  274.  #endif
  275.  
  276.      fill_ipbuf () ;                    /* fill input data buffer */ 
  277.      xaddr = 0 ; 
  278.      xlen = get_len ( &xaddr ) ;        /* find length of continuous chunk */ 
  279.      
  280.      switch ( opftype ) 
  281.      { 
  282.        case 0 :                      /* INTEL  */ 
  283.  
  284.          if ( ousba != ousban )  /* .. build a type 2 record maybe ? */ 
  285.            { 
  286.              ousba = ousban ; 
  287.              xdllen = dll_Irec ( 2 , (long)ousba  , 2 ) ;   /* gen record */ 
  288.  
  289.              opbuf [xdllen++] = '\n' ;     /* append RETURN  to  record */ 
  290.      
  291.              rite_rec ( offp , opbuf , xdllen ) ;   /* write it */ 
  292.              ++oprecs ; 
  293.            }             
  294.  
  295.          if (xlen)     /* end record ? */ 
  296.             { 
  297.               xtype = 0 ;                     /* no */ 
  298.             } 
  299.          else                  /* yes , maybe insert checksum record */ 
  300.             { 
  301.               xtype = 1 ;  
  302.               if ( xmode == 3 )    /* checksum mode ? */ 
  303.         { 
  304.                    gen_csum () ;   /* build and write last data rec */ 
  305.         } 
  306.             }  
  307.          
  308.          xdllen = dll_Irec ( xtype, xaddr, xlen ) ;  /* build INTEL record  */ 
  309.           
  310.          break ; 
  311.   
  312.        case 1 :                     /* MOTOROLA  */ 
  313.        case 2 : 
  314.        case 3 :   
  315.  
  316.          (xlen) ? (xtype = opftype + '0') : (xtype = '9') ; 
  317.                                                      /* data or eof rec type */ 
  318.           xdllen =  dll_Mrec ( xtype , xaddr , xlen )  ; 
  319.              break ; 
  320.  
  321.        case 4 :                       /* TEKTRONIX  */ 
  322.  
  323.           xdllen  = dll_Trec ( 0 , xaddr ,xlen ) ; 
  324.           break ; 
  325.  
  326.        case 5 :                       /* TEKTRONIX - extended   */ 
  327.           
  328.  
  329.          (xlen) ? (xtype = '6') : (xtype = '8') ; /* data or eof rec type */ 
  330.  
  331.           xdllen  = dll_Txrec ( xtype , xaddr ,xlen ) ; 
  332.           break ; 
  333.  
  334.        case 6 :                        /* QTAM  */ 
  335.            
  336.           xdllen = dll_Qrec ( 0 , xaddr , xlen ) ; 
  337.           break ; 
  338.  
  339.        }  ; 
  340.  
  341.   /*--------------now write record to disc ----------------------------------*/ 
  342.  
  343.     ++datarecs ; 
  344.     ++oprecs ; 
  345.     totchars += xlen ;                  /* update total data chara count */ 
  346.  
  347.     opbuf [xdllen++] = '\n' ;            /* append RETURN  to each record */ 
  348.      
  349.     rite_rec ( offp , opbuf , xdllen ) ;   /* write it */ 
  350.  
  351.     if ( (!(totchars & 0x3FF) )  && (!pdots)  )                        
  352.        fprintf ( stderr , "." ) ;   /* dots before the eyes.... , every 1K */ 
  353.  
  354.  
  355.    } 
  356.  
  357. /*-------------------- FIN , print a message -------------------------------*/ 
  358.  
  359.   if ( odccon )                                  /* flush write buffer */ 
  360.    {  
  361.     if ( write( offp , dlldbuf , odccon) != odccon ) 
  362.        {    
  363.         perror("Disc write error: "); 
  364.         exit(3); 
  365.        } 
  366.    } 
  367.  
  368.        printf (  "\nOutput file is :  %s\n" , ofile  ) ; 
  369.        printf ( "*** Total recs = %d, Data recs = %d \n", oprecs , datarecs ) ; 
  370.        printf ( "*** Reclen = %d, Data chars = %ldDec/%lXH \n", 
  371.                        reclen , totchars, totchars ) ; 
  372.  
  373.     /*--------- if -P/-C  option , put printable charas in checksum buffer 
  374.                 into "temp.x2x" ( bit of a kluge for documentation) ----*/ 
  375.  
  376.       if ( temp = strlen ( mallocptr ) ) 
  377.         if ( write( tffp , mallocptr , temp ) != temp ) 
  378.               {    
  379.                  fprintf (stderr,"(rite_rec) - write error" ); 
  380.                  perror("Disc write error: "); 
  381.                  exit(3); 
  382.               } 
  383.              
  384.  
  385.         
  386.     exit (0) ; 
  387.  
  388. } 
  389.  
  390.  
  391. /*************************************************************************** 
  392.  
  393.  
  394.   Function :      getc2 
  395.  
  396.   Purpose  : 
  397.  
  398.   Entry    : 
  399.  
  400.   Returns  :     TRUE -  
  401.  
  402.                  FALSE- 
  403.  
  404.  
  405.  
  406. ****************************************************************************/ 
  407.  
  408. int  getc2 (  )       /* returns with de-hexed byte  
  409.                  from 2 ASCII hex bytes       */ 
  410.  
  411.  
  412.  
  413. { 
  414.   int c , c0 , c1  ; 
  415.  
  416.   if ( (c = Ichar ()) == -1 )                  /* MS nibble   */ 
  417.     { 
  418.        fprintf ( stderr , "\Ichar fail" ) ; 
  419.        exit (3) ; 
  420.     } 
  421.   if ( (c0 = get_hex (c) ) == -1 ) 
  422.     { 
  423.        fprintf ( stderr , "\Non ASCII-hex chara in file = %c " , c ) ; 
  424.        exit (3) ; 
  425.     } 
  426.  
  427.   if ( (c = Ichar ()) == -1 )                  /* MS nibble   */ 
  428.     { 
  429.        fprintf ( stderr , "\Ichar fail" ) ; 
  430.        exit (3) ; 
  431.     } 
  432.   if ( (c1 = get_hex (c) ) == -1 ) 
  433.     { 
  434.        fprintf ( stderr , "\Non ASCII-hex chara in file" ) ; 
  435.        exit (3) ; 
  436.     } 
  437.  
  438.   c = (( c0 << 4 )  | c1 )  ;     
  439.  
  440.   return ( c & 0xFF ) ;         /* ensure return byte here only  */ 
  441.  
  442. } 
  443.  
  444.  
  445. /*************************************************************************** 
  446.  
  447.  
  448.   Function :      convc2 
  449.  
  450.   Purpose  :      converts byte to 2 ASCII hex charas  
  451.  
  452.   Entry    : 
  453.  
  454.   Returns  :      (hi byte/lo byte)  as int  
  455.  
  456.  
  457.  
  458.  
  459. ****************************************************************************/ 
  460.  
  461. int  convc2 ( bite  ) 
  462.  
  463. unsigned char bite ; 
  464.  
  465.  
  466. { 
  467.   unsigned char cc , k  ; 
  468.   unsigned int chch = 0  ; 
  469.  
  470.    cc = bite  ; 
  471.  
  472.    k = cc ; 
  473.  
  474.     cc = (k >> 4) & 0xF ;     /* MS nibble  */ 
  475.  
  476.   (cc < 0xA) ? ( cc = cc + '0') : ( cc = cc + 'A' - 10 ) ;  
  477.  
  478.   chch = (int) cc << 8  ;            /*Hi  nibble  */ 
  479.  
  480.   cc = k & 0xF ; 
  481.  
  482.   (cc < 0xA) ? ( cc = cc + '0') : ( cc = cc + 'A' - 10 ) ;  
  483.   
  484.   return ( chch | cc ) ; 
  485.  
  486. } 
  487.  
  488. /*************************************************************************** 
  489.  
  490.  
  491.   Function :    get_hex 
  492.  
  493.   Purpose  :    Returns with given ASCII hex chara de-ASCIIed 
  494.  
  495.   Entry    :    chara 
  496.  
  497.   Returns  :     - 1 , error , else chara ( 0 > 15 )  
  498.  
  499.  
  500.  
  501.  
  502. **************************************************************************/ 
  503.  
  504. int get_hex ( bite )  
  505.  
  506.  
  507. uchar bite ; 
  508.  
  509. { 
  510.    if ( isdigit (bite) ) 
  511.       return ( bite & 0xF ) ;                  /* number */ 
  512.  
  513.   bite |= 0x20 ; 
  514.  
  515.   if ( islower (bite) && ( bite < 'g')  ) 
  516.      return ( (bite & 0xF) + 9 )   ;           /* A _ F */ 
  517.  
  518.   return ( -1 )  ;                             /* error */ 
  519.  
  520. } 
  521.  
  522. /*************************************************************************** 
  523.  
  524.  
  525.   Function :    Ichar 
  526.  
  527.   Purpose  :    Returns with chara from input file 
  528.  
  529.   Entry    :    chara 
  530.  
  531.   Returns  :     - 1 , error , else chara  
  532.  
  533.  
  534.  
  535.  
  536. **************************************************************************/ 
  537.  
  538.  
  539. uchar Ichar () 
  540.  
  541. { 
  542.  int  ch ; 
  543.  
  544.    if ( boffs == -1 ) 
  545.        return ( -1 ) ;            /* File empty */ 
  546.  
  547.    if ( !disclen ) 
  548.      { 
  549.        disclen =   read (iffp , dbuf , 1024 ) ; /* read a block of file */ 
  550.        boffs = 0 ; 
  551.      } 
  552.  
  553.    if ( !disclen ) 
  554.       return ( -1 ) ; 
  555.     
  556.    ch =  dbuf[ boffs ] &0xFF  ; 
  557.  
  558.    xchek += ch ;                  /* accum a checksum for ext use */ 
  559.  
  560.    if (  ++boffs != disclen ) 
  561.        return ( ch ) ; 
  562.    else if ( boffs == 1024 ) 
  563.        disclen  = 0 ;                 /* flag buffer empty */ 
  564.    else  
  565.        boffs = -1 ;                   /* flag file empty   */ 
  566.  
  567.    return ( ch ) ; 
  568.    
  569. } 
  570.