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_2.c < prev    next >
C/C++ Source or Header  |  1990-04-16  |  22KB  |  906 lines
  1. /*SCCS header -          %W%   %G%                                     */
  2. /************************************************************************ 
  3. *                                                                       * 
  4. *            File   :          x2x_2.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. * 01 Jul 89    "           Changed K64 to K64K
  21. *
  22. *------------------------------------------------------------------------ 
  23.  
  24.  
  25. * 
  26. *------------------------------------------------------------------------------ 
  27. * Contents 
  28. * ------- 
  29. *+ 
  30. *+              rite_rec        writes DLL record to disc 
  31. *+              get_rtype       validates input file as INTEL/MOTOROLA/TEK.. 
  32. *+              f_reset         resets file pointer to start 
  33. *+              dll_Irec        builds an INTEL  record 
  34. *+              dll_Mrec        builds a MOTOROLA  record 
  35. *+              dll_Trec        builds a TEKTRONIX  record 
  36. *+              dll_Txrec       builds a TEKTRONIX-extended  record 
  37. *+              dll_Qrec        builds a QTAM  record 
  38. *+              sum_get         gets a checksum on a string 
  39. *+              xgetc           gets a DLL byte     
  40. *+              xputc           puts a DLL addr/byte pair in buffer 
  41. *+              fill_ipbuf      replenish i/p buffer 
  42. *+              get_len         determine # of contiguous bytes in record 
  43. *+  
  44. * 
  45. ******************************************************************************/ 
  46.  
  47. #include "x2x_amiga.h"
  48. #include "x2x_data.c"
  49.  
  50.  
  51. /*************************************************************************** 
  52.  
  53.  
  54.   Function :     rite_rec 
  55.  
  56.  
  57.   Purpose  :     Puts DLL record into buffer and writes to disc when  
  58.                  full , or when forced 
  59.  
  60.   Entry    : 
  61.  
  62.  
  63.   Returns  :   
  64.  
  65.  
  66. ****************************************************************************/ 
  67.  
  68.  
  69. int   rite_rec ( fptr , fmadr , len )  
  70.  
  71. int fptr ; 
  72. char *fmadr ; 
  73. int len ; 
  74.  
  75. { 
  76.  
  77.   while ( len-- ) 
  78.       { 
  79.          dlldbuf [odccon++] = *fmadr++ ;    /* copy to buffer */    
  80.          if ( odccon == OPBUFLEN )         /* if full write */ 
  81.            { 
  82.             if ( write( fptr , dlldbuf , OPBUFLEN) != OPBUFLEN ) 
  83.               {    
  84.                  fprintf (stderr,"(rite_rec) - write error" ); 
  85.                  perror("Disc write error: "); 
  86.                  exit(3); 
  87.               } 
  88.             odccon = 0 ;  
  89.       } 
  90.        } 
  91.  
  92. } 
  93.  
  94. /*************************************************************************** 
  95.  
  96.  
  97.   Function :     get_rtype      
  98.  
  99.  
  100.   Purpose  :     Determines type of DLL file 
  101.  
  102.   Entry    : 
  103.  
  104.  
  105.   Returns  :   with file type 
  106.  
  107.  
  108. ****************************************************************************/ 
  109.  
  110. int   get_rtype ( ) 
  111.  
  112. { 
  113.   int ch  ; 
  114.   int retval = 1 ; 
  115.    
  116.   ch = Ichar () ;              /* 1st chara assumed to define file type !*/ 
  117.   switch ( ch ) 
  118.     { 
  119.      case ':'  :                  /* INTEL */ 
  120.          break ; 
  121.   
  122.      case 'S'  :                  /* MOTOROLA */ 
  123.         ch = Ichar() -'0' ;       /* get type 1,2,3 */ 
  124.         switch (ch) 
  125.       { 
  126.       case 3 :  ++retval ; 
  127.       case 2 :  ++retval ; 
  128.       case 1 :  ++retval ; 
  129.               xiMaddr = retval + 1 ; 
  130.               break ; 
  131.       default : 
  132.             retval = 0 ; 
  133.       } 
  134.         break ; 
  135.  
  136.      case '/'  :                  /* TEKTRONIX */ 
  137.  
  138.        retval = 5 ; 
  139.        break ;         
  140.  
  141.      case '%'  :                  /* TEKTRONIX - extended  */ 
  142.  
  143.        retval = 6 ; 
  144.        break ;         
  145.  
  146.      case 'Q'  :                  /* QTAM  */ 
  147.  
  148.        retval = 7 ; 
  149.        break ;         
  150.  
  151.      default : 
  152.        retval = 0 ; 
  153.        break ;                   /* ?????????  */ 
  154.  
  155.      } 
  156.  
  157.    f_reset () ;      /* reset file ptrs */ 
  158.  
  159.    return ( retval -1 ) ; 
  160.  
  161. } 
  162.  
  163. /*************************************************************************** 
  164.  
  165.  
  166.   Function :       f_reset     
  167.  
  168.  
  169.   Purpose  :      resets pointers to DLL file- ensures read starts at 
  170.                   beginning 
  171.  
  172.   Entry    : 
  173.  
  174.  
  175.   Returns  :     TRUE -  
  176.  
  177.                  FALSE-  
  178.  
  179.  
  180. ****************************************************************************/ 
  181.  
  182.  
  183. int f_reset () 
  184.  
  185.  
  186. { 
  187.     boffs = 0 ; 
  188.     disclen = 0 ; 
  189.   
  190.   if (  lseek ( iffp , 0L  , L_SET ) == -1 )   /* reset file ptr */ 
  191.     { 
  192.         fprintf (stderr, "lseek fail\n" ) ; 
  193.         exit(1) ; 
  194.     } 
  195.  
  196. } 
  197.  
  198. /*************************************************************************** 
  199.  
  200.  
  201.   Function :     dll_Irec 
  202.  
  203.  
  204.   Purpose  :     builds an INTEL  DLL record 
  205.  
  206.   Entry    : 
  207.  
  208.  
  209.   Returns  :    # of charas in record 
  210.  
  211.  
  212.  
  213. ****************************************************************************/ 
  214.  
  215.  
  216. int  dll_Irec ( tipe , addr ,  len ) 
  217.  
  218. int tipe , len ; 
  219. long addr ; 
  220.  
  221. { 
  222. int count , j ; 
  223. uchar ch ; 
  224. int t2data ; 
  225.  
  226.  
  227.      t2data =  addr << 12  ;           /* convert to  seg offset   */ 
  228.      if ( tipe == 2 ) 
  229.         addr = 0 ; 
  230.  
  231.     /*----------- calc checksum --------------------------------*/ 
  232.  
  233.      Icsum = 0 ;  
  234.      Icsum += sum_get ( 'I' , &addr , 2 ) ;      /* addr  */ 
  235.      Icsum += sum_get ( 'I' , &tipe , 1 ) ;      /* type  */ 
  236.      Icsum += sum_get ( 'I' , &len , 1 ) ;       /*  len   */ 
  237.  
  238.    /* -----------now build buffer ------------------------*/ 
  239.  
  240.    opbuf [0] = ':'                   ; 
  241.     
  242.    chcon = convc2 ( len ) ; 
  243.    opbuf [IRLEN] = chcon >> 8 ; 
  244.    opbuf [IRLEN+1] = chcon & 0xFF ; 
  245.  
  246.    chcon = convc2 ( tipe ) ;                   /* rec type - data= 0 */ 
  247.    opbuf [IRTYPE] = chcon >> 8 ; 
  248.    opbuf [IRTYPE+1] = chcon & 0xFF ; 
  249.  
  250.    chcon = convc2 ( (int)(addr >> 8) ) ;           /* load addr - hi */ 
  251.    opbuf [IRADDR] = chcon >> 8 ; 
  252.    opbuf [IRADDR+1] = chcon & 0xFF ; 
  253.  
  254.    chcon = convc2 ( (int)addr ) ;           /* load addr - lo */ 
  255.    opbuf [IRADDR+2] = chcon >> 8 ; 
  256.    opbuf [IRADDR+3] = chcon & 0xFF ; 
  257.  
  258.  
  259.    for ( count = 0 , j = 0; count < len ; ++ count, j += 2 )   /* now the 
  260.                                                                      data */ 
  261.      { 
  262.        if ( tipe == 2 )                        /* fudge for USBA record */ 
  263.           { 
  264.             ch = t2data >> 8 ; 
  265.             t2data <<= 8 ; 
  266.           } 
  267.        else   
  268.            ch = xgetc ( )  ;                  /* get data chara */ 
  269.         
  270.        Icsum += sum_get ( 'I' , &ch , 1 ) ;       /* accum c/sum   */ 
  271.        chcon = convc2 ( ch ) ;        
  272.    
  273.        opbuf [IRDATA +   j ] = chcon >> 8 ; 
  274.        opbuf [IRDATA+1 + j ] = chcon & 0xFF ; 
  275.      } 
  276.     
  277.    Icsum =  - Icsum ; 
  278.    chcon = convc2 ( Icsum ) ;           /* checksum  */ 
  279.    opbuf [IRDATA +    j ] = chcon >> 8 ; 
  280.    opbuf [IRDATA + 1 +j ] = chcon & 0xFF ; 
  281.  
  282.    return ( IRDATA + 2 + j ) ;     /* return length */ 
  283. } 
  284.  
  285. /*************************************************************************** 
  286.  
  287.  
  288.   Function :     dll_Mrec 
  289.  
  290.  
  291.   Purpose  :     builds a MOTOROLA 68000  DLL record 
  292.  
  293.   Entry    : 
  294.  
  295.  
  296.   Returns  :     TRUE -  
  297.  
  298.                  FALSE-  
  299.  
  300.  
  301. ****************************************************************************/ 
  302.  
  303.  
  304.  
  305. int  dll_Mrec ( tipe , addr ,  len ) 
  306.  
  307. int tipe  , len ; 
  308. long addr ; 
  309.  
  310. { 
  311.  
  312. int count , j ; 
  313. uchar ch ; 
  314. static int size ; 
  315. int offs ; 
  316.  
  317.  
  318.     /*------------- abort if S1 and addr > K64K ----------------------------*/ 
  319.  
  320.     if ( (xoMaddr == 2) && ( (addr+len) > K64K ) ) 
  321.       { 
  322.          fprintf ( stderr ,  
  323.               "\007\nAbort: address overflow! ( %ld )\n" ,addr+len ); 
  324.          exit (1) ; 
  325.       } 
  326.    offs = 2 * ( xoMaddr - 2) ;   /* addr offset start */ 
  327.  
  328.    size = len + 1 + offs/2 + 2 ; 
  329.  
  330.  
  331.    /*----------- calc  checksum --------------------------------*/ 
  332.  
  333.     Icsum = 0 ;  
  334.     Icsum += sum_get ( 'I' , &addr , 4 ) ;      /* addr  */ 
  335.     Icsum += sum_get ( 'I' , &size , 1 ) ;      /*  len   */ 
  336.  
  337.    /* -----------now build buffer ------------------------*/ 
  338.  
  339.    opbuf [0] = 'S'                   ; 
  340.    opbuf [1] =  tipe                ; 
  341.     
  342.  
  343.    chcon = convc2 ( size ) ; 
  344.    opbuf [MRLEN]   = chcon >> 8 ; 
  345.    opbuf [MRLEN+1] = chcon & 0xFF ; 
  346.  
  347.    /*----------------- now the variable address length ------------------*/ 
  348.  
  349.    for ( count=0 , j = 2*xoMaddr-2 ; count < (xoMaddr) ; ++count , j -= 2  ) 
  350.      { 
  351.        ch = addr ; 
  352.        addr >>= 8 ; 
  353.        chcon = convc2 ( ch ) ;                /* byte -> 2 ASCII hex */ 
  354.        opbuf [MRADDR+ j + 0] = chcon >> 8 ; 
  355.        opbuf [MRADDR+ j + 1] = chcon & 0xFF ; 
  356.      }  
  357.  
  358.   /*---------------------- now the data ----------------------------------*/ 
  359.    for ( count = 0 , j = 0; count < len ; ++ count, j += 2 ) 
  360.                                                       /* now the data */ 
  361.      { 
  362.        ch = xgetc ( ) ;       
  363.        Icsum += sum_get ( 'I' , &ch , 1 ) ;       /* accum c/sum   */ 
  364.        chcon = convc2 ( ch ) ;        
  365.  
  366.        opbuf [MRDATA + offs +  j ] = chcon >> 8 ; 
  367.        opbuf [MRDATA+1 + offs +j ] = chcon & 0xFF ; 
  368.      } 
  369.     
  370.    Icsum = ~Icsum ;                 /* 1s complement */ 
  371.    chcon = convc2 ( Icsum ) ;           /* checksum  */ 
  372.    opbuf [MRDATA + offs +   j ] = chcon >> 8 ; 
  373.    opbuf [MRDATA + offs + 1 +j ] = chcon & 0xFF ; 
  374.  
  375.    return ( MRDATA + offs + 2 + j ) ;     /* return length */ 
  376.  
  377. } 
  378.  
  379. /*************************************************************************** 
  380.  
  381.  
  382.   Function :     dll_Trec 
  383.  
  384.  
  385.   Purpose  :     builds a TEKTRONIX DLL record 
  386.  
  387.   Entry    : 
  388.  
  389.  
  390.   Returns  :     TRUE -  
  391.  
  392.                  FALSE-  
  393.  
  394.  
  395. ****************************************************************************/ 
  396.  
  397.  
  398. int  dll_Trec ( tipe , addr ,  len ) 
  399.  
  400. int tipe , len ; 
  401. long addr ; 
  402.  
  403. { 
  404. int count , j ; 
  405. uchar ch ; 
  406.  
  407.     /*------------- abort if addr > K64K ----------------------------*/ 
  408.  
  409.     if ( (addr+len) > K64K ) 
  410.       { 
  411.          fprintf ( stderr ,  
  412.               "\007\nAbort: address overflow! ( %ld )\n" ,addr+len ); 
  413.          exit (1) ; 
  414.       } 
  415.  
  416.     /*----------- calc load checksum --------------------------------*/ 
  417.  
  418.      Tcsum = 0 ;  
  419.      Tcsum += sum_get ( 'T' , &addr , 2 ) ;      /* addr  */ 
  420.      Tcsum += sum_get ( 'T' , &len , 1 ) ;       /*  len   */ 
  421.  
  422.      chcon = convc2 ( Tcsum ) ;           /* put checksum in record   */ 
  423.      opbuf [ TRSUM  ]    = chcon >> 8 ; 
  424.      opbuf [ TRSUM + 1 ] = chcon & 0xFF ; 
  425.  
  426.  
  427.    /* -----------now build buffer ------------------------*/ 
  428.  
  429.    opbuf [0] = '/'                   ; 
  430.     
  431.  
  432.    chcon = convc2 ( len ) ; 
  433.    opbuf [TRLEN] = chcon >> 8 ; 
  434.    opbuf [TRLEN+1] = chcon & 0xFF ; 
  435.  
  436.    chcon = convc2 ( (int)(addr >> 8) ) ;           /* load addr - hi */ 
  437.    opbuf [TRADDR] = chcon >> 8 ; 
  438.    opbuf [TRADDR+1] = chcon & 0xFF ; 
  439.  
  440.    chcon = convc2 ( (int) addr ) ;                /* load addr - lo */ 
  441.    opbuf [TRADDR+2] = chcon >> 8 ; 
  442.    opbuf [TRADDR+3] = chcon & 0xFF ; 
  443.  
  444.  
  445.  
  446.    /* -----------now build buffer ------------------------*/ 
  447.  
  448.    Tcsum = 0 ;  
  449.  
  450.    for ( count = 0 , j = 0; count < len ; ++ count, j += 2 ) 
  451.                                                       /* now the data */ 
  452.      {  
  453.        ch = xgetc ( ) ;       
  454.        Tcsum += sum_get ( 'T' , &ch , 1 ) ;       /* accum c/sum   */ 
  455.        chcon = convc2 ( ch ) ; 
  456.  
  457.        opbuf [TRDATA +   j ] = chcon >> 8 ; 
  458.        opbuf [TRDATA+1 + j ] = chcon & 0xFF ; 
  459.      } 
  460.  
  461.   if ( len )                            /* last record , skip  (small fudge)*/ 
  462.    {    
  463.      chcon = convc2 ( Tcsum ) ;           /* checksum  */ 
  464.      opbuf [TRDATA +    j ] = chcon >> 8 ; 
  465.       opbuf [TRDATA + 1 +j ] = chcon & 0xFF ; 
  466.    } 
  467.   else 
  468.      j -= 2 ; 
  469.    return ( TRDATA + 2 + j ) ;     /* return length */ 
  470.  
  471. } 
  472.  
  473. /*************************************************************************** 
  474.  
  475.  
  476.   Function :     dll_Txrec 
  477.  
  478.  
  479.   Purpose  :     builds a TEKTRONIX - extended DLL record 
  480.  
  481.   Entry    : 
  482.  
  483.  
  484.   Returns  :     TRUE -  
  485.  
  486.                  FALSE-  
  487.  
  488.  
  489. ****************************************************************************/ 
  490.  
  491.  
  492. int  dll_Txrec ( tipe , addr ,  len ) 
  493.  
  494. int tipe , len ; 
  495. long addr ; 
  496.  
  497. { 
  498. int count , j , k; 
  499. uchar ch ; 
  500.  
  501. int nochars = 2*len +14 ;        /* chara count in record */ 
  502.  
  503.    opbuf [0] = '%'  ;            /* record header chara   */ 
  504.  
  505.    opbuf [ nochars + 2 ] = 0 ; 
  506.  
  507.     /*----------- record length (#of charas) -------------------------------*/ 
  508.     /* ( make addr field max of 8 charas ( 32 bit address )                 */ 
  509.  
  510.      chcon = convc2 ( nochars ) ;           /* put checksum in record   */ 
  511.      opbuf [ TRXLEN + 0 ]    = chcon >> 8 ; 
  512.      opbuf [ TRXLEN + 1 ]    = chcon & 0xFF ; 
  513.  
  514.     /*-------------- now the record type ------------------------------------*/ 
  515.  
  516.      opbuf [ TRXTYPE  ]    = tipe ; 
  517.      
  518.     /*--------------- now a fake csum ---------------------------------------*/ 
  519.  
  520.      opbuf [ TRXSUM ]    = '0' ; 
  521.      opbuf [ TRXSUM +1 ] = '0' ; 
  522.  
  523.     /*-------------- now the addr length ( 8 for now ) ----------------------*/ 
  524.  
  525.    opbuf [ TRXADDR ] = '8' ;                  /* # of charas   */ 
  526.  
  527.    count = addr >> 24 ;                        /* top 8 bits */ 
  528.    chcon = convc2 ( count ) ; 
  529.    opbuf [TRXADDR + 1 ]   = chcon >> 8 ; 
  530.    opbuf [TRXADDR + 2 ]   = chcon & 0xFF ; 
  531.  
  532.    count = addr >> 16 ;                       /*  next 8 bits */ 
  533.    chcon = convc2 ( count ) ; 
  534.    opbuf [TRXADDR + 3 ]   = chcon >> 8 ; 
  535.    opbuf [TRXADDR + 4 ]   = chcon & 0xFF ; 
  536.  
  537.    count = addr >> 8 ;                       /* next 8 bits */ 
  538.    chcon = convc2 ( count ) ; 
  539.    opbuf [TRXADDR + 5 ]   = chcon >> 8 ; 
  540.    opbuf [TRXADDR + 6 ]   = chcon & 0xFF ; 
  541.  
  542.    count = addr ;                            /* low 8 bits */ 
  543.    chcon = convc2 ( count ) ; 
  544.    opbuf [TRXADDR + 7 ]   = chcon >> 8 ; 
  545.    opbuf [TRXADDR + 8 ]   = chcon & 0xFF ; 
  546.  
  547.   /*-------------- now put data in buffer -----------------------------*/ 
  548.  
  549.    for ( count = 0 , j = 0; count < len ; ++ count, j += 2 ) 
  550.                                                       /* now the data */ 
  551.      {  
  552.        ch = xgetc ( ) ;       
  553.        chcon = convc2 ( ch ) ; 
  554.  
  555.        opbuf [TRXDATA +   j ] = chcon >> 8 ; 
  556.        opbuf [TRXDATA+1 + j ] = chcon & 0xFF ; 
  557.      } 
  558.  
  559.   /*----------------- now build and store checksum -----------------------*/ 
  560.  
  561.  
  562.    for ( count = 0 , k = 0 ; count < nochars ; ++count ) 
  563.      { 
  564.        if ( (j = get_hex (opbuf [count + 1])) == -1) 
  565.        { 
  566.              fprintf ( stderr , "dll_TXrec bad hex chara\n" ) ; 
  567.              fprintf ( stderr , opbuf ) ; 
  568.              exit ( 1 ) ; 
  569.            } 
  570.        k += j ;         /* accum checksum */ 
  571.      } 
  572.  
  573.        chcon = convc2 ( k ) ;              /* put in buffer  */ 
  574.   
  575.        opbuf [TRXSUM     ] = chcon >> 8 ; 
  576.        opbuf [TRXSUM + 1 ] = chcon & 0xFF ; 
  577.  
  578.  
  579.    return ( nochars + 1 ) ;     /* return length */ 
  580.  
  581. } 
  582.  
  583. /*************************************************************************** 
  584.  
  585.  
  586.   Function :     dll_Qrec 
  587.  
  588.  
  589.   Purpose  :     gen  a QTAM record 
  590.  
  591.   Entry    : 
  592.  
  593.   Returns  :     TRUE -  
  594.  
  595.                  FALSE- 
  596.  
  597.  
  598. ****************************************************************************/ 
  599.  
  600.  
  601. int  dll_Qrec ( tipe , addr ,  len ) 
  602.  
  603. int tipe , len ; 
  604. long addr ; 
  605.  
  606.  
  607. { 
  608. int count , j ; 
  609. uchar ch ; 
  610.  
  611.  
  612.    /* -----------now build buffer ------------------------*/ 
  613.  
  614.    opbuf [0] = 'Q'   ; 
  615.    opbuf [1] =  len  ; 
  616.  
  617.    opbuf [2] = addr >> 16 ; 
  618.    opbuf [3] = addr >> 8  ; 
  619.    opbuf [4] = addr  ; 
  620.  
  621.    for ( count = 0 ; count < len ; ++ count)  /* put data in buffer */  
  622.      { 
  623.        ch = xgetc ( )  ;        
  624.        opbuf [ 5 + count ] = ch ; 
  625.      } 
  626.  
  627.    for ( count = 0 , j = 0 ; count < (len + 4) ; ++ count )   /*  calc c/sum */ 
  628.       j += opbuf [ 1 + count] ; 
  629.  
  630.    opbuf [ 1 + count ] = - j  ;        /* put c/sum in buffer */ 
  631.     
  632.    return ( len + 6 ) ;                    /* return length */ 
  633.  
  634.  
  635. } 
  636.  
  637. /*************************************************************************** 
  638.  
  639.  
  640.   Function :       sum_get      
  641.  
  642.  
  643.   Purpose  :     Accumulates a checksum on a string 
  644.  
  645.   Entry    :     "I" / "T"  
  646.                  ptr to char string 
  647.                  length  
  648.  
  649.   Returns  :     uchar : checksum 
  650.  
  651.  
  652.  
  653. ****************************************************************************/ 
  654.  
  655.  
  656. int  sum_get  ( type , ptr , len ) 
  657.  
  658.  
  659. char *ptr ; 
  660. int type , len ; 
  661.  
  662. { 
  663. int csum  ; 
  664. int count ; 
  665.  
  666. switch ( type ) 
  667.   { 
  668.   case 'I' : 
  669.         
  670.        for (  count = 0 , csum = 0 ; count < len ; ++count , ++ptr ) 
  671.             csum +=  *ptr & 0xFF  ;               
  672.  
  673.        break ; 
  674.  
  675.      case 'T' : 
  676.         
  677.        for (  count = 0 , csum = 0 ; count < len ; ++count , ++ptr) 
  678.             csum +=  (*ptr & 0xF) + ((*ptr >> 4) & 0xF ) ;               
  679.  
  680.        break ; 
  681.  
  682.      } 
  683.  
  684.    return ( csum & 0xFF ) ; 
  685. } 
  686.  
  687. /*************************************************************************** 
  688.  
  689.  
  690.   Function :       xgetc      
  691.  
  692.  
  693.   Purpose  :       gets next chara from input buffer 
  694.  
  695.   Entry    : 
  696.  
  697.  
  698.   Returns  :     chara , or -1 ( empty ) 
  699.                  *ptr = addr 
  700.  
  701. ***************************************************************************/ 
  702.  
  703.  
  704. int xgetc (  ) 
  705.  
  706.  
  707. { 
  708. int ch , temp  ; 
  709. char *ptr = mallocptr ; 
  710.  
  711.     if ( !xccnt ) 
  712.       return -1 ;           /* empty */ 
  713.  
  714.     ch = xipbuf [xnrp].bite ;    /* get chara */     
  715.  
  716.     /* if mode 3 ( checksum gen ) , put byte in array */ 
  717.  
  718.     if ( xmode == 3 ) 
  719.       { 
  720.         if ( (temp = xipbuf[xnrp].addr) > 0xFFFF ) 
  721.            { 
  722.              fprintf ( stderr , "(xgetc) : addr > K64K !\n" ) ; 
  723.              exit (1) ; 
  724.            }  
  725.         ptr += temp ;         
  726.         *ptr = ch ;                  /* plant byte in array */     
  727.       } 
  728.  
  729.     --xccnt ; 
  730.     if ( ++xnrp == IPLEN ) 
  731.        xnrp = 0 ; 
  732.  
  733.     return ( ch & 0xFF ) ; 
  734. } 
  735.  
  736. /*************************************************************************** 
  737.  
  738.  
  739.   Function :       xputc      
  740.  
  741.  
  742.   Purpose  :       loads an addr/ data chara pair from DLL record to xipbuf 
  743.  
  744.  
  745.   Entry    : 
  746.  
  747.  
  748.   Returns  :     TRUE -  buffer not full 
  749.  
  750.                  FALSE-  buffer full 
  751.  
  752. ***************************************************************************/ 
  753.  
  754.  
  755.  
  756. int xputc ( addr , bite )  
  757.  
  758.  
  759. long addr ; 
  760. uchar bite ; 
  761.  
  762. {     
  763.       if ( csum > 255 ) 
  764.            csum = (++csum) & 0xFF ;    /* wrap prev carry  */ 
  765.   
  766.       csum +=  bite ;                /* accum checksum */ 
  767.  
  768.      xipbuf [xnwp].addr = addr ; 
  769.      xipbuf [xnwp++].bite = bite ; 
  770.  
  771.      if ( xnwp == IPLEN ) 
  772.        xnwp = 0 ; 
  773.  
  774.      if ( ++xccnt == IPLEN )       /* full check */ 
  775.         return ( FALSE ) ; 
  776.      else 
  777.         return ( TRUE ) ;     
  778. } 
  779.  
  780. /*************************************************************************** 
  781.  
  782.  
  783.   Function :      fill_ipbuf      
  784.  
  785.  
  786.   Purpose  :      fills up xipbuf with addr/data pairs made from DLL 
  787.                   file records 
  788.  
  789.   Entry    : 
  790.  
  791.  
  792.   Returns  :     TRUE - ip file not empty  
  793.  
  794.                  FALSE- ip fill now empty 
  795.  
  796. ***************************************************************************/ 
  797.  
  798.  
  799. int fill_ipbuf () 
  800.  
  801. { 
  802.  
  803.  while ( (xccnt < (IPLEN-300))  && xeof   ) 
  804.                    /* read DLL records until EOF or enough for o/p */ 
  805.    { 
  806.      switch ( ipftype ) 
  807.      { 
  808.        case 0 : 
  809.  
  810.          xeof = get_Irec () ;       /* get INTEL record -- deASCIIed */ 
  811.          break ; 
  812.   
  813.        case 1 :               /* MOTOROLA  */ 
  814.        case 2 : 
  815.        case 3 :   
  816.  
  817.           xeof =  get_Mrec()  ; 
  818.             break ; 
  819.  
  820.        case 4 :                   /* TEKTRONIX  */ 
  821.  
  822.           xeof = get_Trec () ; 
  823.           break ; 
  824.  
  825.        case 5 :                   /* TEKTRONIX - extended  */ 
  826.  
  827.           xeof = get_trec () ; 
  828.           break ; 
  829.  
  830.        case 6 :                   /* QTAM  */ 
  831.            
  832.           xeof = get_Qrec () ; 
  833.           break ; 
  834.  
  835.        }  ; 
  836.    } 
  837. } 
  838.  
  839. /*************************************************************************** 
  840.  
  841.  
  842.   Function :      get_len  
  843.  
  844.  
  845.   Purpose  :      scans i/p data buffer to see how many contiguous  
  846.                   bytes there are ( up to reclen ) 
  847.                   - does not allow overflow past K64K boundary if dest. 
  848.                     file is INTEL ( to allow type 2 tec gen. ) 
  849.   
  850.   Entry    : 
  851.  
  852.  
  853.   Returns  :      # of bytes 
  854.                   *ptr = addr field of start byte 
  855.  
  856. ***************************************************************************/ 
  857.  
  858. int  get_len ( aptr )  
  859.  
  860. long *aptr ; 
  861.  
  862. { 
  863. int count = 0 ; 
  864. long addr ; 
  865. int ptr ; 
  866.  
  867.  
  868.   ptr = xnrp ;                         /* scan from read ptr */ 
  869.        
  870.   addr = xipbuf [ptr].addr ; 
  871.   *aptr = addr ;                      /* hold start addr for external use   */ 
  872.   ousban= addr >> 16 ;            /* for INTEL , hold K64 seg # */  
  873.  
  874.   if ( !xccnt  )                      /* check odd conditions */ 
  875.      { 
  876.        *aptr = 0 ; 
  877.        return ( xccnt ) ; 
  878.      } 
  879.    else if ( xccnt == 1 ) 
  880.        return ( xccnt ) ; 
  881.  
  882.  
  883.   while ( count++ != xccnt )          /* read up to what's in buffer */ 
  884.     { 
  885.  
  886.       if ( ptr == IPLEN ) 
  887.          ptr = 0 ;                          /* wrap buffer ptr */ 
  888.  
  889.       if ( xipbuf [++ptr].addr != ++addr )  /* contiguous ? */ 
  890.      break ; 
  891.  
  892.      if ( count == reclen )             /* ( up to selected data length ) */ 
  893.          break ;  
  894.     
  895.      if ( !opftype ) 
  896.       { 
  897.         if (ousban != (addr >> 16) )  /* if INTEL check for K64 overflow */ 
  898.          break ;  
  899.       } 
  900.  
  901.    } 
  902.  
  903.   return ( count ) ; 
  904.  
  905. } 
  906.