home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / musik / MIDIFP21 / SOURCES / MY_LIB / ACS_PLUS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-24  |  10.7 KB  |  465 lines
  1. /**************************************************************
  2. *
  3. *                ACS_PLUS.C
  4. *
  5. **************************************************************/
  6.  
  7. #include <stdio.h> 
  8. #include <string.h>
  9. #include <stdlib.h> /* because of ltoa(), ... */
  10. #include <tos.h>    /* because of Fforce(), ... */
  11. #include <acs.h>
  12. #include <acs_plus.pif>
  13. #include "acs_plus.h"
  14. #include "acs_plus.ah" 
  15. #include <messages.pif>
  16.  
  17.  
  18. /**************************************************************
  19. *
  20. *                memory management
  21. *
  22. **************************************************************/
  23.  
  24. /*** global variable, used to point to symptom data for debug_mem ***/ 
  25.  
  26. char *memory_symptom ;
  27.  
  28.  
  29. /*** global variable for recording memory management operations ***/
  30.  
  31. #define MAX_OPERATIONS 64
  32.  
  33. struct OPERATION
  34. {
  35.     enum {Memory, String, Object, Window} type ;
  36.     long ptr ;
  37.     long size ;
  38. } ;
  39.  
  40. static struct OPERATION operation[MAX_OPERATIONS] ;
  41. static char i = 0 ;
  42.  
  43. /*** own memory management ***/
  44.  
  45. #define BLOCK_SIZE 0x10000L  /* size to be allocated in 1 one block */
  46. #define MIN_BYTES  4         /* minimum length of last section */
  47.  
  48. struct BH /* block header for blocks of allocated memory */
  49. { /* sizeof(BH) must be a multiple of 4 */
  50.     long      size ;   /* total size of block */
  51.     long      free ;   /* net free size */
  52.     struct BH *next ;  /* pointer to next list element */
  53.     long      cs ;     /* checksum for this header */
  54. } 
  55. *bh_first = NULL ; /* pointer to first list element */ ;
  56.  
  57. struct SH /* section header for memory sections inside blocks */
  58. { /* sizeof(SH) must be a multiple of 4 */
  59.     long size ;   /* net size of following section */
  60.     int  FREE ;   /* TRUE = next section is free */
  61.     int  cs ;     /* checksum for this header */
  62. } ;
  63.  
  64.  
  65.  
  66. long block_cs(struct BH *bh)
  67. { return ~( bh->size + bh->free + (long)(bh->next) ) ; }
  68.  
  69. int section_cs(struct SH *sh)
  70. { return ~( (int)sh->size + sh->FREE ) ; }
  71.  
  72.  
  73. void *new_block(long blocksize, long size) 
  74. {
  75. struct BH *bh ;
  76. struct SH *sh, *sh_next ;
  77.  
  78.     /*** allocate memory ***/
  79.     bh = (struct BH *)Ax_malloc(blocksize) ;
  80.     if (bh == NULL) { alert_str(OUT_OF_MEMORY, "") ; return NULL ; }
  81.     
  82.     /*** init headers ***/
  83.     bh->next = bh_first ; bh_first = bh ; /* chain in */
  84.     bh->size = blocksize ;
  85.     sh = (struct SH *)(bh + 1) ;
  86.     sh->FREE = FALSE ;
  87.     
  88.     /*** init 1 header for free section ***/
  89.     sh->size = blocksize - sizeof(*bh) - sizeof(*sh) ;
  90.     bh->free = 0 ;
  91.     if (size + sizeof(*bh) + (sizeof(*sh)<<1) + MIN_BYTES <= blocksize)
  92.     {
  93.         /*** init 1 more header for free section ***/
  94.         sh->size = size ;
  95.         sh_next = (struct SH *)((long)(sh + 1) + sh->size) ;
  96.         sh_next->FREE = TRUE ;
  97.         sh_next->size = blocksize - size - sizeof(*bh) - (sizeof(*sh)<<1) ;
  98.         sh_next->cs = section_cs(sh_next) ;
  99.         bh->free = sh_next->size ;
  100.     }
  101.     sh->cs = section_cs(sh) ;
  102.     bh->cs = block_cs(bh) ;
  103.     
  104.     /*** return pointer to user section ***/
  105.     return (void *)(sh + 1) ;
  106. }
  107.  
  108.  
  109. void *Allocate(long size)
  110. { 
  111. struct SH *sh, *sh_new ;
  112. struct BH *bh ;
  113. char address[30] ;
  114.  
  115.     /*** round up size to a multiple of 4 ***/
  116.     size = (size + 3) & 0xfffffffcL ;
  117.  
  118.     /*** if requested size is big enough, user gets an extra block ***/
  119.     if (size > BLOCK_SIZE / 2) return new_block(size + sizeof(*bh) + sizeof(*sh), size) ;
  120.  
  121.     /*** else: search for a free section inside allocated blocks ***/
  122.     bh = bh_first ;
  123.     while (bh != NULL) 
  124.     {
  125.         if (bh->cs != block_cs(bh)) 
  126.         { 
  127.             alert_str(BLOCK_DESTROYED, ltoa((long)bh, address, 16)) ; 
  128.             return NULL ; 
  129.         }
  130.         if (bh->free >= size)
  131.         {
  132.             /*** search this block for a free section ***/
  133.             sh = (struct SH *)(bh + 1) ;
  134.             while ( (long)sh < (long)bh + bh->size )  
  135.             {
  136.                 if (sh->cs != section_cs(sh))
  137.                 {
  138.                     alert_str(SECTION_DESTROYED, ltoa((long)sh, address, 16)) ;
  139.                     return NULL ;
  140.                 }
  141.                 if (sh->FREE) 
  142.                 {
  143.                     if (sh->size >= size)
  144.                     {
  145.                         /*** allocate section (partly) ***/
  146.                         if (sh->size >= size + sizeof(*sh) + MIN_BYTES )
  147.                         {
  148.                             /*** create new section header ***/
  149.                             sh_new = (struct SH *)((long)(sh + 1) + size) ;
  150.                             sh_new->FREE = TRUE ;
  151.                             sh_new->size = sh->size - size - sizeof(*sh_new) ;
  152.                             sh_new->cs = section_cs(sh_new) ;
  153.     
  154.                             /*** update block header ***/
  155.                             bh->free -= sizeof(*sh_new) ;
  156.         
  157.                             /*** update section header ***/
  158.                             sh->size = size ;
  159.                         }
  160.                         sh->FREE = FALSE ;
  161.                         sh->cs = section_cs(sh) ;
  162.                         bh->free -= sh->size ;
  163.                         bh->cs = block_cs(bh) ;
  164.                         return (void *)(sh + 1) ;
  165.                     }
  166.                 } /* if section is free */
  167.                 sh = (struct SH *)( (long)(sh + 1) + sh->size ) ;
  168.             }
  169.         } /* if enough free memory in this block */
  170.         bh = bh->next ;
  171.     } 
  172.     /*** nothing suitable found up to now -> allocate new block ***/
  173.     return new_block(BLOCK_SIZE, size) ;
  174. }
  175.  
  176.  
  177. void Free(void *ptr)
  178. {
  179. struct BH *bh_prev, *bh ;
  180. struct SH *sh, *sh_next, *sh_prev ;
  181. char address[30] ;
  182.  
  183.     bh_prev = NULL ;
  184.     bh = bh_first ;
  185.     while (bh != NULL) 
  186.     {
  187.         if (bh->cs != block_cs(bh)) 
  188.         { 
  189.             alert_str(BLOCK_DESTROYED, ltoa((long)bh, address, 16)) ; 
  190.             return ; 
  191.         }
  192.         if ( ((long)ptr >= (long)bh + sizeof(*bh) + sizeof(*sh))
  193.             && ((long)ptr < (long)bh + bh->size) )
  194.         {
  195.             /*** memory to be freed lies in this block ***/
  196.             sh = (struct SH *)(bh + 1) ; sh_prev = sh ;
  197.             while ( (long)sh < (long)bh + bh->size ) 
  198.             {
  199.                 if (sh->cs != section_cs(sh))
  200.                 {
  201.                     alert_str(SECTION_DESTROYED, ltoa((long)sh, address, 16)) ;
  202.                     return ;
  203.                 }
  204.                 if ((void *)(sh + 1) == ptr)
  205.                 {
  206.                     /*** free section ***/
  207.                     sh->FREE = TRUE ;
  208.                     bh->free += sh->size ;
  209.                     sh_next = (struct SH *)((long)(sh + 1) + sh->size) ;
  210.                     if ((long)sh_next + sizeof(*sh_next) + MIN_BYTES <= (long)bh + bh->size )
  211.                     {
  212.                         if (sh_next->cs != section_cs(sh_next))
  213.                         {
  214.                             alert_str(SECTION_DESTROYED, ltoa((long)sh, address, 16)) ;
  215.                             return ;
  216.                         }
  217.                         if (sh_next->FREE)
  218.                         {
  219.                             /*** put together both free sections ***/
  220.                             sh->size += (sizeof(*sh_next) + sh_next->size) ;
  221.  
  222.                             /*** update block header ***/
  223.                             bh->free += sizeof(*sh_next) ;
  224.                         }
  225.                     }
  226.                     sh->cs = section_cs(sh) ;
  227.                     if ((sh_prev->FREE) && (sh_prev != sh))
  228.                     {
  229.                         /*** put together both free sections ***/
  230.                         sh_prev->size += (sizeof(*sh) + sh->size) ;
  231.                         sh_prev->cs = section_cs(sh_prev) ;
  232.         
  233.                         /*** update block header ***/
  234.                         bh->free += sizeof(*sh) ;
  235.                     }
  236.                     bh->cs = block_cs(bh) ;
  237.                     if (bh->free + sizeof(*bh) + sizeof(*sh) == bh->size)
  238.                     {
  239.                         /*** block is empty, it can be freed ***/
  240.                         if (bh_prev == NULL) bh_first = bh->next ;
  241.                         else
  242.                         {
  243.                             bh_prev->next = bh->next ;
  244.                             bh_prev->cs = block_cs(bh_prev) ;
  245.                         }
  246.                         Ax_free(bh) ;
  247.                     }
  248.                 return ;
  249.                 }
  250.                 sh_prev = sh ;
  251.                 sh = (struct SH *)( (long)(sh + 1) + sh->size ) ;
  252.             } 
  253.         } /* if inside this block */
  254.         bh_prev = bh ;
  255.         bh = bh->next ;
  256.     } 
  257.     alert_str(NOT_ALLOCATED, "") ;
  258. }
  259.  
  260.  
  261. void debug_mem (void* defective)
  262. {
  263. char all_symptoms[30] = "" ;
  264.  
  265.     ltoa( (long)defective, all_symptoms, 0x10) ;
  266.     strncat(all_symptoms, " ", 1) ;
  267.     strncat(all_symptoms, memory_symptom, 20) ;
  268.     alert_str(MEMORY_ERROR, all_symptoms) ; 
  269. }
  270.  
  271.  
  272. void *My_shrink(void *memory, long size)
  273. {
  274. void *new_memory ;
  275.  
  276.     /*** free memory if new size shall be 0 ***/
  277.     if (!size) 
  278.     {
  279.         My_free(memory) ;
  280.         return NULL ;
  281.     }
  282.     /*** allocate new memory ***/
  283.     new_memory = My_alloc(size) ;
  284.     if (!new_memory) return memory ; /* not "shrinked" */    
  285.  
  286.     /*** copy old to new ***/
  287.     memcpy(new_memory, memory, size) ;
  288.  
  289.     /*** free old memory ***/
  290.     My_free(memory) ;
  291.  
  292.     /*** return pointer to new memory ***/
  293.     return new_memory ; 
  294. }
  295.  
  296.  
  297. void *My_alloc(long size)
  298. {
  299.     void *ptr = Allocate(size) ;
  300.     if (i < MAX_OPERATIONS)
  301.     {
  302.         operation[i].type = Memory ;
  303.         operation[i].ptr  = (long)ptr ;
  304.         operation[i].size = size ;
  305.         i++ ;
  306.     }
  307.     return ptr ;
  308. }
  309.  
  310. void My_free(void *ptr)
  311. {
  312.     Free(ptr) ;
  313.     if (i < MAX_OPERATIONS)
  314.     {
  315.         operation[i].type = Memory ;
  316.         operation[i].ptr  = (long)ptr ;
  317.         operation[i].size = 0 ;
  318.         i++ ;
  319.     }
  320. }
  321.  
  322.  
  323. char *Myst_create(const char *parent)
  324. {
  325.     char *ptr = Ast_create(parent) ;
  326.     if (i < MAX_OPERATIONS)
  327.     {
  328.         operation[i].type = String ;
  329.         operation[i].ptr  = (long)ptr ;
  330.         operation[i].size = strlen(parent) ;
  331.         i++ ;
  332.     }
  333.     return ptr ;
  334. }
  335.  
  336. void Myst_delete(char *ptr)
  337. {
  338.     Ast_delete(ptr) ;
  339.     if (i < MAX_OPERATIONS)
  340.     {
  341.         operation[i].type = String ;
  342.         operation[i].ptr  = (long)ptr ;
  343.         operation[i].size = 0 ;
  344.         i++ ;
  345.     }
  346. }
  347.  
  348.  
  349. OBJECT *Myob_create(const OBJECT *parent)
  350. {
  351.     OBJECT *ptr = Aob_create(parent) ;
  352.     if (i < MAX_OPERATIONS)
  353.     {
  354.         operation[i].type = Object ;
  355.         operation[i].ptr  = (long)ptr ;
  356.         operation[i].size = sizeof(*ptr) ;
  357.         i++ ;
  358.     }
  359.     return ptr ;
  360. }
  361.  
  362. void Myob_delete(OBJECT *ptr)
  363. {
  364.     Aob_delete(ptr) ;
  365.     if (i < MAX_OPERATIONS)
  366.     {
  367.         operation[i].type = Object ;
  368.         operation[i].ptr  = (long)ptr ;
  369.         operation[i].size = 0 ;
  370.         i++ ;
  371.     }
  372. }
  373.  
  374.  
  375. Awindow *Mywi_create(const Awindow *parent)
  376. {
  377.     Awindow *ptr = Awi_create(parent) ;
  378.     if (i < MAX_OPERATIONS)
  379.     {
  380.         operation[i].type = Window ;
  381.         operation[i].ptr  = (long)ptr ;
  382.         operation[i].size = sizeof(*ptr) ;
  383.         i++ ;
  384.     }
  385.     return ptr ;
  386. }
  387.  
  388. void Mywi_delete(Awindow *ptr)
  389. {
  390.     Awi_delete(ptr) ;
  391.     if (i < MAX_OPERATIONS)
  392.     {
  393.         operation[i].type = Window ;
  394.         operation[i].ptr  = (long)ptr ;
  395.         operation[i].size = 0 ;
  396.         i++ ;
  397.     }
  398. }
  399.  
  400.  
  401. void print_operations(void)
  402. {
  403.     Fforce(1, (int)Fdup(3)) ;
  404.     for (i = 0 ; i < MAX_OPERATIONS ; i++)
  405.     {
  406.         switch (operation[i].type)
  407.         {
  408.             case Memory: printf("Memory %lx", (long)operation[i].ptr) ; break ;
  409.             case String: printf("String %lx", (long)operation[i].ptr) ; break ;
  410.             case Object: printf("Object %lx", (long)operation[i].ptr) ; break ;
  411.             case Window: printf("Window %lx", (long)operation[i].ptr) ; break ;
  412.         }
  413.         printf(" Size %lx \n", operation[i].size) ;
  414.     }
  415.     Fforce(1, (int)Fdup(1)) ;
  416. }
  417.  
  418.  
  419. /**************************************************************
  420. *
  421. *                timer management
  422. *
  423. **************************************************************/
  424.  
  425. static Awindow *waiting_wi = NULL ;
  426. static int rest_time ;
  427.  
  428. int set_timer(Awindow *wi)
  429. {
  430.     if ((!waiting_wi) || (wi == waiting_wi))
  431.     {
  432.         rest_time = 3000 ; /* ms */
  433.         waiting_wi = wi ; /* now timer is running */
  434.         return 0 ;
  435.     }
  436.     else return -1 ;
  437. }
  438.  
  439. void stop_timer(Awindow *wi)
  440. { waiting_wi = NULL ; }
  441.  
  442. static void timer(void)
  443. {
  444. Awindow *buffer_wi ;
  445.  
  446.     if (waiting_wi)
  447.     {
  448.         /*** a job is running */
  449.         rest_time -= ev_mtcount ;
  450.         if (rest_time <= 0)
  451.         {
  452.             /*** timer expired ***/
  453.             buffer_wi = waiting_wi ;
  454.             waiting_wi = NULL ; /* timer is stopped now */
  455.             Awi_sendall(REDRAW, buffer_wi) ;
  456.         }
  457.     }
  458. }
  459.  
  460. void init_time(void)
  461. { ACSblk->ACStimer = timer ; /* replace with own timer procedure */ }
  462.  
  463.  
  464.  
  465.