home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 9 / FreshFishVol9-CD2.bin / bbs / disk / mkisofs-1.00.7.lha / mkisofs / amiga.c next >
C/C++ Source or Header  |  1994-05-29  |  3KB  |  129 lines
  1. /* amiga.c: */
  2.  
  3. #include "mkisofs.h"
  4. #undef malloc
  5. #include <stdlib.h>
  6. #include <stdio.h>
  7. #include <exec/memory.h>
  8.  
  9. #ifdef AMIGA
  10. #ifdef LATTICE
  11. #include <proto/exec.h>
  12. #else
  13. #include <clib/exec_protos.h>
  14. #endif
  15. #endif
  16.  
  17. #ifdef LATTICE
  18. void __regargs _CXBRK (void)
  19. {
  20.   fprintf (stderr, "\nuser interrupt\n");
  21.   exit (1);
  22. }
  23. #endif
  24.  
  25. void* xmalloc (size_t p_size)
  26. {
  27.   void *result = malloc (p_size);
  28.   if (!result) {
  29.     fprintf (stderr, "\nmkisofs: out of memory, cannot allocate %d bytes!\n",
  30.              (int) p_size);
  31.     exit (10);
  32.   }
  33.   return result;
  34. }
  35.  
  36. char* xstrdup (char* p_string)
  37. {
  38.   char *result = xmalloc (strlen (p_string) + 1);
  39.   strcpy (result, p_string);
  40.   return result;
  41. }
  42.  
  43. /* -------------------- Memory Management -------------------- */
  44.  
  45. #define MALLOC_FOREVER_CHUNKSIZE 16384
  46. #define MALLOC_MAX_CHUNKS 2048
  47.  
  48. typedef struct mem_node {
  49.   struct mem_node  *next;
  50.   char           *chunk;
  51.   unsigned int       offset;
  52. } t_mem_node;
  53.  
  54. static t_mem_node *g_mem_list = NULL;
  55. static char **g_chunk_table = NULL;
  56.  
  57. static void malloc_forever_cleanup (void)
  58. {
  59.   int i;
  60.  
  61.   for (i=0; i<MALLOC_MAX_CHUNKS && g_chunk_table[i]; i++)
  62.     FreeMem (g_chunk_table[i], MALLOC_FOREVER_CHUNKSIZE);
  63.   
  64.   FreeMem (g_chunk_table, sizeof (char*) * MALLOC_MAX_CHUNKS);
  65. }
  66.  
  67. void* malloc_forever (size_t p_size)
  68. {
  69.   static int next_chunk_number = -1;
  70.   t_mem_node *ptr = g_mem_list, *old;
  71.  
  72.   if (next_chunk_number == -1) {
  73.     next_chunk_number++;
  74.     g_chunk_table = (char**) AllocMem (sizeof (char*) * MALLOC_MAX_CHUNKS,
  75.                            MEMF_ANY | MEMF_CLEAR);
  76.     if (!g_chunk_table) {
  77.       fprintf (stderr, "\nout of memory!\n");
  78.       exit (1);
  79.     }
  80.     atexit (malloc_forever_cleanup);
  81.   }
  82.  
  83.   if (p_size > MALLOC_FOREVER_CHUNKSIZE)
  84.     return xmalloc (p_size);
  85.  
  86.   /* even sizes only: */
  87.   if (p_size & 1)
  88.     p_size++;
  89.  
  90.   for (old = NULL; ptr; old = ptr, ptr = ptr->next) {
  91.     if (p_size <= MALLOC_FOREVER_CHUNKSIZE - ptr->offset) {
  92.       char *result = ptr->chunk + ptr->offset;
  93.       ptr->offset += p_size;
  94.       if (MALLOC_FOREVER_CHUNKSIZE - 8 < ptr->offset) {
  95.         if (old)
  96.       old->next = ptr->next;
  97.     else
  98.       g_mem_list = ptr->next;
  99.         free (ptr);
  100.       }
  101.       return (void*) result;
  102.     }
  103.   }
  104.  
  105.   if (next_chunk_number == MALLOC_MAX_CHUNKS) {
  106.     fprintf (stderr, "error: internal memory management table overflow\n");
  107.     exit (0);
  108.   }
  109.  
  110.   ptr = xmalloc (sizeof (*ptr));
  111.   ptr->chunk = g_chunk_table[next_chunk_number++] =
  112.     AllocMem (MALLOC_FOREVER_CHUNKSIZE, MEMF_ANY);
  113.   if (!ptr->chunk) {
  114.     fprintf (stderr, "out of memory!\n");
  115.     exit (1);
  116.   }
  117.   ptr->offset = p_size;
  118.   ptr->next = g_mem_list;
  119.   g_mem_list = ptr;
  120.   return (void*) ptr->chunk;
  121. }
  122.  
  123. char* strdup_forever (char *p_str)
  124. {
  125.   char* result = malloc_forever (strlen (p_str) + 1);
  126.   strcpy (result, p_str);
  127.   return result;
  128. }
  129.