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 / MemFrag / memfrag.c < prev    next >
C/C++ Source or Header  |  1990-04-16  |  5KB  |  231 lines
  1. /************************************************************************ 
  2. *                                                                       * 
  3. *                                                                       * 
  4. *                      Filename:        MemFrag.c                       *      
  5. *                       Version:        0.0                             * 
  6. *                       Author :        Gary Duncan                     * 
  7. *                                                                       * 
  8. *                                frags , heavily modified               *
  9. *-----------------------------------------------------------------------* 
  10. *
  11. * Function:
  12. * ~~~~~~~~~
  13. *
  14. * Invocation:
  15. * ~~~~~~~~~~
  16. *
  17. * 
  18. * Modification record: 
  19. *~~~~~~~~~~~~~~~~~~~~
  20. * 
  21. * Date         By whom             Change 
  22. * ----         -------             ------ 
  23. * 
  24. * 17 Jan 89    GMD          Original ; frags.c heavily modified
  25. *                                            ( from FF69)
  26. *
  27. * 01 Jul 89    "          Date added
  28. *
  29. * Contents:    Function    Description
  30. * ~~~~~~~~     ~~~~~~~~    ~~~~~~~~~~~
  31. *+  
  32. *+  _main
  33. *+  print_count
  34. *+  ascify
  35. *+  MemCleanup
  36. *+ 
  37. *
  38. *
  39. *******************************************************************************/
  40.  
  41.  
  42. #include "gd_functions.h"
  43.  
  44.  
  45. #include <exec/types.h>
  46. #include <exec/exec.h>
  47. #include <exec/execbase.h>
  48.  
  49.  
  50. extern char *MakeDate[] ;
  51.  
  52. #if 0
  53. char redpen[]  =  "\033[33m";      /* red pen     */
  54. char witepen[] =  "\033[0m";      /* white  pen  */
  55. #endif
  56.  
  57. char ghdr[] = "\n\033[33m\
  58.                    Chip:Fast \n\
  59.                    ~~~~ ~~~~\033[0m\n" ;
  60.  
  61. char buffer[100] = "12345678 : 123     123 :123         \n"  ;
  62.  
  63. struct gazza { int   kk ;
  64.                 BYTE chip ;
  65.                 BYTE fast ; }  Chunk_Count[25] ;
  66.  
  67.  
  68.  
  69. _main() 
  70. {
  71.  
  72. long aggrF = 0 ;        /* GMD    */
  73. long aggrC = 0 ;        /* GMD    */
  74. char flag ;
  75. struct MemHeader *hdr ;
  76. struct MemChunk *chunk ;
  77. long    size ;
  78. extern struct ExecBase *SysBase ;
  79. short j ;
  80.  
  81.     {
  82.      char vvv[100] ;
  83.      sprintf ( vvv, "\nMemFrag: (%s) \n", 
  84.                 MakeDate[0] ) ;
  85.      Write(Output(), vvv, (long)strlen(vvv) ) ;    /* GMD */    
  86.     }
  87.     Forbid() ;
  88.  
  89.     hdr = (struct MemHeader *) SysBase -> MemList . lh_Head ;
  90.  
  91.     while (hdr ->mh_Node.ln_Succ) 
  92.          {
  93.         flag = *(char *)(hdr->mh_Node.ln_Name) ; /* 'F'ast or 'C'hip */
  94.  
  95.         for (chunk = hdr -> mh_First; chunk; chunk = chunk -> mc_Next)
  96.                   {
  97.             size = chunk -> mc_Bytes ;
  98.             for (j = 0; size; j += 1) 
  99.                 size >>= 1 ;
  100.  
  101.             Chunk_Count[j].kk += 1 ;
  102.             if ( flag == 'e' )    /* count Fast or Chip chunks */
  103.               ++Chunk_Count[j].fast ;
  104.             else
  105.               ++Chunk_Count[j].chip ;    /* GMD    */
  106.  
  107.         }
  108.  
  109.         hdr = (struct MemHeader *) hdr -> mh_Node . ln_Succ ;
  110.  
  111.       } /*end-while */
  112.  
  113.     Permit() ;
  114.  
  115.     Write(Output(), ghdr, (long)strlen(ghdr) ) ;    /* GMD */    
  116.  
  117.     for (j = 1; j <= 23; ++j )
  118.           {
  119.         if (Chunk_Count[j].kk)
  120.             print_count( j ) ;    /* print # of blocks    */
  121.           }
  122.  
  123.         exit ( 0 ) ;            /* GMD         */
  124. }
  125.  
  126. /*************************************************************************** 
  127.  
  128.  
  129.   Name :          print_count 
  130.  
  131.   Purpose:           Given index into array , prints line
  132.  
  133.  
  134.   Entry    :           
  135.  
  136.  
  137.   Returns  :           
  138.                                
  139.  
  140.  
  141. ****************************************************************************/ 
  142.  
  143.  
  144.  
  145. print_count ( j )
  146.  
  147. int j ;
  148. {
  149.  
  150.  
  151.     ascify ( (1L << (j-1)) ,             8 ,   &buffer[0]  ) ;
  152.     ascify ( (long)Chunk_Count[j].kk ,   3 ,   &buffer[11] ) ;
  153.     ascify ( (long)Chunk_Count[j].chip , 3 ,   &buffer[19] ) ;
  154.     ascify ( (long)Chunk_Count[j].fast , 3 ,   &buffer[24] ) ;
  155.  
  156.     Write(Output(), buffer,(long)strlen(buffer) ) ;
  157. }
  158.  
  159. /*************************************************************************** 
  160.  
  161.  
  162.   Name :          ascify
  163.  
  164.   Purpose:      Converts a long number  to an ASCII string
  165.  
  166.  
  167.   Entry    :    (long)numb = number
  168.              (int) digs = # of digits to print ( field-width )
  169.                 (char *) where = ptr to where sting is to be copied
  170.  
  171.  
  172.   Returns  :           
  173.                                
  174.  
  175.  
  176. ****************************************************************************/ 
  177.  
  178.  
  179. ascify ( numb , digs , where )
  180.  
  181. long numb ;
  182. int digs ;
  183. char *where ;
  184.  
  185. {
  186. int j , k ;
  187. char *ptr = where ;
  188.  
  189.     for ( j=0 , where += digs-1 ; j < digs ; ++j  )
  190.        {
  191.          k = numb%10 ;
  192.          numb /= 10  ; 
  193.          *where-- = k + '0'  ;
  194.  
  195.        }
  196.     while ( *ptr == '0' )
  197.           *ptr++ = ' ' ;
  198.     
  199.     
  200. }
  201. /*************************************************************************** 
  202.  
  203.  
  204.   Name :          MemCleanup
  205.  
  206.   Purpose:
  207.  
  208.  *
  209.  * To cut down on memory useage, we provide a stub for a routine pulled
  210.  * in by the default startup code in _main. This code cleans up
  211.  * dynamically allocated memory, which we don't need. So we flush the code
  212.  * here. By making this a smallcode, smalldata program, turning off stack 
  213.  * checking (nothing recursive, and only three routines, so who needs it?),
  214.  * and adding this, I've reduced the size of MemFrag to 1644 bytes. Since the
  215.  * original MemFrag is 1964 bytes long, I'm happy. Just out of curiosity, I'd
  216.  * like to know how large a binary Manx 3.4 produces.
  217.  
  218.  
  219.   Entry    :           
  220.  
  221.  
  222.   Returns  :           
  223.                                
  224.  
  225.  
  226. ****************************************************************************/ 
  227.  
  228.  
  229. MemCleanup() {}
  230.  
  231.