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_1.c < prev    next >
C/C++ Source or Header  |  1990-04-16  |  11KB  |  447 lines
  1. /*SCCS header -          %W%   %G%                                     */
  2. /************************************************************************ 
  3. *                                                                       * 
  4. *                      Filename:        x2x_1.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. *+              rite_rec        writes DLL record to disc 
  30. *+              get_rtype       validates input file as INTEL/MOTOROLA/TEK.. 
  31. *+              f_reset         resets file pointer to start 
  32. *+              dll_Irec        builds an INTEL  record 
  33. *+              dll_Mrec        builds a MOTOROLA  record 
  34. *+              dll_Trec        builds a TEKTRONIX  record 
  35. *+              dll_Txrec       builds a TEKTRONIX-extended  record 
  36. *+              dll_Qrec        builds a QTAM  record 
  37. *+  
  38. * 
  39. ******************************************************************************/ 
  40.  
  41. #include "x2x_amiga.h"
  42. #include "x2x_data.c"
  43.  
  44.  
  45.  
  46. /*************************************************************************** 
  47.  
  48.  
  49.   Function :     get_Irec  
  50.  
  51.  
  52.   Purpose  :     reads and compacts an INTEL record (termed by a RET) 
  53.  
  54.   Entry    : 
  55.  
  56.  
  57.   Returns  :     TRUE -  
  58.  
  59.                  FALSE-  
  60.  
  61.  
  62. ****************************************************************************/ 
  63.  
  64. int get_Irec () 
  65.  
  66. { 
  67.   int cch , len , count ; 
  68.  
  69.   
  70.      get_rstart ( ':' ) ;        /* search for record start */ 
  71.  
  72.       count = 0 ; 
  73.        
  74.       while ( count != 4 )                /* process record */ 
  75.     { 
  76.           cch = getc2 ( ) ; 
  77.  
  78.           switch ( count++ ) 
  79.         { 
  80.              case 0 : 
  81.                ilen = cch   ;            
  82.                glen = ilen ;          /* data length */
  83.                break ; 
  84.     
  85.              case 1 : 
  86.                iaddr = cch << 8  ;     /* addr hi */ 
  87.                 break ; 
  88.     
  89.              case 2 : 
  90.                 iaddr |= cch  ;       /* addr lo */ 
  91.                break ; 
  92.  
  93.              case 3 :                 /* type - */ 
  94.                 itype = cch ; 
  95.  
  96.                 if ( itype == 1 )           /* check for end record */ 
  97.                    return ( 0 ) ; 
  98.                 break ; 
  99.             } 
  100.     } 
  101.         /*--------------- act on rec type -----------------------------*/ 
  102.  
  103.        if ( itype == 0 )          /* data rec here  */ 
  104.         {         
  105.           len = ilen ; 
  106.           count = 0 ; 
  107.           while ( len-- ) 
  108.              { 
  109.                cch = getc2 () ; 
  110.  
  111.                yaddr = xibase + iaddr++ ;   /* gen address */ 
  112.                xputc ( yaddr , cch ) ;     /* put addr/chara in buffer */ 
  113.  
  114.              } 
  115.      } 
  116.        else if ( itype == 2 )         /* seg addr ( USBA ) */ 
  117.          { 
  118.             xibase  = getc2() << 8 ;   /* hi  */ 
  119.             xibase |= getc2 ()     ;   /* lo  */ 
  120.             xibase = xibase << 4   ;   /* make abs  */ 
  121.       } 
  122.        else 
  123.      { 
  124.                       /* ignore anything else */ 
  125.      } 
  126.       return ( 1 ) ; 
  127. } 
  128.  
  129. /*************************************************************************** 
  130.  
  131.  
  132.   Function :     get_Mrec 
  133.  
  134.  
  135.   Purpose  :     Get a Motorola S record 
  136.  
  137.   Entry    : 
  138.  
  139.  
  140.   Returns  :     
  141.  
  142.  
  143. ****************************************************************************/ 
  144.  
  145. int  get_Mrec ()        /* gets a Motorola S record                  */ 
  146.  
  147.  
  148. { 
  149.   int cch , len , count , type ; 
  150.   int adrlen = 0 ; 
  151.   
  152.   while ( !adrlen )              /* ignore all but S1,2,3,9 recs */ 
  153.     { 
  154.       get_rstart ( 'S' ) ;        /* search for record start */ 
  155.        
  156.       type = Ichar() - '0' ; 
  157.       switch ( type ) 
  158.     { 
  159.         case 9: 
  160.                 return ( 0 ) ;     /* EOF */ 
  161.  
  162.     case 3   :  ++adrlen ; 
  163.     case 2   :  ++adrlen ; 
  164.     case 1   :  ++adrlen ; 
  165.  
  166.                break ;        
  167.     default : 
  168.         {} ;                 /* loop */ 
  169.     } 
  170.     } 
  171.       count = 0 ; 
  172.       iaddr = 0 ; 
  173.        
  174.       while ( count != (adrlen + 2) )    /* get len , then 2/3/4 addr bytes */ 
  175.     { 
  176.           cch = getc2 ( ) ; 
  177.  
  178.           switch ( count++ ) 
  179.         { 
  180.              case 0 : 
  181.                ilen = cch - adrlen - 2   ;  /* # of data bytes */            
  182.                len = ilen ; 
  183.                break ; 
  184.     
  185.              case 1 : 
  186.                iaddr = cch   ;         /* addr hi */ 
  187.                 break ; 
  188.     
  189.              case 2 : 
  190.                 iaddr = (iaddr<<8) | cch  ;       /* addr lo */ 
  191.                break ; 
  192.                                         /*--next bytes maybe--- */ 
  193.              case 3 : 
  194.                 iaddr = (iaddr<<8) | cch  ;       /* addr lo */ 
  195.  
  196.                break ; 
  197.  
  198.              case 4 : 
  199.                 iaddr = (iaddr<<8) | cch  ;       /* addr lo */ 
  200.  
  201.                break ; 
  202.  
  203.             } 
  204.     } 
  205.            
  206.           /* read data bytes */ 
  207.          
  208.           count = 0 ; 
  209.           while ( len-- ) 
  210.              { 
  211.  
  212.                cch = getc2 () ; 
  213.  
  214.                xputc ( iaddr++, cch ) ;     /* put addr/chara in buffer */ 
  215.  
  216.              } 
  217.  
  218.   return ( 1 ) ;        /* flag data type */ 
  219. } 
  220.  
  221. /*************************************************************************** 
  222.  
  223.  
  224.   Function :     get_Trec 
  225.  
  226.  
  227.   Purpose  :     Get a TEKTRONIX record 
  228.  
  229.   Entry    : 
  230.  
  231.   Returns  :     TRUE -  
  232.  
  233.                  FALSE- 
  234.  
  235.  
  236. ****************************************************************************/ 
  237.  
  238. int  get_Trec ()        /* gets a TEKTRONIX record                  */ 
  239.  
  240.                         /* returns FALSE if error & xerrno = error    */ 
  241.  
  242.  
  243. { 
  244.   int cch , len , count ; 
  245.  
  246.  
  247.  
  248.       get_rstart ( '/' ) ;        /* search for record start */ 
  249.   
  250.       count = 0 ; 
  251.        
  252.       while ( count != 4 )                /* process record */ 
  253.     { 
  254.           cch = getc2 ( ) ; 
  255.  
  256.           switch ( count++ ) 
  257.         { 
  258.     
  259.              case 0 : 
  260.                iaddr = cch << 8  ;     /* addr hi */ 
  261.                 break ; 
  262.     
  263.              case 1 : 
  264.                 iaddr |= cch  ;       /* addr lo */ 
  265.                 break ; 
  266.  
  267.              case 2 :                 /* len */ 
  268.                ilen = cch   ;            
  269.                glen = ilen ; 
  270.                if ( !ilen )          /* exit if last record */ 
  271.                  { 
  272.                    return ( 0 ) ; 
  273.          } 
  274.  
  275.                 break ; 
  276.  
  277.              case 3  :                 /* load sum - ignore */ 
  278.                 break ;  
  279.             } 
  280.     } 
  281.            
  282.           /* read data bytes */ 
  283.          
  284.           len = ilen ; 
  285.           count = 0 ; 
  286.           while ( len-- ) 
  287.              { 
  288.  
  289.                cch = getc2 () ; 
  290.  
  291.                xputc ( iaddr++, cch ) ;     /* put addr/chara in buffer */ 
  292.  
  293.              } 
  294.          return ( 1 ) ;        /* not EOF return */ 
  295. } 
  296.  
  297.  
  298. /*************************************************************************** 
  299.  
  300.  
  301.   Function :     get_trec 
  302.  
  303.  
  304.   Purpose  :     Get a TEKTRONIX-extended  record 
  305.  
  306.   Entry    : 
  307.  
  308.   Returns  :     TRUE -  
  309.  
  310.                  FALSE- 
  311.  
  312.  
  313.   Record Format :     %lltCCkx...x<Hex data pairs> 
  314.  
  315.                        ll = length ( all charas after % ) 
  316.                        t  = type chara ( 6 = data , 8 = end ) 
  317.                        CC = checksum  
  318.                        k  = # of address charas, max 8 ( = 4 bytes ) 
  319.                        x...x = 'k' address charas 
  320.          
  321.                        .... data as usual 
  322.   
  323.  
  324. ****************************************************************************/ 
  325.  
  326. int  get_trec ()        /* gets a TEKTRONIX-extended record                  */ 
  327.  
  328.                         /* returns FALSE if error & xerrno = error    */ 
  329.  
  330.  
  331. { 
  332.   int type , cch , count ,  len , nchars ; 
  333.  
  334.  
  335.       get_rstart ( '%' ) ;        /* search for record start */ 
  336.   
  337.       count = 0 ; 
  338.        
  339.       nchars = getc2 ()   ;           /* get length */ 
  340.  
  341.      if ( (type = Ichar ()) == -1 )                  /* MS nibble   */ 
  342.       { 
  343.          fprintf ( stderr , "\Ichar fail" ) ; 
  344.          exit (3) ; 
  345.       } 
  346.  
  347.       if ( type == '8' ) 
  348.           return ( 0 ) ;                 /* end record */ 
  349.       if ( type != '6' ) 
  350.         { 
  351.           fprintf (stderr , "\nBad type ( %d ) " , type ) ; 
  352.           exit (3) ; 
  353.         } 
  354.         
  355.        getc2 () ;                   /* discard 2 checksum charas */ 
  356.  
  357.  
  358.      if ( (len = Ichar ()) == -1 )                  /* MS nibble   */ 
  359.       { 
  360.          fprintf ( stderr , "\Ichar fail" ) ; 
  361.          exit (3) ; 
  362.       } 
  363.        len -=  '0'     ;   /* get addr len  */ 
  364.        nchars = nchars - len - 6 ;  /* adjust for data len */ 
  365.  
  366.        iaddr = 0 ; 
  367.        while ( len-- )              /* build addr */ 
  368.         { 
  369.           if ( (cch = Ichar ()) == -1 )                  /* MS nibble   */ 
  370.             { 
  371.               fprintf ( stderr , "\Ichar fail" ) ; 
  372.               exit (3) ; 
  373.             } 
  374.            cch -= '0' ; 
  375.            iaddr = iaddr*16 + cch ; 
  376.         } 
  377.  
  378.          
  379.            
  380.         /* read data bytes */ 
  381.          
  382.         ilen = nchars / 2 ;    /* set up ext # of bytes */ 
  383.         len = ilen ; 
  384.  
  385.           while ( len-- ) 
  386.              { 
  387.                cch = getc2 () ; 
  388.  
  389.                xputc ( iaddr++, cch ) ;     /* put addr/chara in buffer */ 
  390.  
  391.              } 
  392.          return ( 1 ) ;        /* not EOF return */ 
  393. } 
  394.  
  395. /*************************************************************************** 
  396.  
  397.  
  398.   Function :     get_Qrec 
  399.  
  400.  
  401.   Purpose  :     Get a QTAM record 
  402.  
  403.   Entry    : 
  404.  
  405.   Returns  :     TRUE -  
  406.  
  407.                  FALSE- 
  408.  
  409.  
  410. ****************************************************************************/ 
  411.  
  412. int  get_Qrec () 
  413.  
  414.  
  415.  
  416. { 
  417.   int cch , len  ; 
  418.  
  419.  
  420.  
  421.    get_rstart ( 'Q' ) ;        /* search for record start */ 
  422.   
  423.    len = Ichar () ;                     /* length */ 
  424.    if ( !len )  
  425.       return ( 0 ) ;                    /* EOF */ 
  426.  
  427.    yaddr = Ichar () ;                    /*  3 addr bytes */ 
  428.    yaddr = (yaddr << 8 ) | Ichar () ; 
  429.    yaddr = (yaddr << 8 ) | Ichar () ; 
  430.            
  431.    /* read data bytes */ 
  432.          
  433.  
  434.           while ( len-- ) 
  435.              { 
  436.                cch = Ichar () ; 
  437.                xputc ( yaddr++, cch ) ;     /* put addr/chara in buffer */ 
  438.  
  439.              } 
  440.  
  441.          Ichar () ;           /* discard c/sum chara */ 
  442.  
  443.          return ( 1 ) ;        /* not EOF return */ 
  444.  
  445.  
  446. } 
  447.