1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
  
35
  
36
  
37
  
38
  
39
  
40
  
41
  
42
  
43
  
44
  
45
  
46
  
47
  
48
  
49
  
50
  
51
  
52
  
53
  
54
  
55
  
56
  
57
  
58
  
59
  
60
  
61
  
62
  
63
  
64
  
65
  
66
  
67
  
68
  
69
  
70
  
71
  
72
  
73
  
/* $Id: block_alloc.h,v 1.5 1999/01/31 09:01:39 hubbe Exp $ */ 
#undef PRE_INIT_BLOCK 
#undef INIT_BLOCK 
#undef EXIT_BLOCK 
#undef BLOCK_ALLOC 
 
#define PRE_INIT_BLOCK(X) 
#define INIT_BLOCK(X) 
#define EXIT_BLOCK(X) 
 
#define BLOCK_ALLOC(DATA,BSIZE)                                                                       \ 
                                                                                                \ 
struct PIKE_CONCAT(DATA,_block)                                                                 \ 
{                                                                                               \ 
  struct PIKE_CONCAT(DATA,_block) *next;                                                        \ 
  struct DATA x[BSIZE];                                                                         \ 
};                                                                                              \ 
                                                                                                \ 
static struct PIKE_CONCAT(DATA,_block) *PIKE_CONCAT(DATA,_blocks)=0;                            \ 
static struct DATA *PIKE_CONCAT3(free_,DATA,s)=0;                                               \ 
                                                                                                \ 
struct DATA *PIKE_CONCAT(alloc_,DATA)(void)                                                     \ 
{                                                                                               \ 
  struct DATA *tmp;                                                                             \ 
  if(!PIKE_CONCAT3(free_,DATA,s))                                                               \ 
  {                                                                                             \ 
    struct PIKE_CONCAT(DATA,_block) *n;                                                         \ 
    int e;                                                                                      \ 
    n=(struct PIKE_CONCAT(DATA,_block) *)malloc(sizeof(struct PIKE_CONCAT(DATA,_block)));       \ 
    if(!n)                                                                                      \ 
    {                                                                                           \ 
      fprintf(stderr,"Fatal: out of memory.\n");                                                \ 
      exit(17);                                                                                 \ 
    }                                                                                           \ 
    n->next=PIKE_CONCAT(DATA,_blocks);                                                          \ 
    PIKE_CONCAT(DATA,_blocks)=n;                                                                \ 
                                                                                                \ 
    for(e=0;e<BSIZE;e++)                                                                        \ 
    {                                                                                           \ 
      n->x[e].next=PIKE_CONCAT3(free_,DATA,s);                                                  \ 
      PRE_INIT_BLOCK( (n->x+e) );                                                               \ 
      PIKE_CONCAT3(free_,DATA,s)=n->x+e;                                                        \ 
    }                                                                                           \ 
  }                                                                                             \ 
                                                                                                \ 
  tmp=PIKE_CONCAT3(free_,DATA,s);                                                               \ 
  PIKE_CONCAT3(free_,DATA,s)=tmp->next;                                                         \ 
  INIT_BLOCK(tmp);                                                                              \ 
  return tmp;                                                                                   \ 
}                                                                                               \ 
                                                                                                \ 
inline void PIKE_CONCAT(really_free_,DATA)(struct DATA *d)                                              \ 
{                                                                                               \ 
  EXIT_BLOCK(d);                                                                                \ 
  d->next=PIKE_CONCAT3(free_,DATA,s);                                                           \ 
  PRE_INIT_BLOCK(d);                                                                            \ 
  PIKE_CONCAT3(free_,DATA,s)=d;                                                                 \ 
}                                                                                               \ 
                                                                                                \ 
void PIKE_CONCAT3(free_all_,DATA,_blocks)(void)                                                 \ 
{                                                                                               \ 
  struct PIKE_CONCAT(DATA,_block) *tmp;                                                         \ 
  while((tmp=PIKE_CONCAT(DATA,_blocks)))                                                        \ 
  {                                                                                             \ 
    PIKE_CONCAT(DATA,_blocks)=tmp->next;                                                        \ 
    free((char *)tmp);                                                                          \ 
  }                                                                                             \ 
  PIKE_CONCAT(DATA,_blocks)=0;                                                                  \ 
  PIKE_CONCAT3(free_,DATA,s)=0;                                                                 \ 
}                                                                                               \