const cwal_scope cwal_scope_empty = cwal_scope_empty_m;
const cwal_state cwal_state_empty = cwal_state_empty_m;
const cwal_trace_state cwal_trace_state_empty = cwal_trace_state_empty_m;
const cwal_value_vtab cwal_value_vtab_empty = cwal_value_vtab_empty_m;
const cwal_memchunk_config cwal_memchunk_config_empty = cwal_memchunk_config_empty_m;
static const cwal_memchunk_overlay cwal_memchunk_overlay_empty = {0,0};
const cwal_memcap_config cwal_memcap_config_empty = cwal_memcap_config_empty_m;
const cwal_buffer_obj cwal_buffer_obj_empty = cwal_buffer_obj_empty_m;

/**
   If CWAL_INT_DOUBLE_SAME_SIZE is true then we can pack integers
   and doubles into the same recycling bins.
*/
#define CWAL_INT_DOUBLE_SAME_SIZE (sizeof(cwal_double_t)==sizeof(cwal_int_t))

      cwal_value_cleanup_hash,
      cwal_value_hash_ptr,
      cwal_value_cmp_ptr_only,
      cwal_rescope_children_hash
    };
static const cwal_value_vtab cwal_value_vtab_buffer =
    { CWAL_TYPE_BUFFER, "buffer",
      CWAL_F_ISA_OBASE,
      cwal_value_cleanup_buffer,
      cwal_value_hash_ptr,
      cwal_value_cmp_buffer,
      cwal_rescope_children_obase
    };
static const cwal_value_vtab cwal_value_vtab_function =
    { CWAL_TYPE_FUNCTION, "function",
      CWAL_F_ISA_OBASE,
      cwal_value_cleanup_function,
      cwal_value_hash_ptr,
      cwal_value_cmp_func,

#define CWAL_VOBASE(V) (CWAL_V_IS_OBASE(V) ? CWAL_VVPCAST(cwal_obase,(V)) : 0)

/**
   Casts CWAL_TYPE_NATIVE value V to (cwal_native*).
*/
#define CWAL_V2NATIVE(V) CWAL_VVPCAST(cwal_native,(V))
/**
   CWAL_BUFOBJ(V) casts CWAL_TYPE_BUFFER (cwal_value*) V to a (cwal_buffer_obj*).
*/
#define CWAL_BUFOBJ(V) (((V) && (V)->vtab && (CWAL_TYPE_BUFFER==(V)->vtab->typeID)) ? CWAL_VVPCAST(cwal_buffer_obj,(V)) : 0)

/**
   CWAL_UNIQUE_VALPP(V) casts gets the wrapped (cwal_value**) part of
   CWAL_TYPE_UNIQUE (cwal_value*) V. If V is-not-a Unique, it evals
   to 0.
*/
#define CWAL_UNIQUE_VALPP(V) (((V) && (V)->vtab && (CWAL_TYPE_UNIQUE==(V)->vtab->typeID)) ? (CWAL_VVPCAST(cwal_value*,(V))) : 0)

          assert(cwalRecyclerInfo.indexes[typeID]>=0);
          return cwalRecyclerInfo.indexes[typeID];
      default:
          return -1;
    }
}

/**
   Overwrites all state in buf with defaults (zeroes) but
   retains the buf->self member.
*/
static void cwal_buffer_wipe_keep_self( cwal_buffer * buf ){
    void * self = buf->self;
    *buf = cwal_buffer_empty;
    buf->self = self;
}

/** @internal

   Checks whether child refers to a higher scope than parent, and if
   it does then it moves child to par. If par is 0 this function
   sets *res (if not NULL) to 1 and returns.

ISA(bool,BOOL)
ISA(integer,INTEGER)
ISA(double,DOUBLE)
ISA(string,STRING)
ISA(array,ARRAY)
ISA(object,OBJECT)
ISA(native,NATIVE)
/* ISA(buffer,BUFFER) */
ISA(function,FUNCTION)
ISA(exception,EXCEPTION)
ISA(hash,HASH)
ISA(unique,UNIQUE)
#undef ISA


char cwal_value_is_buffer( cwal_value const * v ){
    cwal_buffer_obj const * bo = CWAL_BUFOBJ(v);
    assert(bo ? (bo==bo->buf.self) : 1);
    return (bo && bo == bo->buf.self) ? 1 : 0;
}

char cwal_value_is_number( cwal_value const * v ){
    if(!v) return 0;
    else switch(v->vtab->typeID){
      case CWAL_TYPE_INTEGER:
      case CWAL_TYPE_DOUBLE:
      case CWAL_TYPE_BOOL:
          return 1;

      case CWAL_TYPE_STRING: return sizeof(cwal_value)+sizeof(cwal_string);
      case CWAL_TYPE_UNIQUE: return sizeof(cwal_value)+sizeof(cwal_value*);
      case CWAL_TYPE_INTEGER: return sizeof(cwal_value)+sizeof(cwal_int_t);
      case CWAL_TYPE_DOUBLE: return sizeof(cwal_value)+sizeof(cwal_double_t);
      case CWAL_TYPE_ARRAY: return sizeof(cwal_value)+sizeof(cwal_array);
      case CWAL_TYPE_OBJECT: return sizeof(cwal_value)+sizeof(cwal_object);
      case CWAL_TYPE_NATIVE: return sizeof(cwal_value)+sizeof(cwal_native);
      case CWAL_TYPE_BUFFER: return sizeof(cwal_value)+sizeof(cwal_buffer_obj);
      case CWAL_TYPE_FUNCTION: return sizeof(cwal_value)+sizeof(cwal_function);
      case CWAL_TYPE_EXCEPTION: return sizeof(cwal_value)+sizeof(cwal_exception);
      case CWAL_TYPE_HASH: return sizeof(cwal_value)+sizeof(cwal_hash);
      case CWAL_TYPE_SCOPE: return sizeof(cwal_scope);
      case CWAL_TYPE_KVP: return sizeof(cwal_kvp);
      case CWAL_TYPE_WEAK_REF: return sizeof(cwal_weak_ref);
      case CWAL_TYPE_XSTRING:

          assert( 0 == extra );
          def = cwal_value_exception_empty;
          tx = sizeof(cwal_exception);
          break;
      case CWAL_TYPE_BUFFER:
          assert( 0 == extra );
          def = cwal_value_buffer_empty;
          tx = sizeof(cwal_buffer_obj);
          break;
      case CWAL_TYPE_HASH:
          assert( 0 == extra );
          def = cwal_value_hash_empty;
          tx = sizeof(cwal_hash);
          break;
      case CWAL_TYPE_UNIQUE:

    return CWAL_VALPART(s);
}

cwal_value * cwal_new_buffer_value(cwal_engine *e, cwal_size_t startingSize){
    cwal_value * v = cwal_value_new(e, e->current, CWAL_TYPE_BUFFER,0);
    if( NULL != v )
    {
        cwal_buffer_obj * bo = CWAL_BUFOBJ(v);
        cwal_buffer * b;
        assert(NULL != bo);
        b = &bo->buf;
        b->self = bo;
        cwal_buffer_wipe_keep_self(b);
        assert(bo == b->self);
        if(startingSize &&
           cwal_buffer_reserve(e, b, startingSize)){
            cwal_value_unref2(e, v);
            v = NULL;
        }
    }
    return v;
}

int cwal_buffer_unref(cwal_engine *e, cwal_buffer *v){
    return (e&&v)
        ? cwal_value_unref2( e, cwal_buffer_value(v) )
        : CWAL_RC_MISUSE;
}

int cwal_value_fetch_buffer( cwal_value const * val, cwal_buffer ** x){
    cwal_buffer_obj * bo;
    if( ! val ) return CWAL_RC_MISUSE;
    else if( !(bo = CWAL_BUFOBJ(val)) ) return CWAL_RC_TYPE;
    else{
        if(x) *x = &bo->buf;
        return 0;
    }
}
    
cwal_buffer * cwal_value_get_buffer( cwal_value const * v ) {
    cwal_buffer * b = NULL;
    cwal_value_fetch_buffer( v, &b );
    return b;
}

cwal_buffer * cwal_new_buffer(cwal_engine *e, cwal_size_t startingSize){
    return cwal_value_get_buffer(cwal_new_buffer_value(e, startingSize));
}

cwal_value * cwal_buffer_value(cwal_buffer const * s){
    if(!s || !s->self) return 0;
    else{
        cwal_buffer_obj const * bo = (cwal_buffer_obj const *)s->self;
        cwal_value * v = CWAL_VALPART(bo);
        assert(v && v->vtab && (CWAL_TYPE_BUFFER==v->vtab->typeID))
            /* trying to protect against misuse of stack-allocated
               buffers there. */;
        return v;
    }
}

cwal_string * cwal_buffer_to_zstring(cwal_engine * e, cwal_buffer * b){
    if(!e || !e->current || !b) return 0;
    else{
        cwal_string * s;

                                           b->used);
        if(s){
            /* Re-tweak the metrics which the ctor just counted,
               discounting b->used, as that was already counted
               elsewhere. */
            assert(e->metrics.bytes[CWAL_TYPE_ZSTRING] >= b->used);
            e->metrics.bytes[CWAL_TYPE_ZSTRING] -= b->used;
            cwal_buffer_wipe_keep_self(b);
        }
        return s;
    }
}

cwal_value * cwal_buffer_to_zstring_value(cwal_engine * e, cwal_buffer * b){
    return cwal_string_value(cwal_buffer_to_zstring(e,b));
}
    
/**
   cwal_value_vtab::destroy_value() impl for Buffer
   values. Cleans up self-owned memory, but does not
   free self.
*/
void cwal_value_cleanup_buffer( cwal_engine * e, void * self ){
    cwal_value * v = (cwal_value*)self;
    cwal_buffer_obj * bo = CWAL_BUFOBJ(v);
    cwal_buffer_reserve(e, &bo->buf, 0);
    cwal_cleanup_obase(e, &bo->base, 1);
    *bo = cwal_buffer_obj_empty;
}


void cwal_value_cleanup_exception( cwal_engine * e, void * self ){
    cwal_value * v = (cwal_value*)self;
    cwal_exception * f = CWAL_VVPCAST(cwal_exception,v);
    cwal_cleanup_obase(e, &f->base, 1);
    *f = cwal_exception_empty;
}

cwal_string * cwal_new_stringfv(cwal_engine * e, char const * fmt, va_list args ){
    if(!e || !fmt) return 0;
    else if(!*fmt) return cwal_new_string(e,"",0);
    else{
        int rc;

















        cwal_size_t const oldUsed = e->buffer.used;
        cwal_size_t slen;
        rc = cwal_buffer_printfv(e, &e->buffer, fmt, args);
        slen = e->buffer.used - oldUsed;
        e->buffer.used = oldUsed;
        return rc
            ? NULL
            : cwal_new_string(e,
                    slen ? (char const*)(e->buffer.mem+oldUsed) : NULL,
                    slen);
            ;

    }
}

cwal_string * cwal_new_stringf(cwal_engine * e, char const * fmt, ...){
    if(!e || !fmt) return 0;
    else if(!*fmt) return cwal_new_string(e,"",0);
    else{

int cwal_props_copy( cwal_value * src, cwal_value * dest ){
    if(!src || !dest) return CWAL_RC_MISUSE;
    else if(!cwal_props_can(src) || !cwal_props_can(dest)) return CWAL_RC_TYPE;
    else return cwal_props_visit_kvp( src, cwal_kvp_visitor_props_copy, dest );
}





































char cwal_props_has_any( cwal_value const * c ){
    cwal_obase const * b = CWAL_VOBASE(c);
    return b && b->kvp ? 1 : 0;
}

cwal_size_t cwal_props_count( cwal_value const * c ){
    cwal_obase const * b = CWAL_VOBASE(c);

int cwal_buffer_reserve( cwal_engine * e, cwal_buffer * buf, cwal_size_t n ){
    if( !e || !buf ) return CWAL_RC_MISUSE;
    else if( 0 == n ){
        if(buf->mem){
            assert(buf->capacity);
            assert((cwal_size_t)-1 != buf->capacity);
            cwal_memchunk_add(e, buf->mem, buf->capacity);
            cwal_buffer_wipe_keep_self(buf);
            assert(0==buf->mem);
            assert(0==buf->capacity);
            assert(0==buf->used);
        }
        return 0;
    }
    else if( buf->capacity >= n ){
            return 0;
    }
    

    {/*CWAL_TYPE_DOUBLE*/0, sizeof(cwal_value)+sizeof(cwal_double_t)},
    {/*CWAL_TYPE_STRING*/ "Incl. string bytes plus NULs", sizeof(cwal_value)+sizeof(cwal_string)},
    {/*CWAL_TYPE_ARRAY*/ "Not incl. cwal_list memory", sizeof(cwal_value)+sizeof(cwal_array)},
    {/*CWAL_TYPE_OBJECT*/ 0, sizeof(cwal_value)+sizeof(cwal_object)},
    {/*CWAL_TYPE_FUNCTION*/ 0, sizeof(cwal_value)+sizeof(cwal_function)},
    {/*CWAL_TYPE_EXCEPTION*/ 0, sizeof(cwal_value)+sizeof(cwal_exception)},
    {/*CWAL_TYPE_NATIVE*/ "Not including (opaque/unknown) native memory", sizeof(cwal_value)+sizeof(cwal_native)},
    {/*CWAL_TYPE_BUFFER*/ "[2] Incl. total allocated buffer memory and non-Value buffers", sizeof(cwal_value)+sizeof(cwal_buffer_obj)},
    {/*CWAL_TYPE_HASH*/ "Not incl. cwal_list table memory.", sizeof(cwal_value)+sizeof(cwal_hash)},
    {/*CWAL_TYPE_SCOPE*/ "[3]", sizeof(cwal_scope)},
    {/*CWAL_TYPE_KVP*/ "Key/value pairs (obj. properties/hash entries)", sizeof(cwal_kvp)},
    {/*CWAL_TYPE_WEAK_REF*/ 0, sizeof(cwal_weak_ref)},
    {/*CWAL_TYPE_XSTRING*/ "Not incl. external string bytes", sizeof(cwal_value)+sizeof(cwal_string)+sizeof(char **)},
    {/*CWAL_TYPE_ZSTRING*/ "Incl. string bytes", sizeof(cwal_value)+sizeof(cwal_string)+sizeof(char **)},
    {/*CWAL_TYPE_UNIQUE*/ 0, sizeof(cwal_value)+sizeof(cwal_value*)},

        else v = cwal_value_prototype_get(e, v);
    }while(v);
    return NULL;
}

cwal_buffer * cwal_value_buffer_part( cwal_engine * e,
                                      cwal_value * v ){
    cwal_buffer_obj * f;
    do{
        if( (f = CWAL_BUFOBJ(v)) ) return &f->buf;
        else v = cwal_value_prototype_get(e, v);
    }while(v);
    return NULL;
}

cwal_native * cwal_value_native_part( cwal_engine * e,
                                      cwal_value * v,

        0/*native*/,\
        0/*typeID*/,\
        0/*finalize*/, \
        0/*rescope_children*/ \
        }
extern const cwal_native cwal_native_empty;

/** @internal
   Hash table Value type.
*/
struct cwal_hash {
    /**
       base MUST be the first member for casting reasons.
    */
    cwal_obase base;
    /**
       Array (hash table) of (cwal_kvp*) values.

#define cwal_hash_empty_m {            \
    cwal_obase_empty_m/*base*/,        \
    cwal_list_empty_m/*table*/,    \
    0/*hashSize*/\
    }
extern const cwal_hash cwal_hash_empty;


/** @internal

    An object-style representation for cwal_buffer. This type is
    strictly internal, not exposed to clients.
*/
struct cwal_buffer_obj {
    /**
       base MUST be the first member for casting reasons.
    */
    cwal_obase base;
    /**
       The buffer owned/tracked by this object.
    */
    cwal_buffer buf;
};
typedef struct cwal_buffer_obj cwal_buffer_obj;
#define cwal_buffer_obj_empty_m {\
    cwal_obase_empty_m/*base*/, \
    cwal_buffer_empty_m/*buf*/ \
}
extern const cwal_buffer_obj cwal_buffer_obj_empty;

/** @internal

    Internal impl of the weak reference class.
*/
struct cwal_weak_ref {
    void * value;
    cwal_type_id typeID;

       (You might also need to store buf.used and buf.capacity,
       depending on what you want to do with the memory.)
       
       When doing so, the memory must eventually be passed to free()
       to deallocate it.
    */
    unsigned char * mem;

    /**
       For internal use by cwal to differentiate between
       container-style buffers and non-container style without
       requiring a complete overhaul of the buffer API to make
       Container-type representations of them.

       Clients MUST NOT modify this. It is only non-NULL for buffers
       created via cwal_new_buffer() resp.  cwal_new_buffer_value(),
       and its non-NULL value has a very specific meaning. To
       reiterate: clients MUST NOT modify this.
    */
    void * self;
};


/**
   A typedef used by cwal_engine_type_name_proxy() to allow
   clients to hook their own type names into
   cwal_value_type_name().

   Returns non-0 (true) if c is of a type capable of
   containing per-instance properties, else 0 (false).

   The following value types will return true from
   this function:

   CWAL_TYPE_ARRAY, CWAL_TYPE_OBJECT, CWAL_TYPE_FUNCTION,
   CWAL_TYPE_EXCEPTION, CWAL_TYPE_NATIVE, CWAL_TYPE_HASH,
   CWAL_TYPE_BUFFER (as of 20141217).

   All others return false.

   Note that arrays can also contain integer-indexed properties and
   hashes can contain hashed properties.
*/
char cwal_props_can( cwal_value const * c );

/**
   An empty-initialized cwal_buffer object.

   ALWAYS initialize embedded-in-struct cwal_buffers by copying
   this object!
*/
#define cwal_buffer_empty_m {0/*capacity*/,0/*used*/,NULL/*mem*/, 0/*self*/}

/**
   An empty-initialized cwal_buffer object. ALWAYS initialize
   stack-allocated cwal_buffers by copying this object!
*/
extern const cwal_buffer cwal_buffer_empty;

    }\
  } (void)0


#define THIS_BUFFER                                             \
  cwal_buffer * self; ARGS_SE;                                  \
  if(!se) return CWAL_RC_MISUSE;                                \
  else if(!(self=cwal_value_buffer_part(args->engine, args->self))){ \
    return cwal_exception_setf( args->engine, CWAL_RC_TYPE,      \
                                "'this' is-not-a Buffer." );     \
  } (void)0


static int s2_cb_str_concat( cwal_callback_args const * args, cwal_value **rv ){
  if(!args->argc){

    */
    REMAX(UNIQUE,20)/* will end up being trumped by integer (32-bit)
                       and/or double (64-bit) */;
    REMAX(KVP,80) /* guaranteed individual recycler */;
    REMAX(WEAK_REF,30) /* guaranteed individual recycler */;
    REMAX(STRING,50) /* guaranteed individual recycler */;
    REMAX(EXCEPTION,3);
    REMAX(HASH,15) /* might also include: function, native, buffer */;
    REMAX(BUFFER,20) /* might also include: function, native, buffer, hash */ ;
    REMAX(XSTRING,20 /* also Z-strings, might also include doubles */);
    REMAX(NATIVE,20)  /* might also include: function, hash */;
    REMAX(DOUBLE,50)/* might also include z-/x-strings,
                       integer (64-bit), unique (64-bit)*/;
    REMAX(FUNCTION,50) /* might include: hash, native, buffer */;
    REMAX(ARRAY,30);
    REMAX(OBJECT,30) /* might include: buffer */;
    REMAX(INTEGER,80) /* might include: double, unique */;

#endif
  }
#undef REMAX

  if(0==strcmp("ta",pos)){
    App.memcap.maxTotalAllocCount = parse_cap_value(val, &rc)
      /* Caps the cumulative total number of memory allocations made
         by the engine. 0=disabled. OOM errors after this total is hit
         are not recoverable without resetting the engine. */
      ;
  }else if(0==strcmp("tb",pos)){
    App.memcap.maxTotalMem =  parse_cap_value(val, &rc)
      /* Caps the cumulative total memory allocated by the engine.
         0=disabled. Requires over-allocation so that reallocs can be
         properly tracked. OOM errors after this total is hit are not
         recoverable without resetting the engine. */
      ;
  }else if(0==strcmp("ca",pos)){
    App.memcap.maxConcurrentAllocCount = parse_cap_value(val, &rc)
      /* Max number of memory chunks the allocator should serve
         at a time. After this, it will fail until a chunk
         is freed. */
      ;
  }else if(0==strcmp("sb",pos)){

{
  int rc = 0;
  int i;
  char const * arg;
  int gotNoOp = 0;
  assert(!App.shellExitFlag);
  App.appName = argv[0];

#if 0
  /* just for one test... */
  App.memcap.maxTotalMem = 1 << 30;
#endif

  for( i = 1; i < argc; ++i ){
    cwal_size_t argLen;
    arg = argv[i];
    argLen = cwal_strlen(arg);
#define ARG(STR) else if(0==strcmp(STR, arg))
#define GET_FLAG_VAL(TGT) \
    if( (rc=check_flag_val(arg, (i<argc-1) ? argv[i+1] : 0)) ) break; \

    C(CWAL_INT_T_BITS);
    C(CWAL_VOID_PTR_IS_BIG);
    
#undef C
#define SO(T) total += sizeof(T); MARKER("sizeof(%s)=%u\n", #T, (unsigned int)sizeof(T))
    SO(void*);
    SO(cwal_array);
    SO(cwal_buffer);
    SO(cwal_callback_args);
    SO(cwal_double_t);
    SO(cwal_engine);
    SO(cwal_engine_vtab);
    SO(cwal_int_t);
    SO(cwal_kvp);
    SO(cwal_list);