#ifndef _VMHDR_H
#define _VMHDR_H 1
#ifndef _BLD_vmalloc
#define _BLD_vmalloc 1
#endif
#if _PACKAGE_ast
#if defined(__STDPP__directive) && defined(__STDPP__hide)
__STDPP__directive pragma pp:hide getpagesize
#else
#define getpagesize ______getpagesize
#endif
#include <ast.h>
#if defined(__STDPP__directive) && defined(__STDPP__hide)
__STDPP__directive pragma pp:nohide getpagesize
#else
#undef getpagesize
#endif
#else
#include <ast_common.h>
#include "FEATURE/vmalloc"
#endif
#undef free
#undef malloc
#undef realloc
#undef BITS
typedef unsigned char Vmuchar_t;
typedef unsigned long Vmulong_t;
typedef union _head_u Head_t;
typedef union _body_u Body_t;
typedef struct _block_s Block_t;
typedef struct _seg_s Seg_t;
typedef struct _pfobj_s Pfobj_t;
#define NIL(t) ((t)0)
#define reg register
#if __STD_C
#define NOTUSED(x) (void)(x)
#else
#define NOTUSED(x) (&x,1)
#endif
#define VLONG(addr) ((Vmulong_t)((char*)(addr) - (char*)0) )
#define ROUND2(x,y) (((x) + ((y)-1)) & ~((y)-1))
#define ROUNDX(x,y) ((((x) + ((y)-1)) / (y)) * (y))
#define ROUND(x,y) (((y)&((y)-1)) ? ROUNDX((x),(y)) : ROUND2((x),(y)) )
#define MULTIPLE(x,y) ((x)%(y) == 0 ? (x) : (y)%(x) == 0 ? (y) : (y)*(x))
#ifndef DEBUG
#define ASSERT(p)
#define COUNT(n)
#else
extern int printf _ARG_((const char*, ...));
#if defined(__LINE__) && defined(__FILE__)
#define PRFILELINE printf("Assertion failed at %s:%d\n",__FILE__,__LINE__)
#else
#define PRFILELINE 0
#endif
#define ASSERT(p) ((p) ? 0 : (PRFILELINE, abort(), 0) )
#define COUNT(n) ((n) += 1)
#endif
#define VMPAGESIZE 8192
#if _lib_getpagesize
#define GETPAGESIZE(x) ((x) ? (x) : \
(((x)=getpagesize()) < VMPAGESIZE ? ((x)=VMPAGESIZE) : (x)) )
#else
#define GETPAGESIZE(x) ((x) = VMPAGESIZE)
#endif
#define BUSY (01)
#define PFREE (02)
#define JUNK (04)
#define BITS (07)
#define ALIGNB (8)
#define ISBITS(w) ((w) & BITS)
#define CLRBITS(w) ((w) &= ~BITS)
#define CPYBITS(w,f) ((w) |= ((f)&BITS) )
#define ISBUSY(w) ((w) & BUSY)
#define SETBUSY(w) ((w) |= BUSY)
#define CLRBUSY(w) ((w) &= ~BUSY)
#define ISPFREE(w) ((w) & PFREE)
#define SETPFREE(w) ((w) |= PFREE)
#define CLRPFREE(w) ((w) &= ~PFREE)
#define ISJUNK(w) ((w) & JUNK)
#define SETJUNK(w) ((w) |= JUNK)
#define CLRJUNK(w) ((w) &= ~JUNK)
#define OFFSET(t,e) ((size_t)(&(((t*)0)->e)) )
#define VM_AGAIN 0010000
#define VM_LOCK 0020000
#define VM_LOCAL 0040000
#define VM_UNUSED 0104060
#define VMETHOD(vd) ((vd)->mode&VM_METHODS)
#define SETLOCAL(vd) ((vd)->mode |= VM_LOCAL)
#define GETLOCAL(vd,l) (((l) = (vd)->mode&VM_LOCAL), ((vd)->mode &= ~VM_LOCAL) )
#define ISLOCK(vd,l) ((l) ? 0 : ((vd)->mode & VM_LOCK) )
#define SETLOCK(vd,l) ((l) ? 0 : ((vd)->mode |= VM_LOCK) )
#define CLRLOCK(vd,l) ((l) ? 0 : ((vd)->mode &= ~VM_LOCK) )
#define KPVALLOC(vm,sz,func) (SETLOCAL((vm)->data), func((vm),(sz)) )
#define KPVALIGN(vm,sz,al,func) (SETLOCAL((vm)->data), func((vm),(sz),(al)) )
#define KPVFREE(vm,d,func) (SETLOCAL((vm)->data), func((vm),(d)) )
#define KPVRESIZE(vm,d,sz,mv,func) (SETLOCAL((vm)->data), func((vm),(d),(sz),(mv)) )
#define KPVADDR(vm,addr,func) (SETLOCAL((vm)->data), func((vm),(addr)) )
union _align_u
{ char c, *cp;
int i, *ip;
long l, *lp;
double d, *dp, ***dppp[8];
size_t s, *sp;
void(* fn)();
union _align_u* align;
Head_t* head;
Body_t* body;
Block_t* block;
Vmuchar_t a[ALIGNB];
#if _long_double
long double ld, *ldp;
#endif
};
struct _a_s
{ char c;
union _align_u a;
};
#define ALIGNA (sizeof(struct _a_s) - sizeof(union _align_u))
struct _align_s
{ char data[MULTIPLE(ALIGNA,ALIGNB)];
};
#define ALIGN sizeof(struct _align_s)
struct _head_s
{ union
{ Seg_t* seg;
Block_t* link;
Pfobj_t* pf;
char* file;
} seg;
union
{ size_t size;
Block_t* link;
int line;
} size;
};
#define HEADSIZE ROUND(sizeof(struct _head_s),ALIGN)
union _head_u
{ Vmuchar_t data[HEADSIZE];
struct _head_s head;
};
struct _body_s
{ Block_t* link;
Block_t* left;
Block_t* right;
Block_t** self;
};
#define BODYSIZE ROUND(sizeof(struct _body_s),ALIGN)
union _body_u
{ Vmuchar_t data[BODYSIZE];
struct _body_s body;
};
struct _block_s
{ Head_t head;
Body_t body;
};
struct _tiny_s
{ Block_t* link;
Block_t* self;
};
#define TINYSIZE ROUND(sizeof(struct _tiny_s),ALIGN)
#define S_TINY 7
#define MAXTINY (S_TINY*ALIGN + TINYSIZE)
#define TLEFT(b) ((b)->head.head.seg.link)
#define TINIEST(b) (SIZE(b) == TINYSIZE)
#define DIV(x,y) ((y) == 8 ? ((x)>>3) : (x)/(y) )
#define INDEX(s) DIV((s)-TINYSIZE,ALIGN)
#define S_CACHE 7
#define MAXCACHE (S_CACHE*ALIGN + TINYSIZE)
#define C_INDEX(s) (s < MAXCACHE ? INDEX(s) : S_CACHE)
#define TINY(vd) ((vd)->tiny)
#define CACHE(vd) ((vd)->cache)
typedef struct _vmdata_s
{ int mode;
size_t incr;
size_t pool;
Seg_t* seg;
Block_t* free;
Block_t* wild;
Block_t* root;
Block_t* tiny[S_TINY];
Block_t* cache[S_CACHE+1];
} Vmdata_t;
#define _VM_PRIVATE_ \
Vmdisc_t* disc; \
Vmdata_t* data; \
Vmalloc_t* next;
#include "vmalloc.h"
#undef malloc
#undef free
#undef realloc
struct _seg_s
{ Vmalloc_t* vm;
Seg_t* next;
Void_t* addr;
size_t extent;
Vmuchar_t* baddr;
size_t size;
Block_t* free;
Block_t* last;
};
#define SEGBLOCK(s) ((Block_t*)(((Vmuchar_t*)(s)) + ROUND(sizeof(Seg_t),ALIGN)))
#define SEG(b) ((b)->head.head.seg.seg)
#define SEGLINK(b) ((b)->head.head.seg.link)
#define SIZE(b) ((b)->head.head.size.size)
#define SIZELINK(b) ((b)->head.head.size.link)
#define LINK(b) ((b)->body.body.link)
#define LEFT(b) ((b)->body.body.left)
#define RIGHT(b) ((b)->body.body.right)
#define VM(b) (SEG(b)->vm)
#define DATA(b) ((Void_t*)((b)->body.data) )
#define BLOCK(d) ((Block_t*)((char*)(d) - sizeof(Head_t)) )
#define SELF(b) ((Block_t**)((b)->body.data + SIZE(b) - sizeof(Block_t*)) )
#define LAST(b) (*((Block_t**)(((char*)(b)) - sizeof(Block_t*)) ) )
#define NEXT(b) ((Block_t*)((b)->body.data + SIZE(b)) )
#define SETLINK(b) (RIGHT(b) = (b) )
#define ISLINK(b) (RIGHT(b) == (b) )
#define UNLINK(vd,b,i,t) \
((((t) = LINK(b)) ? (LEFT(t) = LEFT(b)) : NIL(Block_t*) ), \
(((t) = LEFT(b)) ? (LINK(t) = LINK(b)) : (TINY(vd)[i] = LINK(b)) ) )
#define REMOVE(vd,b,i,t,func) \
((!TINIEST(b) && ISLINK(b)) ? UNLINK((vd),(b),(i),(t)) : \
func((vd),SIZE(b),(b)) )
#define SEGWILD(b) (((b)->body.data+SIZE(b)+sizeof(Head_t)) >= SEG(b)->baddr)
#define VMWILD(vd,b) (((b)->body.data+SIZE(b)+sizeof(Head_t)) >= vd->seg->baddr)
#define VMFILELINE(vm,f,l) ((f) = (vm)->file, (vm)->file = NIL(char*), \
(l) = (vm)->line, (vm)->line = 0 )
#define PF_EXTRA sizeof(Head_t)
#define PFDATA(d) ((Head_t*)((Vmuchar_t*)(d)+(SIZE(BLOCK(d))&~BITS)-sizeof(Head_t)) )
#define PFOBJ(d) (PFDATA(d)->head.seg.pf)
#define PFSIZE(d) (PFDATA(d)->head.size.size)
#define DB_HEAD (2*sizeof(Head_t))
#define DB_TAIL (2*sizeof(Head_t))
#define DB_EXTRA (DB_HEAD+DB_TAIL)
#define DBBLOCK(d) ((Block_t*)((Vmuchar_t*)(d) - 3*sizeof(Head_t)) )
#define DBBSIZE(d) (SIZE(DBBLOCK(d)) & ~BITS)
#define DBSEG(d) (((Head_t*)((Vmuchar_t*)(d) - sizeof(Head_t)))->head.seg.seg )
#define DBSIZE(d) (((Head_t*)((Vmuchar_t*)(d) - 2*sizeof(Head_t)))->head.size.size )
#define DBFILE(d) (((Head_t*)((Vmuchar_t*)(d) - 2*sizeof(Head_t)))->head.seg.file )
#define DBLN(d) (((Head_t*)((Vmuchar_t*)DBBLOCK(d)+DBBSIZE(d)))->head.size.line )
#define DBLINE(d) (DBLN(d) < 0 ? -DBLN(d) : DBLN(d))
#define DB2BEST(d) ((Vmuchar_t*)(d) - 2*sizeof(Head_t))
#define DB2DEBUG(b) ((Vmuchar_t*)(b) + 2*sizeof(Head_t))
#define DBSETFL(d,f,l) (DBFILE(d) = (f), DBLN(d) = (f) ? (l) : 1)
#define DBSETBAD(d) (DBLN(d) > 0 ? (DBLN(d) = -DBLN(d)) : -1)
#define DBISBAD(d) (DBLN(d) <= 0)
#define DB_MAGIC 0255
#define DBHEAD(d,begp,endp) \
(((begp) = (Vmuchar_t*)(&DBSEG(d)) + sizeof(Seg_t*)), ((endp) = (d)) )
#define DBTAIL(d,begp,endp) \
(((begp) = (Vmuchar_t*)(d)+DBSIZE(d)), ((endp) = (Vmuchar_t*)(&DBLN(d))) )
#define INTCOPY(to,fr,n) \
switch(n/sizeof(int)) \
{ default: memcpy((Void_t*)to,(Void_t*)fr,n); break; \
case 7: *to++ = *fr++; \
case 6: *to++ = *fr++; \
case 5: *to++ = *fr++; \
case 4: *to++ = *fr++; \
case 3: *to++ = *fr++; \
case 2: *to++ = *fr++; \
case 1: *to++ = *fr++; \
}
#define INTZERO(d,n) \
switch(n/sizeof(int)) \
{ default: memset((Void_t*)d,0,n); break; \
case 7: *d++ = 0; \
case 6: *d++ = 0; \
case 5: *d++ = 0; \
case 4: *d++ = 0; \
case 3: *d++ = 0; \
case 2: *d++ = 0; \
case 1: *d++ = 0; \
}
typedef Block_t* (*Vmsearch_f)_ARG_((Vmdata_t*, size_t, Block_t*));
typedef struct _vmextern_
{ Block_t* (*vm_extend)_ARG_((Vmalloc_t*, size_t, Vmsearch_f ));
int (*vm_truncate)_ARG_((Vmalloc_t*, Seg_t*, size_t, int));
size_t vm_pagesize;
char* (*vm_strcpy)_ARG_((char*, char*, int));
char* (*vm_itoa)_ARG_((Vmulong_t, int));
void (*vm_trace)_ARG_((Vmalloc_t*,
Vmuchar_t*, Vmuchar_t*, size_t, size_t));
void (*vm_pfclose)_ARG_((Vmalloc_t*));
} Vmextern_t;
#define _Vmextend (_Vmextern.vm_extend)
#define _Vmtruncate (_Vmextern.vm_truncate)
#define _Vmpagesize (_Vmextern.vm_pagesize)
#define _Vmstrcpy (_Vmextern.vm_strcpy)
#define _Vmitoa (_Vmextern.vm_itoa)
#define _Vmtrace (_Vmextern.vm_trace)
#define _Vmpfclose (_Vmextern.vm_pfclose)
_BEGIN_EXTERNS_
extern Vmextern_t _Vmextern;
#if !_PACKAGE_ast
extern size_t getpagesize _ARG_((void));
extern void abort _ARG_(( void ));
extern ssize_t write _ARG_(( int, const void*, size_t ));
#if !__STDC__ && !_hdr_stdlib
extern size_t strlen _ARG_(( const char* ));
extern char* strcpy _ARG_(( char*, const char* ));
extern int strcmp _ARG_(( const char*, const char* ));
extern int atexit _ARG_(( void(*)(void) ));
extern char* getenv _ARG_(( const char* ));
extern Void_t* memcpy _ARG_(( Void_t*, const Void_t*, size_t ));
extern Void_t* memset _ARG_(( Void_t*, int, size_t ));
#else
#ifndef cfree
#define cfree ______cfree
#endif
#include <stdlib.h>
#undef cfree
#include <string.h>
#endif
extern int creat _ARG_(( const char*, int ));
extern int close _ARG_(( int ));
extern int getpid _ARG_(( void ));
extern int onexit _ARG_(( void(*)(void) ));
extern void _exit _ARG_(( int ));
extern void _cleanup _ARG_(( void ));
#endif
#if !_typ_ssize_t
typedef int ssize_t;
#endif
#if !_WIN32
extern Vmuchar_t* sbrk _ARG_(( ssize_t ));
#endif
_END_EXTERNS_
#endif