/* ---------------------------------------------------------------------- */
/*                   Copyright (C) 1991 by Natrlich!                     */
/*                      This file is copyrighted!                         */
/*                Refer to the documentation for details.                 */
/* ---------------------------------------------------------------------- */
#define TEST 0                   /* may fail on big MACROS    */
/* these aren't actually _MAXIMAL_ values,but 'malloc' values */
/* if your malloc only allocates 64K and you don't want to go */
/* for farmalloc (as in MesS-DOS), figure values that keep    */
/* sizeof( struct) *  _MAXIMAL_ + 256 to < 0xFFFF             */
/* The values look very suggestively, like the higher the     */
/* better but actually 1/2 1/4 or even 1/8 won't reduce the   */
/* speed dramatically                                         */
/* too small values may actually CRASH your system            */
#if ! VERSION && TEST
# define LABMAX    10L           /* #global labels            */
# define LLABMAX   10L           /* #local labels             */
# define STRMAX    0x100L        /* #bytes for strings        */
# define EXPMAX    0x40L         /* #expressions              */
# define FIXMAX    0x10L         /* #forward ref fixes        */
# define LEXPMAX   0x10L         /* #lexpression              */
# define REFMAX    0x80L         /* #forward refs             */
# define MACTOKMAX 0x100L        /* #token in macro buffer    */
# define NBUFSIZ   0x1000L       /* #bytes file buffer space  */
# define SEGMAX    10L           /* #code segments            */
# define IMMMAX    50L           /* #immediate patch pointers */
#else
# define LABMAX    1000L         /* #global labels            */
# define LLABMAX   100L          /* #local labels             */
# define STRMAX    0x2000L       /* #bytes for strings        */
# define EXPMAX    0x400L        /* #expressions              */
# define FIXMAX    0x40L         /* #forward ref fixes        */
# define LEXPMAX   0x200L        /* #lexpression              */
# define REFMAX    0x80L         /* #forward refs             */
# define MACTOKMAX 0x1000L       /* #token in macro buffer    */
# define NBUFSIZ   0x2000L       /* #bytes file buffer space  */
# define SEGMAX    50L           /* #code segments            */
# define IMMMAX    100L          /* #immediate patch pointers */
#endif
/* ---------------------------------------------------------- */
#define MAXMODULE 0xFE00L        /* 64K address space on 6502 */
#if OS == UNIX
# define LIBMAX   0x80000L       /* Library maximum size 512K */
#endif
#if OS == MSDOS
# define LIBMAX   0x40000L
#endif

#define MAXFLOATS 32             /* #floats in one line       */
#define MACSPACE  (MACTOKMAX * (sizeof( int) + sizeof( lword)))

#if __NSTDC__ && __TURBOC__
void huge   *nmalloc( lword),
            nfree( void huge *);
#else
void huge   *nmalloc();
void        nfree();
#endif
/* ---------------------------------------------------------- */
/*          Copyright (c) 1990 by Natrlich!                  */
/* ---------------------------------------------------------- */
/* This is a generic function so to speak (it is of course    */
/* just a simple macro) that builds a custom mallocer for a   */
/* structure. The benefits are:                               */
/*       Speed                                                */
/*       Garbage collectability                               */
/*       Fragmentation                                        */
/* The detriments (?) are:                                    */
/*       No "free()"                                          */
/*         Not all that portable if it isn't ANSI-C.          */
/*       <space> ## <space> used to stand here, but some        */
/*      Compilers can't take it.                              */
/* ---------------------------------------------------------- */
#if ! STATISTICS

#if CANCONCAT

#define make_mallocer( type, max, fun_name)                       \
typedef struct _ ## type ## _m                                        \
{                                                                 \
   long            free;                                          \
   type huge       *tab;                                          \
   struct _ ## type ## _m huge  *before;                              \
} type ## _m;                                                       \
                                                                  \
type ## _m huge * ## type ## _h = 0;                                    \
                                                                  \
type *fun_name()                                                  \
{                                                                 \
   register type ## _m huge *p;                                     \
                                                                  \
   if( (p = type ## _h) && p->free--)                               \
      return( p->tab++);                                          \
   p         = nmalloc( (lword) (sizeof(type ## _m) +               \
                                       max * sizeof( type)));     \
   p->free   = max - 1;                                           \
   p->tab    = (type *) ((char huge *) p + sizeof( type ## _m));    \
   p->before = (type ## _m *) type ## _h;                             \
   type ## _h  = p;                                                 \
   return( p->tab++);                                             \
}
#else
#define make_mallocer( type, max, fun_name)                       \
typedef struct _/**/type/**/_m                                    \
{                                                                 \
   long            free;                                          \
   type huge       *tab;                                          \
   struct _/**/type/**/_m huge *before;                           \
} type/**/_m;                                                     \
                                                                  \
type/**/_m huge */**/type/**/_h = 0;                              \
                                                                  \
type *fun_name()                                                  \
{                                                                 \
   register type/**/_m huge *p;                                   \
                                                                  \
   if( (p = type/**/_h) && p->free--)                             \
      return( p->tab++);                                          \
   p         = nmalloc((lword) (sizeof(type/**/_m)+               \
                                       max * sizeof( type)));     \
   p->free   = max - 1;                                           \
   p->tab    = (type *) ((char huge *) p + sizeof( type/**/_m));  \
   p->before = (type/**/_m *) type/**/_h;                         \
   type/**/_h = p;                                                \
   return( p->tab++);                                             \
}
#endif

#else

#if CANCONCAT
#define make_mallocer( type, max, fun_name)                       \
typedef struct _ ## type ## _m                                        \
{                                                                 \
   long            free;                                          \
   type huge       *tab;                                          \
   struct _ ## type ## _m huge *before;                               \
} type ## _m;                                                       \
                                                                  \
type ## _m huge * ## type ## _h = 0;                                    \
                                                                  \
type *fun_name()                                                  \
{                                                                 \
   register type ## _m huge *p;                                     \
   extern   word        _a_ ## type,                                \
                        _m_ ## type;                                \
   extern   lword       _s_ ## type;                                \
                                                                  \
   _a_ ## type++;                                                   \
   if( (p = type ## _h) && p->free--)                               \
      return( p->tab++);                                          \
   _m_ ## type++;                                                   \
   _s_ ## type = sizeof(type ## _m) + max * sizeof( type);            \
   p         = nmalloc( (lword) (sizeof(type ## _m) +               \
                                       max * sizeof( type)));     \
   p->free   = max - 1;                                           \
   p->tab    = (type *) ((char huge *) p + sizeof( type ## _m));    \
   p->before = (type ## _m *) type ## _h;                             \
   type ## _h  = p;                                                 \
   return( p->tab++);                                             \
}
#else
#define make_mallocer( type, max, fun_name)                       \
typedef struct _/**/type/**/_m                                    \
{                                                                 \
   long            free;                                          \
   type huge       *tab;                                          \
   struct _/**/type/**/_m huge *before;                           \
} type/**/_m;                                                     \
                                                                  \
type/**/_m huge */**/type/**/_h = 0;                              \
                                                                  \
type *fun_name()                                                  \
{                                                                 \
   register type/**/_m huge  *p;                                  \
   extern   word        _a_/**/type,                              \
                        _m_/**/type;                              \
   extern   lword       _s_/**/type;                              \
                                                                  \
   _a_/**/type++;                                                 \
   if( (p = type/**/_h) && p->free--)                             \
      return( p->tab++);                                          \
   _m_/**/type++;                                                 \
   _s_/**/type = sizeof(type/**/_m) + max * sizeof( type);        \
   p         = nmalloc((lword) sizeof(type/**/_m)+                \
                                       max * sizeof( type)));     \
   p->free   = max - 1;                                           \
   p->tab    = (type *) ((char huge *) p + sizeof( type/**/_m));  \
   p->before = (type/**/_m *) type/**/_h;                         \
   type/**/_h = p;                                                \
   return( p->tab++);                                             \
}
#endif
#endif

#if ! STATISTICS

#if CANCONCAT

#define dup_mallocer( type, max, fun_name, id)                    \
type ## _m huge   * id ## type ## _h = 0;                               \
                                                                  \
type *fun_name()                                                  \
{                                                                 \
   register type ## _m huge *p;                                     \
                                                                  \
   if( (p = id ## type ## _h) && p->free--)                           \
      return( p->tab++);                                          \
   p         = nmalloc((lword) (sizeof(type ## _m) +                \
                                       max * sizeof( type)));     \
   p->free   = max - 1;                                           \
   p->tab    = (type *) ((char huge *) p + sizeof( type ## _m));    \
   p->before = (type ## _m *) id ## type ## _h;                         \
   id ## type ## _h = p;                                              \
   return( p->tab++);                                             \
}
#else
#define dup_mallocer( type, max, fun_name, id)                    \
                                                                  \
type/**/_m huge  *id/**/type/**/_h = 0;                           \
                                                                  \
type *fun_name()                                                  \
{                                                                 \
   register type/**/_m huge *p;                                   \
                                                                  \
   if( (p = id/**/type/**/_h) && p->free--)                       \
      return( p->tab++);                                          \
   p         = nmalloc((lword) (sizeof(type/**/_m)+               \
                                       max * sizeof( type)));     \
   p->free   = max - 1;                                           \
   p->tab    = (type *) ((char huge *) p + sizeof( type/**/_m));  \
   p->before = (type/**/_m *) id/**/type/**/_h;                   \
   id/**/type/**/_h = p;                                          \
   return( p->tab++);                                             \
}
#endif

#else

#if CANCONCAT
#define dup_mallocer( type, max, fun_name, id)                    \
type ## _m huge  * id ## type ## _h = 0;                                \
                                                                  \
type *fun_name()                                                  \
{                                                                 \
   register type ## _m huge *p;                                     \
   extern   word        _a_ ## id ## type,                            \
                        _m_ ## id ## type;                            \
   extern   lword       _s_ ## id ## type;                            \
                                                                  \
   _a_ ## id ## type++;                                               \
   if( (p = id ## type ## _h) && p->free--)                           \
      return( p->tab++);                                          \
   _m_ ## id ## type++;                                               \
   _s_ ## id ## type = sizeof(type ## _m) + max * sizeof( type);        \
   p         = nmalloc( (lword) (sizeof(type ## _m) +               \
                                       max * sizeof( type)));     \
   p->free   = max - 1;                                           \
   p->tab    = (type *) ((char huge *) p + sizeof( type ## _m));    \
   p->before = (type ## _m *) id ## type ## _h;                         \
   id ## type ## _h = p;                                              \
   return( p->tab++);                                             \
}
#else
#define dup_mallocer( type, max, fun_name, id)                    \
type/**/_m huge  *id/**/type/**/_h = 0;                           \
                                                                  \
type *fun_name()                                                  \
{                                                                 \
   register type/**/_m huge *p;                                   \
   extern   word        _a_/**/id/**/type,                        \
                        _m_/**/id/**/type;                        \
   extern   lword       _s_/**/id/**/type;                        \
                                                                  \
   _a_/**/id/**/type++;                                           \
   if( (p = id/**/type/**/_h) && p->free--)                       \
      return( p->tab++);                                          \
   _m_/**/id/**/type++;                                           \
   _s_/**/id/**/type = sizeof(type/**/_m) + max * sizeof( type);  \
   p         = nmalloc((lword) (sizeof(type/**/_m)+               \
                                       max * sizeof( type)));     \
   p->free   = max - 1;                                           \
   p->tab    = (type *) ((char huge *) p + sizeof( type/**/_m));  \
   p->before = (type/**/_m *) id/**/type/**/_h;                   \
   id/**/type/**/_h = p;                                          \
   return( p->tab++);                                             \
}
#endif
#endif