unit: unit-proxy
unit2: UNIT_SCRIPTS_ALL:=$(filter unit2/%,$(UNIT_SCRIPT_LIST))
unit2: unit-proxy
.PHONY: unit-r
.PHONY: unit-rc
unit-r: S2SH.SHELL.FLAGS:=--a --R --C
unit-r: unit
unit-s: S2SH.SHELL.FLAGS:=--a -R -C --S
unit-s: unit
unit-rc: S2SH.SHELL.FLAGS:=--a --R --C
unit-rc: unit
unit-rsc: S2SH.SHELL.FLAGS:=--a --R --C --S
unit-rsc: unit
units:
	@for i in unit unit-r unit-rc unit-s unit-rsc; do \
		echo "Making $$i ..."; \
		$(MAKE) $$i || exit $$?; \
	done
include vg.make

    echo "Massified $test: try: ms_print ${msp} | less"
}

if [ -e f-s2sh ]; then
    # kludge for the libfossil source tree
    S2SH_ADD_FLAGS="${S2SH_ADD_FLAGS} -a"
fi
S2SHFLAGS="--a -R -S ${S2SH_ADD_FLAGS}"
# Reminder: some fsl modules rely on code set up by s2sh init script,
# so we cannot use the --a option in libfossil.
echo S2SHFLAGS=$S2SHFLAGS
for test in $list; do
    echo "Running require.s2 test: ${test}"
    outfile=${rdir}/${test}.test_out
    verbose "Output going to: $outfile"

CWAL_FMT_DOUBLE,
CWAL_FMT_STRING,
CWAL_FMT_STRING_SQL,
CWAL_FMT_CHAR,
CWAL_FMT_TYPENAME,
CWAL_FMT_BLOB,
CWAL_FMT_JSON,
CWAL_FMT_URLENCODE,
CWAL_FMT_URLDECODE,
CWAL_FMT_MAX
};
typedef enum cwal_format_t cwal_format_t;

enum cwal_format_flags {
CWAL_FMT_F_NONE = 0,
CWAL_FMT_F_SIGNED = 0x01,

                                  cwal_format_info * fi, cwal_value const * v );
static int cwal_format_part_basics( cwal_engine * e, cwal_buffer * tgt,
                                    cwal_format_info * fi, cwal_value const * v );
static int cwal_format_part_blob( cwal_engine * e, cwal_buffer * tgt,
                                  cwal_format_info * fi, cwal_value const * v );
static int cwal_format_part_json( cwal_engine * e, cwal_buffer * tgt,
                                  cwal_format_info * fi, cwal_value const * v );
static int cwal_format_part_urlenc( cwal_engine * e, cwal_buffer * tgt,
                                    cwal_format_info * fi, cwal_value const * v );
static int cwal_format_part_urldec( cwal_engine * e, cwal_buffer * tgt,
                                    cwal_format_info * fi, cwal_value const * v );

static const cwal_format_info CWAL_FORMAT_INFO[CWAL_FMT_MAX+1] = {
/*
  Maintenance reminder: these MUST be in the same order the entries
  are defined in cwal_format_t.
*/
/* {type,flags,precision,width,position,errMsg,pad,f} */

FMT(DOUBLE,double),
FMT(STRING,string),
FMT(STRING_SQL,sql),
FMT(CHAR,char),
FMT(TYPENAME,basics),
FMT(BLOB,blob),
FMT(JSON,json),
FMT(URLENCODE,urlenc),
FMT(URLDECODE,urldec),
#undef FMT
{CWAL_FMT_MAX, 0, 0, 0, 0,NULL,' ', NULL},
};

static const cwal_format_info cwal_format_info_empty = {
CWAL_FMT_UNKNOWN,
0/*flags*/,

            for( ; !rc && (width > n); --width){
                rc = cwal_buffer_append( e, tgt, &fi->pad, 1 );
            }
        }
        return rc;
    }
}

static int cwal_httpurl_needs_escape( int c )
{
  /*
    Definition of "safe" and "unsafe" chars
    was taken from:

    http://www.codeguru.com/cpp/cpp/cpp_mfc/article.php/c4029/
  */
  return ( (c >= 32 && c <=47)
           || ( c>=58 && c<=64)
           || ( c>=91 && c<=96)
           || ( c>=123 && c<=126)
           || ( c<32 || c>=127)
           );
}

int cwal_format_part_urlenc( cwal_engine * e,
                             cwal_buffer * tgt,
                             cwal_format_info * fi,
                             cwal_value const * v ){
    cwal_size_t slen = 0;
    char const * str = cwal_value_get_cstr(v, &slen);
    char ch;
    int rc = 0;
    cwal_size_t j = 0;
    char * bufpt = NULL;
    cwal_size_t const oldUsed = e->buffer.used;
    static char const * hex = "0123456789ABCDEF";
    if(!str){
        fi->errMsg = "URL encoding requires a String value.";
        return CWAL_RC_TYPE;
    }
    rc = cwal_buffer_reserve(e, &e->buffer, oldUsed + slen * 3 );
    if(rc) return rc;
    bufpt = (char *)(e->buffer.mem + oldUsed);
    ch = *str;
    for( ; !rc && ch; ch = *(++str) ){
        if(!cwal_httpurl_needs_escape(ch) ){
            bufpt[j++] = ch;
        }else{
            bufpt[j++] = '%';
            bufpt[j++] = hex[((ch>>4)&0xf)];
            bufpt[j++] = hex[(ch&0xf)];
        }
    }
    assert( (void *)bufpt == (void*)e->buffer.mem );
    rc = cwal_buffer_append(e, tgt, bufpt, j);
    e->buffer.used = oldUsed;
    e->buffer.mem[e->buffer.used] = 0;
    return 0;
}

/* 
   cwal_hexchar_to_int():

   For 'a'-'f', 'A'-'F' and '0'-'9', returns the appropriate decimal
   number.  For any other character it returns -1.
*/
static int cwal_hexchar_to_int( int ch )
{
  if( (ch>='0' && ch<='9') ) return ch-'0';
  else if( (ch>='a' && ch<='f') ) return ch-'a'+10;
  else if( (ch>='A' && ch<='F') ) return ch-'A'+10;
  else return -1;
}

static int cwal_is_xdigit( int ch ){
  return ('a'<=ch && 'f'>=ch)
    ? 1
    : (('A'<=ch && 'F'>=ch)
       ? 1
       : ('0'<=ch && '9'>=ch ? 1 : 0));
}

int cwal_format_part_urldec( cwal_engine * e,
                             cwal_buffer * tgt,
                             cwal_format_info * fi,
                             cwal_value const * v ){

    cwal_size_t slen = 0;
    char const * str = cwal_value_get_cstr(v, &slen);
    int rc = 0;
    char ch = 0, ch2 = 0;
    char xbuf[4];
    int decoded;
    if(!str){
        fi->errMsg = "URL decoding requires a String value.";
        return CWAL_RC_TYPE;
    }
    else if(!slen) return 0;
    else if(slen<3){
        /* can't be urlencoded */
        return cwal_buffer_append(e, tgt, str, slen);
    }
    ch = *str;
    while( !rc && ch ){
        if( ch == '%' ){
            ch = *(++str);
            ch2 = *(++str);
            if( cwal_is_xdigit((int)ch) &&
                cwal_is_xdigit((int)ch2) ){
                decoded = (cwal_hexchar_to_int( ch ) * 16)
                    + cwal_hexchar_to_int( ch2 );
                xbuf[0] = (char)decoded;
                xbuf[1] = 0;
                rc = cwal_buffer_append(e, tgt, xbuf, 1);
                ch = *(++str);
                continue;
            }
            else{
                xbuf[0] = '%';
                xbuf[1] = ch;
                xbuf[2] = ch2;
                xbuf[3] = 0;
                rc = cwal_buffer_append(e, tgt, xbuf, 3);
                ch = *(++str);
                continue;
            }
        }
        else if( ch == '+' ){
            xbuf[0] = ' ';
            xbuf[1] = 0;
            rc = cwal_buffer_append(e, tgt, xbuf, 1);
            ch = *(++str);
            continue;
        }
        xbuf[0] = ch;
        xbuf[1] = 0;
        rc = cwal_buffer_append(e, tgt, xbuf, 1);
        ch = *(++str);
    }
    return rc;
}

/**
   Parse the range [b,*e) as a java.lang.String.format()-style
   format string:

   %N$[flags][width][.precision][type]
*/
static int cwal_format_parse_info( char const * b, char const ** e,

          break;
      case 'x': fi->type = CWAL_FMT_INT_HEXLC;
          ++p;
          break;
      case 'X': fi->type = CWAL_FMT_INT_HEXUC;
          ++p;
          break;
      case 'r': fi->type = CWAL_FMT_URLENCODE;
          ++p;
          break;
      case 'R': fi->type = CWAL_FMT_URLDECODE;
          ++p;
          break;
      default:
          fi->errMsg = "Unknown format type specifier.";
          return CWAL_RC_RANGE;
    }
    switch(fi->type){
      case CWAL_FMT_URLENCODE:
      case CWAL_FMT_URLDECODE:
          if(fi->width){
              fi->errMsg = "Conversion does not support width.";
              return CWAL_RC_MISUSE;
          }
          /* fall through */
      case CWAL_FMT_INT_DEC:
      case CWAL_FMT_INT_HEXLC:
      case CWAL_FMT_INT_HEXUC:
          if(fi->precision && cwalFormatNoPrecision != fi->precision){
              fi->errMsg = "Conversion does not support precision.";
              return CWAL_RC_MISUSE;
          }
          break;
      case CWAL_FMT_CHAR:
          if(fi->precision<0){
              fi->errMsg = "Character precision (repetition) may not be negative.";
              return CWAL_RC_MISUSE;
          }
          break;
      default:
          break;
    }
    *e = p;
    fi->f = CWAL_FORMAT_INFO[fi->type].f;
    return 0;
}

    assert((st->size >= op->arity)
           || (op->assoc>0 && op->arity==1 /* unary +, -, ~ */));
#endif
    if(st->size < op->arity){
      rc = s2_engine_err_set(se, CWAL_RC_RANGE,
                             "Not enough operands on the stack.");
    }else{














      rc = op->call(op, se, op->arity, &rv);




      popArgCount = op->arity;
    }
  }else{
#if 1
    assert(!"not possible");
#else
    /* Variadic operator ... */
    s2_stoken * t = se->st.vals.top;
    int i = 0;
    char doBreak = 0;
    /* Count how the arguments by looking for
       a S2_T_MarkVariadicStart token. */
    for( ; t && !doBreak && (i <st->size); t = t->next ){

        s2_stoken * variadicCheck = s2_engine_peek_token(se);
        assert(variadicCheck);
        assert(S2_T_MarkVariadicStart == variadicCheck->ttype);
      }
      s2_engine_pop_token( se, 0 ) /* S2_T_MarkVariadicStart */;
      popArgCount = i + 1 /* variadic marker */;
    }
#endif
  }
  if(!rc){
    assert( st->size == (oldStackSize - popArgCount) );
    if(st->size != (oldStackSize - popArgCount)){
      rc = s2_engine_err_set(se, CWAL_RC_MISUSE,
                             "Unexpected stack size after "
                             "running operator '%s'\n",

  return se ? se->e : 0;
}

s2_scope * s2_scope_current( s2_engine * se ){
  return (se && se->e) ? se->currentScope : 0;
}


/* defined in s2_eval.c */
void s2_dotop_state( s2_engine * se, cwal_value * self,
                     cwal_value * lhs, cwal_value * key );

int s2_scope_push( s2_engine * se, s2_scope * tgt ){
  int rc = 0;
  cwal_scope * pScope = &tgt->scope;
  assert(se);
  assert(se->e);
  assert(tgt);
  assert(!tgt->parent);
  /* s2_dotop_state(se, 0, 0, 0); */
  rc = cwal_scope_push( se->e, &pScope );
  if(!rc){
    /* assert(tgt->scope.parent); */
    if((int)tgt->scope.level > se->metrics.maxScopeDepth){
      se->metrics.maxScopeDepth = (int)tgt->scope.level;
    }
    tgt->parent = se->currentScope;
    se->currentScope = tgt;
    se->sguard = &tgt->sguard;
    /* MARKER(("pushed %p\n",(void const *)tgt));  */

    /* Make sure that ternary depth is not counted across scopes. We
       need a similar hack for non-scope-pushing blocks, now that i
       think about it. */
    s2_engine_subexpr_save(se, &tgt->saved);
  }else{
    assert(!"This can't happen if the args are valid!");
    rc = CWAL_RC_ASSERT;
  }
  return rc;
}

int s2_scope_pop2( s2_engine * se, cwal_value * upScopeThis ){
  int rc;
  s2_scope * sc = se->currentScope;
  assert(se);
  assert(se->e);
  assert(se->e->current);
  s2_dotop_state(se, 0, 0, 0)
    /* necessary to keep from holding unpropagated,
       stale refs */;
  if(sc==&se->topScope){
    upScopeThis = 0 /* cannot propagate this */;
    cwal_exception_set(se->e, 0);
    s2_propagating_set(se, 0);
  }
  assert(se->e->current == &sc->scope);
  if(upScopeThis){

       popping the scope don't like this at all.*/
    else{
      s2_engine_sweep(se);
    }
#endif
  }else{
    assert(!"This can't happen if the args are valid!");
    rc = CWAL_RC_ASSERT;
  }
  return rc;
}

int s2_scope_pop( s2_engine * se ){
  return s2_scope_pop2(se, 0);
}

  }else{
    *rv = destV;
    cwal_value_unhand(destV);
  }
  return rc;
}

int s2_ctor_method_set( s2_engine * se, cwal_value * container, cwal_function * method ){
  if(!se || !container || !method) return CWAL_RC_MISUSE;
  else if(!cwal_props_can(container)) return CWAL_RC_TYPE;
  else{
    return s2_set_with_flags_v( se, container, se->cache.keyCtorNew,
                                cwal_function_value(method),
                                CWAL_VAR_F_CONST | CWAL_VAR_F_HIDDEN );
  }
}

int s2_ctor_callback_set( s2_engine * se, cwal_value * container, cwal_callback_f method ){
  int rc;
  cwal_function * f;
  cwal_value * fv;
  if(!se || !container || !method) return CWAL_RC_MISUSE;
  else if(!cwal_props_can(container)) return CWAL_RC_TYPE;
  fv = s2_new_callback(se, method);
  f = fv ? cwal_value_get_function(fv) : NULL;
  if(f){
    cwal_value_ref(fv);
    rc = s2_ctor_method_set( se, container, f );
    cwal_value_unref(fv);
  }else{
    rc = CWAL_RC_OOM;
  }
  return rc;
    
}

char s2_scope_is_newing(s2_engine * se){
  return (&se->currentScope->scope
          == se->e->current
          /* ^^^ reminder: cwal_scope_push() may add scopes without s2
             seeing them. */
          && se->currentScope->newingThis)
    ? 1 : 0;
}



int s2_ctor_fetch( s2_engine * se, s2_ptoker const * pr,
                   cwal_value * operand,
                   cwal_function **rv,
                   int errPolicy ){
  cwal_value * vtor = 0;

   key with (s2_keyword **) on s2_keyword::word.
*/
static int s2_keyword_cmp(void const * key, void const * kw){
  s2_keyword const * k = ((s2_keyword const *)key);
  s2_keyword const * w = *((s2_keyword const **)kw);
  if(k->wordLen == w->wordLen) return memcmp(k->word, w->word,
                                             (size_t)k->wordLen);
#if !defined(NDEBUG)
  else if(!w->word){
    assert(!"sentinel gets trimmed from the list length");
    return 1 /* sentinel entry */;
  }
#endif
  else if(k->word[0] != w->word[0]) return (int)k->word[0] - (int)w->word[0];
  else{
    int const len = (k->wordLen<w->wordLen) ? k->wordLen : w->wordLen;
    int const cmp = memcmp(k->word, w->word, (size_t)len);
    return cmp ? cmp : ((len==k->wordLen) ? -1 : 1);
  }
}

      /* MARKER(("opErrPos=%p\n", (void const *)se->opErrPos)); */
      rc = s2_throw_err_ptoker(se, pr ? pr : se->currentScript);
      break;
  }
  return rc;

}

/**
   Sets up se's internals so that it knows the most recent
   dot-op self/lhs/key. If self is not NULL then self is
   considered to be "this" in the corresponding downstream
   handling (i.e. it's a property access which binds "this"), else
   it does not. self is always lhs or 0.

   Pass all 0's to reset it.
*/
void s2_dotop_state( s2_engine * se, cwal_value * self,
                     cwal_value * lhs, cwal_value * key ){
    
#if 0
    se->dotOpSelf = self;
    se->dotOpLhs = lhs;
    se->dotOpKey = key;
#else
    /* Reminder the validity checks here point to, essentially, misuse
       in s2, where we've not cleaned up this state before it goes
       stale.

       A potential future problem is vacuuming-up of these pointers,
       which case we can't solve without a per-s2_scope
       array/container to hold these and make them vacuum-proof.
    */
    cwal_value * oldSelf = se->dotOpSelf;
    cwal_value * oldLhs = se->dotOpLhs;
    cwal_value * oldKey = se->dotOpKey;
    /**
       Assert that all of them appear to still be valid references
       (because it's easy to mess that up). These assertions are not
       guaranteed to trigger in all error cases, but they catch the
       most common one that we've prematurely unref'd a value and he
       have a pointer to its cwal-side recycling bin.
    */
    if(oldSelf){
        assert( cwal_value_refcount(oldSelf)
                || cwal_value_is_builtin(oldSelf) );
    }
    if(oldLhs){
        assert( cwal_value_refcount(oldLhs)
                || cwal_value_is_builtin(oldLhs));
    }
    if(oldKey){
        assert( cwal_value_refcount(oldKey)
                || cwal_value_is_builtin(oldKey) );
    }
    /**
       Because any of self/lhs/key can refer to or contain/own any
       other, as well as be the same instance of oldSelf/oldLhs/oldKey
       (in any combination!), we have to ref them all before we unref
       any of them.
    */
    if(self) cwal_value_ref(self);
    if(lhs) cwal_value_ref(lhs);
    if(key) cwal_value_ref(key);

    se->dotOpSelf = self;
    se->dotOpLhs = lhs;
    se->dotOpKey = key;

    if(oldSelf) cwal_value_unref(oldSelf);
    if(oldLhs) cwal_value_unref(oldLhs);
    if(oldKey) cwal_value_unref(oldKey);
#endif
}

/**
   Internal helper for s2_eval_expr().

   Possibly processes pending operators in se's stack, depending on op
   and its precedence in relation to the operator (if any) to the
   left. Returns 0 on success (which includes it doing nothing of

      /* se->currentScript = oldScript; */
      s2_engine_subexpr_restore(se, &save);
      if(sub.errPos) pr->errPos = sub.errPos;
      return s2_check_interrupted(se, rc);
    }
  }
}

/**
   Like s2_eval_current_sub(se, pr, 0, rv), but pushes a scope
   and sets a local "this" variable to the self value.

   s2_ptoken_is_true_squiggly(&pr->token) MUST be true: this function
   assert()s it (only to simplify skip-mode handling, though we could
   extend it to handle other block-level constructs as well).

   ACHTUNG: self must not be a temporary value: it MUST have a ref
   or this will kill it. Exception: in skip-mode, self is not
   evaluated.
*/
static int s2_eval_current_sub_with_this( s2_engine * se, s2_ptoker * pr,
                                          cwal_value * self,
                                          cwal_value **rv ){
  assert( s2_ptoken_is_true_squiggly(&pr->token) );
  if(se->skipLevel){
    if(rv) *rv = cwal_value_undefined();
    return 0;
  }else{
    s2_scope sc = s2_scope_empty;
    cwal_value * xrv = 0;
    int rc = s2_scope_push(se, &sc);
    if(rc) return rc;
    rc = s2_var_decl_v(se, se->cache.keyThis, self, 0);
    if(!rc){
      rc = s2_eval_current_sub(se, pr, 0, rv ? &xrv : NULL);
    }
    s2_scope_pop2(se, rc ? 0 : xrv);
    if(!rc && rv) *rv = xrv
                    /* will be NULL on an empty expr except in skip-mode */;
    /*
      TODO: centralize this handling somewhere else? We should probably
      add it to object/array literals, etc.
    */
    if(rc){
      s2_keyword const * kword = 0;
      switch(rc){
        case CWAL_RC_RETURN:
          kword = s2_ttype_keyword(S2_T_KeywordReturn);
          assert(kword);
          s2_propagating_set(se, 0);
          break;
        case CWAL_RC_BREAK:
          kword = s2_ttype_keyword(S2_T_KeywordBreak);
          assert(kword);
          s2_propagating_set(se, 0);
          break;
        case CWAL_RC_CONTINUE:
          kword = s2_ttype_keyword(S2_T_KeywordContinue);
          assert(kword);
          break;
        default: break;
      }
      if(kword){
        rc = s2_err_ptoker(se, pr, CWAL_SCR_SYNTAX,
                           /* if we pass on the same rc, error reporting
                              won't DTRT. */
                           "Unhandled '%s' in script block.",
                           kword->word);
      }
    }
    return rc;
  }
}


int s2_eval_expr( s2_engine * se, s2_ptoker * st,
                  int evalFlags,
                  cwal_value ** rv){
  return s2_eval_expr_impl(se, st, 0, evalFlags, rv);
}

/**
   Expects pr to be a comma-separated list of expressions, until its
   EOF. Empty expressions and a stray trailing comma are not
   allowed. Evaluates each token and appends it to dest. Returns 0 on
   success. Some errors are thrown as exceptions, but syntax errors
   are not and propagated errors might not be exceptions.
*/
static int s2_eval_to_array( s2_engine * se, s2_ptoker * pr, cwal_array * dest ){
  int rc = 0;
  s2_op const * opComma = s2_ttype_op(S2_T_Comma);
  s2_ptoken prev = s2_ptoken_empty;
  char const * errMsg = 0;
  assert(!se->skipLevel);
  /* s2_dotop_state(se, 0, 0, 0); */
  while( !rc ){
    s2_ptoken next = s2_ptoken_empty;
    cwal_value * v = 0;
    if( (rc = s2_eval_expr_impl( se, pr, opComma, 0, &v)) ) break;
    if(!v){
      if(s2_ptoker_is_eof(pr)){
        if(S2_T_Comma==prev.ttype){

  cwal_value * fv = 0;
  cwal_value * vSelf = 0;
  s2_scope _SCOPE = s2_scope_empty;
  s2_scope * scope = &_SCOPE;
  s2_strace_entry strace = s2_strace_entry_empty;
  cwal_function * theFunc;
  s2_func_state * fst = 0;

  /* cwal_value * vKey; */
  assert(S2_T_ParenGroup==pr->token.ttype);

  if(!se->skipLevel){
    rc = s2_scope_push(se, scope);
    if(rc) return rc;
  }

  if(rv) *rv = 0;
  /* Check if this is a FUNC() or OBJ.FUNC() call... */
  opTok = s2_engine_peek_op(se);
  op = opTok ? s2_ttype_op( opTok->ttype ) : 0;

  /*
    To consider: if dot is not a dot op but se->dotOpLhs
    is set, then some LHS (possibly a (subexpr)) possibly

      assignment ops as well, so that (x.y)=3 could work.
    */
    /* MARKER(("Possibly stealing a 'this'\n")); */
    assert(!fv);
    assert(!vSelf);
    vSelf = se->dotOpSelf;
    /* s2_dump_val(vSelf, "se->dotOpThis"); */
    if(vSelf) cwal_value_ref(vSelf);
    fv = s2_engine_pop_value(se) /* presumably a dot-op result */;
    assert(fv);

    cwal_value_ref( fv );
  }else{
    fv = s2_engine_pop_value(se) /* hopefully a function */;
    cwal_value_ref( fv );
  }
  s2_dotop_state(se, 0, 0, 0);

  /* In skip mode, we're done. We had to get the values off the stack,
     though, so we couldn't do this first. */
  if(se->skipLevel>0){
    if(rv) *rv = cwal_value_undefined();
    goto end;
  }

  rc = s2_strace_push_pos(se, pr, origin.begin, &strace )
    /* we have to do this fairly late so that the
       the (still pending) call doesn't confuse the
       the trace. */

  if(fst && (fst->flags & S2_FUNCSTATE_F_EMPTY_BODY
             && fst->flags & S2_FUNCSTATE_F_EMPTY_PARAMS)){
      /* If a script function has neither parameters nor a body, we
         don't have to do any of the following work. However, in order
         to get fst, we have to get theFunc, which requires setting up
         a scope and all that.
      */
    if(rv) *rv = cwal_value_undefined();
  }else{
    /* Process the args and call() the func... */
    s2_ptoker sub = s2_ptoker_empty;
    cwal_value * arV = 0;
    cwal_array * oldArgV;
    s2_func_state const * oldScriptFunc = se->currentScriptFunc;
    cwal_array * ar = cwal_new_array(se->e);

         use/abuse it in the docs.
       */;
    se->currentScriptFunc = oldScriptFunc;
    assert(!se->callArgV && "Gets unset via the post-call() hook");
    se->callArgV = oldArgV;
    /* assert(0==oldArgV); */
    cwal_value_make_vacuum_proof(arV, 0);
    if(!rc && rv && *rv){
        cwal_value_ref(*rv);
    }
    cwal_value_unref(arV);




  }
  end:
  /* s2_dotop_state( se, 0, 0, 0 ); */
  rc = s2_check_interrupted(se, rc);
  switch(rc){
    case 0:
      if( rv && !*rv ) *rv = cwal_value_undefined();
      break;
    case CWAL_RC_BREAK:
    case CWAL_RC_CONTINUE:
      assert(se->err.code);
      rc = s2_throw_err(se, 0, s2_ptoker_name_first(pr, 0), 0, 0);
      break;
#if 0
    case CWAL_RC_RETURN:
      rc = 0;
      if(rv){
          *rv = s2_propagating_take(se);
          assert(*rv);
          cwal_value_ref(*rv);
      }
      else cwal_propagating_set(se, NULL);
      break;
#endif
    case CWAL_RC_EXCEPTION:
      s2_exception_add_script_props(se, pr)
        /* Needed to decorate calls to native functions. */;
      /* fall through */
    case CWAL_RC_OOM:
    case CWAL_RC_EXIT:
    case CWAL_RC_FATAL:
    case CWAL_RC_INTERRUPTED:
    case CWAL_RC_ASSERT:
      /* do we want assertion errors to translate to exceptions
         if they go up the call stack? */
      if(rv) *rv = 0;
      break;
    default:
      if(rv) *rv = 0;
      if(se->err.code){
        /* Likely a syntax-related error pending */
        rc = s2_throw_err(se, 0, 0, 0, 0);
      }else{
#if 1
        rc = s2_throw_ptoker(se, pr, rc,
                             "Function call returned non-exception "

#endif
      }
      break;
  }
  if(strace.pr){
    s2_strace_pop(se);
  }
  if(!rc && rv && *rv){
      assert(cwal_value_refcount(*rv)>0 /* we ref'd it above */
             || cwal_value_is_builtin(*rv));
  }
  if(vSelf) cwal_value_unref(vSelf);
  if(fv) cwal_value_unref(fv);
  if(scope->parent){



    assert(scope == se->currentScope);
    s2_scope_pop2(se, rc ? 0 : (rv ? *rv : 0));
    assert(scope != se->currentScope);
  }
  if(!rc && rv && *rv){
      assert(cwal_value_refcount(*rv)>0 /* we ref'd it above */
             || cwal_value_is_builtin(*rv));
      cwal_value_unhand(*rv);
  }
  return rc;
}

/**
   If true, s2_eval_expr_impl() internally uses a local
   array to keep references active and vacuum-proofed.

   HOLY COW... when recycling is disabled, this causes alloc counts
   and total (not peak) memory to skyrocket (nearly 60% increase in
   the 20160131 unit tests). With recycling on alloc counts go up by
   roughly 3% but peak memory goes up anywhere from 1k to 7k (as the
   recycling bins accumulate) in those same unit tests.

   After changing this, MAKE SURE to run all the valgrind tests with
   various combinations of recycling and string interning!!!
*/
#define EVAL_USE_HOLDER 0
#if EVAL_USE_HOLDER
static int s2_eval_hold(s2_engine * se, cwal_array * tgt,
                        cwal_value * v){
  return cwal_value_is_builtin(v)
    ? 0
    : cwal_array_append(tgt, v);
}
#endif

/**
   Internal impl of s2_eval_expr().

   If fromLhsOp is not 0, this call is assumed to be the RHS of that
   operator. Upon encountering an operator of that precedence or less,
   that operator is put back into the tokenizer and evaluation

  int totalValCount = 0 /* just for some error checks */;
  int nextTokenFlags = /* The s2_next_token() flags for the very next token */
    (evalFlags & S2_EVAL_NO_SKIP_FIRST_EOL/* fromLhsOp && S2_T_RHSEvalNoEOL!=fromLhsOp->id */)
    ? S2_NEXT_NO_SKIP_EOL
    : 0;
  s2_scope _SCOPE = s2_scope_empty /* cwal stack, if (flags&S2_EVAL_PUSH_SCOPE) */;
  s2_scope * scope = &_SCOPE;
#if EVAL_USE_HOLDER
  cwal_array * holder = 0 /* holds pending expression values to keep
                             them referenced and vacuum-safe. */;
#endif
#ifndef NDEBUG
  /* Just for sanity checking */
  int const oldValCount = se->st.vals.size;
  int const oldOpCount = se->st.ops.size;
#endif
  if( se->flags.interrupted ) return se->flags.interrupted;
  else if(!fromLhsOp) s2_dotop_state(se, 0, 0, 0);
  if(S2_EVAL_PUSH_SCOPE & evalFlags){
    MARKER(("Oh, this scope-pushing bit in eval_expr_impl IS used.\n"));
    assert(!"This isn't used, is it?");
    rc = s2_scope_push(se, scope);
    if(rc) return rc;
    assert(scope->parent);
    assert(0==se->sguard->sweep);

  if(++se->metrics.subexpDepth > se->metrics.peakSubexpDepth){
    se->metrics.peakSubexpDepth = se->metrics.subexpDepth;
  }

  st->errPos = 0;

#if EVAL_USE_HOLDER
#define eval_hold(V) if( holder && (rc = s2_eval_hold(se, holder, (V)))) goto end
#else
#define eval_hold(V) (void)0
#endif

#if EVAL_USE_HOLDER
  /**
    Reminder to self: we have to explicitly ref/unhand
    se->dotOpSelf/dotOpLhs/dotOpKey to keep them alive
    (i.e. to keep holder from cleaning them up) after this op
    returns (needed by 'unset' and possibly others).
  */
  holder = cwal_new_array(se->e);
  if(!holder){
    rc = CWAL_RC_OOM;
    goto end;
  }else{
    cwal_value * hv = cwal_array_value(holder);
    /* ++se->sguard->vacuum; */
    cwal_value_rescope(&se->currentScope->scope, hv)
        /* in case a cwal-level API has pushed a scope without us
         knowing */;
    cwal_value_ref(hv);
    cwal_value_make_vacuum_proof(hv,1);
  }
#endif
/* ^^^^ EVAL_USE_HOLDER */

  /* if(rv) *rv = 0; */
  if((S2_EVAL_PRE_SWEEP & evalFlags)
     && !fromLhsOp
     && !se->st.vals.size
     && !se->st.ops.size
     ){
    /* MARKER(("SWEEPING from eval_expr_impl\n")); */

          break;
        }
        lhs = 0;
        rc = s2_eval_ternary(se, st, &lhs);
        if(rc) break;
        else{
          assert(lhs);
          eval_hold(lhs);
          continue;
        }
      }
      case S2_T_Identifier:{
        /* If an Identifier is the RHS of a dot operator, change its
           type to PropertyKey so that identifier expansion is not
           done for this property access. The raw token bytes

        break;
    }
    if(se->flags.interrupted && !rc) rc = se->flags.interrupted;
    if(rc || doBreak) break;

    op = s2_ttype_op( pt.ttype );
    if(op && !fromLhsOp){
      s2_dotop_state( se, 0, 0, 0 )
        /* If these get stale, Very Bad Things happen in the cwal core
             (assertions, if we're lucky). */;
      /* se->dotOpId = 0 */ /* keep Other Bad Things from happening */;
      /* Reminder: this means that assignment ops cannot tell
         which dot-like op triggered them. */
    }

            if(S2_T_OpOr3 != pt.ttype && S2_T_OpElvis != pt.ttype){
              /*
                Clean this up:
                s2> x = 0; for( var i = 0; i < 100; (i++, x++ || 1, ++i) );
                MARKER: s2.c:296:s2_engine_sweep():	Swept up 48 value(s) in sweep mode
              */
              cwal_refunref(lhs);
            }else{
              eval_hold(lhs);
            }
            continue;
          }
        }/*if(shortIt)*/
        break;
      }/* end &&, ||, ||| */
      case S2_T_Identifier:{

            s2_op const * kOp = s2_ttype_op(kword->id);
            assert(kOp);
            pt.ttype = kword->id;
            op = kOp;
          }else{
            pt.ttype = st->token.ttype = kword->id;
            rc = kword->call(kword, se, st, &tVal);
            s2_dotop_state( se, 0, 0, 0 );
            rc = s2_check_interrupted(se, rc);
            if(!rc && !tVal){
              st->errPos = pt.begin;
              rc = s2_err_ptoker(se, st, CWAL_RC_ASSERT,
                                 "Keyword '%s' eval'd to <NULL>, "
                                 "which is currently verboten",
                                 kword->word);

              rc = s2_throw_ptoker(se, st, CWAL_RC_NOT_FOUND,
                                   "Could not resolve identifier "
                                   "'%.*s'",
                                   tlen, pt.begin);
            }
          }else if(prevOp && s2_ttype_is_identifier_prefix(prevOp->id)){
            /* Previous token was prefix ++/-- (or similar) */

            if(!s2_next_is_dotish(se, st)){
              rc = s2_ptoken_create_value(se, &pt, &tVal);
              if(!tVal){
                assert(rc);
                /* rc = CWAL_RC_OOM; */
              }
            }else{
              pt.ttype = S2_T_Value;              
            }










          }else if(s2_next_wants_identifier(se, st)){
            /* Required so that assignment gets the identifier's string value,
               but we let it get validated above so that we get precise
               error location info. We just hope that pending ops don't
               invalidate it (potential corner case?).
            */
            tVal = 0;

          break;
        }
#endif
        assert(pt.adjBegin);
        assert(pt.adjEnd);
        assert(pt.adjEnd >= pt.adjBegin);
        if(S2_T_ParenGroup==pt.ttype){
          doBreak = 0;
          if(s2_looks_like_fcall(se, st,
                                 (S2_EVAL_STOP_AT_CALL & evalFlags),
                                 prevOp, &rc) && !rc){
            if(S2_EVAL_STOP_AT_CALL & evalFlags){
              doBreak = 1;
            }else{
              /* MARKER(("Looks like func call? rc=%s prevOp=%s\n",
                 s2_rc_cstr(rc), prevOp?prevOp->sym:"<NULL>")); */
              rc = s2_eval_fcall(se, st, &tVal);
            }
            break;
          }
          else if(rc) break;
        }
        if(pt.adjEnd > pt.adjBegin){
          /* In order to know whether it's really empty, and fail
             consistently across both skipping and non-skipping mode,
             we have to parse the subexpr regardless of skip level
             :/.
          */

        if((se->flags.traceStack>0) && (S2_T_Identifier==pt.ttype)){
          MARKER(("Identifier token: %.*s\n", tlen, pt.begin));
        }
        vtok = s2_engine_push_tv(se, pt.ttype, tVal);
        if(!vtok){
          rc = CWAL_RC_OOM;
        }else{
          eval_hold(tVal);
          ++totalValCount;
          vtok->srcPos = pt.begin;
          if(se->skipLevel>0){
#if 1
            /* s2_dump_val(tVal, "what is this"); */
            assert((tVal == cwal_value_undefined())
                   && "current internal convention for "
                   "skip-mode evaluation was violated");
#endif
          }
        }
      }/*if(!rc)*/
    }/*if op else value */
  }/* for-each token */

  if(rc && !st->errPos){
    st->errPos = (pt.begin && (pt.begin != pt.end)) ? pt.begin : prevTok.begin;
  }else if(!rc){
    assert(capBegin);

      s2_dump_val(xrv, "eval_expr result");
    }
    if(rv) *rv = xrv;
    else cwal_refunref(xrv);
  }

  end:
#undef eval_hold
  if(rc){
    rc= 1 ? rc : 0 /* put breakpoint here (the ?: is to avoid
                      assignment-to-self warning from clang).*/;
  }
  /* Clean up... */
  if(!fromLhsOp){
    /* We must clear these avoid picking them up after they're stale.
       However, they's needed by, e.g. (unset x.y).
    */
    s2_dotop_state( se, 0, 0, 0 );
  }
  if(rc && !se->err.code && st->errMsg
     && (CWAL_RC_EXCEPTION!=rc)){
    /* Error from the tokenizer. */
    rc = s2_err_ptoker(se, st, rc, 0);
  }

  rc = s2_rv_maybe_accept(se, scope->scope.parent /* 0 is okay */, rc, rv);


#if EVAL_USE_HOLDER
  if(holder){
    cwal_value * hv = cwal_array_value(holder);
    /* --se->sguard->vacuum; */
    cwal_value_make_vacuum_proof(hv, 0);
    assert(1==cwal_value_refcount(hv));
    if(!rc && rv) cwal_value_ref(*rv);
    if(se->dotOpSelf) cwal_value_ref(se->dotOpSelf);
    if(se->dotOpLhs) cwal_value_ref(se->dotOpLhs);
    if(se->dotOpKey) cwal_value_ref(se->dotOpKey);
    cwal_value_unref(hv);
    holder = 0;
    if(!rc && rv) cwal_value_unhand(*rv);
    if(se->dotOpSelf) cwal_value_unhand(se->dotOpSelf);
    if(se->dotOpLhs) cwal_value_unhand(se->dotOpLhs);
    if(se->dotOpKey) cwal_value_unhand(se->dotOpKey);
  }
#endif
/* ^^^^ EVAL_USE_HOLDER */

  if(!evalIt){
    assert(se->skipLevel==1+oldSkipLevel);
    se->skipLevel = oldSkipLevel;
  }
  if(ownStack){
    s2_engine_stack_swap(se, &priorStack);
    s2_estack_clear(se, &priorStack, 1);

  }else{
    if(!scope->parent){
      --se->sguard->sweep;
    }
  }
  return rc;
}

#undef EVAL_USE_HOLDER

int s2_eval_buffer( s2_engine * se,
                    char newScope,
                    char const * name,
                    cwal_buffer const * buf,
                    cwal_value **rv ){
  return s2_eval_cstr( se, newScope, name,

      else if(!se->skipLevel){
        if(!se->dotOpLhs || !se->dotOpKey){
          pr->errPos = ident.begin;
          return s2_throw_ptoker( se, pr, CWAL_SCR_SYNTAX,
                                  "Illegal RHS for %s operation.",
                                  kw->word);
        }
        /* cwal_value_ref(se->dotOpLhs); */
        /* cwal_value_ref(se->dotOpKey); */
        /* Do we want to support: unset hash # key? */
        rc = s2_handle_set_result(se, pr,
                                  s2_set_v( se, se->dotOpLhs, se->dotOpKey, 0 ));
        /* cwal_value_unhand(se->dotOpLhs); */
        /* cwal_value_unhand(se->dotOpKey); */
        s2_dotop_state(se, 0, 0, 0);
        if(rc) return rc;
      }
      if(s2_ptoker_next_is_ttype(se, pr, 0, S2_T_Comma, 1)){
        goto next_part;
      }
      break;
    }
    default:

    */
    s2_engine * se = s2_engine_from_state(args->engine);
    se->callArgV = 0 /* Make sure this doesn't propagate through to a script
                        func that this native function calls. Been
                        there, debugged that! */;
    /* MARKER(("Not a script function (or empty function). Not injecting argv/this.\n")); */
    s2_dotop_state( se, 0, 0, 0 ) /* necessary!!! */;
    return 0;
  }
#if 0
  else if(cwal_scope_search(args->scope, 0, "argv", 4, NULL)){
    /* argv is already set. This is (we hope) a callback which itself
       passed on a call via cwal_function_call_in_scope(). Do we have
       a better mechanism for avoiding a duplicate init in that case?

    cwal_scope * s = args->scope;
    s2_engine * se = fs ? fs->se : s2_engine_from_state(args->engine);
    cwal_value * v;
    assert(fs && "Currently always true here.");
    assert(se);
    calleeV = cwal_function_value(args->callee);
    assert(calleeV);
    s2_dotop_state( se, 0, 0, 0 ) /* necessary!!! */;

    if(!fs /* native call, which _might_ eval script code */
       ||
       !(/* empty function */
         fs->flags & S2_FUNCSTATE_F_EMPTY_BODY
         && fs->flags & S2_FUNCSTATE_F_EMPTY_PARAMS)
       ){

  /* s2_func_state * fs = (s2_func_state *)cwal_args_callee_state(args, &s2_func_state_empty); */
  assert(se);
  /* MARKER(("Callback post-hook\n")); */
  /* s2_dump_val(cwal_array_value(se->callArgV), "se->callArgV"); */
  se->callArgV = 0
    /* required for certain calling combinations of native vs script funcs
       to work. */;

  /**
     Reminder to self:

     We can potentially use this callback to communicate certain
     non-zero results back up the call chain, e.g. CWAL_RC_OOM could
     be stuffed into a dedicated error code propagation slot (the plan
     is to consolidate return/exit/etc. with the

  if(!rc){
    cwal_value * ctorResult = 0 /* the ctor result */;
    cwal_array * oldArgV = se->callArgV
      /* not _actually_ sure this is needed, but there might
         be a corner case or two without it. */;
    se->callArgV = args;
    if(args) cwal_value_ref(cwal_array_value(args));


    sc.newingThis = newThis;


    rc = args
      ? cwal_function_call_array(&sc.scope, ctor,
                                 newThis, &ctorResult, args)
      : cwal_function_call_in_scope(&sc.scope, ctor,
                                    newThis, &ctorResult, 0, NULL)
      ;


    sc.newingThis = 0;
    assert(!se->callArgV && "callArgV Gets unset via the call() hook(s)");
    se->callArgV = oldArgV;
    if(args) cwal_value_unhand(cwal_array_value(args));
    if(!rc && ctorResult
       && newThis != ctorResult
       && cwal_value_undefined() != ctorResult){
      /*

  s2_ptoken tIdent = s2_ptoken_empty;
  cwal_size_t idLen;
  cwal_value * operand = 0;
  cwal_function * ctor = 0;
  cwal_array * args = 0;
  cwal_value * vargs = 0;
  s2_ptoker ptArgs = s2_ptoker_empty;
  s2_ptoken tTail = s2_ptoken_empty;
  s2_ptoken tWithThis = s2_ptoken_empty;
  s2_strace_entry strace = s2_strace_entry_empty;
  s2_ptoken const origin = pr->token;
  cwal_value * xrv = 0;
  assert(rv);
  rc = s2_strace_push_pos(se, pr, origin.begin, &strace )
    /* treat new() like a function for stack trace purposes
       or exceptions may contain far-off location info.
    */;
  if(rc) return rc /* after this, no more 'return', only goto end */;
  while(s2_is_space(*pr->token.end)){
    /* Cosmetic workaround! */

  else if(operand) cwal_value_ref(operand);
  if(!operand || S2_T_ParenGroup!=pr->token.ttype){
    rc = s2_err_ptoker(se, pr, CWAL_SCR_SYNTAX,
                       "Expecting EXPR(...) after '%s'.",
                       kw->word);
    goto end;
  }
  tTail = pr->token;
  tIdent = pr->capture;
  idLen = (cwal_size_t)(tIdent.end-tIdent.begin);
#if 0
  MARKER(("Capture=%.*s\n", (int)(pr->capture.end-pr->capture.begin),
          pr->capture.begin));
  MARKER(("tIdent=%.*s\n", (int)idLen, tIdent.begin));
#endif
  if(se->skipLevel>0){
    xrv = cwal_value_undefined();
    goto check_tail;
  }else if(!cwal_props_can(operand)){
    rc = s2_throw_ptoker(se, pr, CWAL_RC_EXCEPTION,
                         "'%s' expects a container, "
                         "but '%.*s' resolves to type '%s'.",
                         kw->word, (int)idLen, tIdent.begin,
                         cwal_value_type_name(operand));
    goto end;

  /* cwal_value_ref(operand); */
  s2_ptoker_sub_from_toker( &ptArgs, pr );
  rc = s2_eval_to_array( se, &ptArgs, args );
  /* cwal_value_unhand(operand); */
  /* cwal_value_make_vacuum_proof(operand, 0); */
  if(!rc){
    /* s2_dump_val(vargs,"call args"); */
    rc = s2_ctor_apply( se, operand, ctor, args, &xrv );
    /* s2_dump_val(xrv, "result from 'new'"); */
  }

  check_tail:
  if(rc){
    assert(!xrv);
  }else{
    if(xrv) cwal_value_ref(xrv);
    /* Check for a {body} part after the T(...), and treat it like
       an inlined extension to the ctor like in Java: new X() {{ ... }}.
    */
    s2_next_token(se, pr, 0, &tWithThis);
    if(s2_ptoken_is_true_squiggly(&tWithThis)){
      pr->token = tTail = tWithThis;
      /*MARKER(("Got post-new() body: %.*s\n",
        (int)(tTail.end-tTail.begin), tTail.begin));*/
      if(!se->skipLevel){
        rc = s2_eval_current_sub_with_this(se, pr, xrv, NULL);
      }
    }
  }
  end:

  if(strace.pr){
    s2_strace_pop(se);
  }
  if(operand){
    cwal_value_unref(operand);
    operand = 0;
  }
  if(vargs){
    cwal_value_make_vacuum_proof(vargs, 0);
    cwal_value_unref(vargs);
  }
  if(!rc){
    pr->token = tTail;
    *rv = xrv;
    cwal_value_unhand(xrv);
  }else if(xrv){
    cwal_value_unref(xrv);
  }
  return rc;
}

int s2_keyword_f_enum( s2_keyword const * kw, s2_engine * se,
                       s2_ptoker * pr, cwal_value **rv){
  int rc;
  s2_ptoken tName = s2_ptoken_empty;

    cwal_container_client_flags_set(store, S2_VAL_F_ENUM);
    cwal_value_unhand(store);
    *rv = store;
  }
  return rc;
}

/**
   Tag type IDs for typeinfo(TAG ...).
*/
enum s2_typeinfo_words {
  /* Sentinel value. Must be 0. */
  TYPEINFO_NONE = 0,
  /** True if operand can be used as an operand for the "new" keyword. */
  TYPEINFO_CANNEW,
  /** True if operand is or has an array in its prototype chain. */
  TYPEINFO_HASARRAY,
  /** True if operand is or has an enum in its prototype chain. */
  TYPEINFO_HASENUM,
  /** True if operand is or has an exception in its prototype chain. */
  TYPEINFO_HASEXCEPTION,
  /** True if operand is or has a hash in its prototype chain. */
  TYPEINFO_HASHASH,
  /** True if operand is or has a native in its prototype chain. */
  TYPEINFO_HASNATIVE,
  /** True if operand is or has an Object in its prototype chain. */
  TYPEINFO_HASOBJECT,
  /** True if operand has a prototype. */
  TYPEINFO_HASPROTOYPE,
  /** True if operand is an array. */
  TYPEINFO_ISARRAY,
  /** True if operand is a bool. */
  TYPEINFO_ISBOOL,
  /** True if operand is a buffer. */
  TYPEINFO_ISBUFFER,
  /** True if operand is callable (is a function or has a function
      in its prototype chain). */
  TYPEINFO_ISCALLABLE,
  /** True if operand is a container (can hold its own properties). */
  TYPEINFO_ISCONTAINER,
  /** True if operand is the name of a declared (currently in-scope) variable/const. */
  TYPEINFO_ISDECLARED,
  /** True if operand is legal for use with the dot operator. */
  TYPEINFO_ISDEREFABLE,
    /** True if operand is a double. */
  TYPEINFO_ISDOUBLE,
  /** True if operand is an enum. */
  TYPEINFO_ISENUM,
  /** True if operand is an exception. */
  TYPEINFO_ISEXCEPTION,
  /** True if operand is a function. */
  TYPEINFO_ISFUNCTION,
  /** True if operand is a hash. */
  TYPEINFO_ISHASH,
  /** True if operand is an integer . */
  TYPEINFO_ISINT,
  /** True if operand is a var/const declared in the local scope. */
  TYPEINFO_ISLOCAL,
  /** True if operand is a native. */
  TYPEINFO_ISNATIVE,
  /** True if the _current_ scope was started by the 'new' keyword. */
  TYPEINFO_ISNEWING,
  /** True if operand is an integer or a double. */
  TYPEINFO_ISNUMBER,
  /**
     True if operand is an integer, a double, a boolean,
     or a numeric-format string (one parseable by
     NumberPrototype.parseNumber()).
  */
  TYPEINFO_ISNUMERIC,
  /** True if operand is an Object */
  TYPEINFO_ISOBJECT,
  /** True if operand is a string. */
  TYPEINFO_ISSTRING,
  /** True if operand is a Unique-type value. */
  TYPEINFO_ISUNIQUE,
  /** Evaluates to the type's name (as as the typename
      keyword). */
  TYPEINFO_NAME,
  /** Evaluates to the operand's refcount. */
  TYPEINFO_REFCOUNT
};
typedef struct {
  enum s2_typeinfo_words type;
  char const * word;
  cwal_size_t wordLen;
  /**
     Argument type:

     0 = none
     >0 = expr
     <0 = identifier
  */
  int argType;
} s2_typeinfo_word;
static const s2_typeinfo_word s2TypeInfoWords[] = {
  /* Keep these sorted by their 'word' member, as we
     do a binary search on that. */
  { TYPEINFO_CANNEW,      "cannew", 6,        1},
  { TYPEINFO_HASARRAY,    "hasarray", 8,      1},
  { TYPEINFO_HASENUM,     "hasenum", 7,       1},
  { TYPEINFO_HASEXCEPTION,"hasexception", 12, 1},
  { TYPEINFO_HASHASH,     "hashash", 7,       1},
  { TYPEINFO_HASNATIVE,   "hasnative", 9,     1},
  { TYPEINFO_HASOBJECT,   "hasobject", 9,     1},
  { TYPEINFO_HASPROTOYPE, "hasprototype", 12, 1},
  { TYPEINFO_ISARRAY,     "isarray", 7,       1},
  { TYPEINFO_ISBOOL,      "isbool", 6,        1},
  { TYPEINFO_ISBUFFER,    "isbuffer", 8,      1},
  { TYPEINFO_ISCALLABLE,  "iscallable", 10,   1},
  { TYPEINFO_ISCONTAINER, "iscontainer", 11,  1},
  { TYPEINFO_ISDECLARED,  "isdeclared", 10,  -1},
  { TYPEINFO_ISDEREFABLE, "isderefable", 11,  1},
  { TYPEINFO_ISDOUBLE,    "isdouble", 8,      1},
  { TYPEINFO_ISENUM,      "isenum", 6,        1},
  { TYPEINFO_ISEXCEPTION, "isexception", 11,  1},
  { TYPEINFO_ISFUNCTION,  "isfunction", 10,   1},
  { TYPEINFO_ISHASH,      "ishash", 6,        1},
  { TYPEINFO_ISINT,       "isinteger", 9,     1},
  { TYPEINFO_ISLOCAL,     "islocal", 7,      -1},
  { TYPEINFO_ISNATIVE,    "isnative", 8,      1},
  { TYPEINFO_ISNEWING,    "isnewing", 8,      0},
  { TYPEINFO_ISNUMBER,    "isnumber", 8,      1},
  { TYPEINFO_ISNUMERIC,   "isnumeric", 9,     1},
  { TYPEINFO_ISOBJECT,    "isobject", 8,      1},
  { TYPEINFO_ISSTRING,    "isstring", 8,      1},
  { TYPEINFO_ISUNIQUE,    "isunique", 8,      1},
  { TYPEINFO_NAME,        "name", 4,          1},
  { TYPEINFO_REFCOUNT,    "refcount", 8,      1},
  { TYPEINFO_NONE, 0, 0, 0}/* end-of-list sentinel: entries must be 0 */
};

/**
   Comparison func for bsearch(), comparing (s2_typeinfo_word *)
   key with (s2_typeinfo_word *) on s2_typeinfo_word::word.
*/
static int s2_typeinfo_cmp(void const * key, void const * kw){
  s2_typeinfo_word const * k = ((s2_typeinfo_word const *)key);
  s2_typeinfo_word const * w = ((s2_typeinfo_word const *)kw);
  if(k->wordLen == w->wordLen) return memcmp(k->word, w->word,
                                     (size_t)k->wordLen);
#if !defined(NDEBUG)
  else if(!w->word){
    assert(!"sentinel gets trimmed from the list length");
    return 1 /* sentinel entry */;
  }
#endif
  else if(k->word[0] != w->word[0]) return (int)k->word[0] - (int)w->word[0];
  else{
    cwal_size_t const len = (k->wordLen<w->wordLen) ? k->wordLen : w->wordLen;
    int const cmp = memcmp(k->word, w->word, (size_t)len);
    return cmp ? cmp : ((len==k->wordLen) ? -1 : 1);
  }
}

int s2_keyword_f_typeinfo( s2_keyword const * kw, s2_engine * se,
                           s2_ptoker * pr, cwal_value **rv){
  s2_ptoken tIdent = s2_ptoken_empty;
  s2_ptoker prBody = s2_ptoker_empty;
  s2_ptoker const * oldScript = se->currentScript;
  cwal_size_t idLen = 0;
  cwal_value * xrv = 0;
  int rc;
  int buul = -1 /* <0=unknown, 0=false, >0=true */;











































































  s2_typeinfo_word const * word;







































  *rv = 0;
  /**
     Ideas:

     typeinfo(FLAG EXPR)

     We use (...) to avoid potential precedence confusion for use
     cases such as:

     typeinfo iscallable X || throw "need a callable type"

     i.e. does the || belong the RHS of the typeinfo or not? We punt
     on that problem by adding the parenthesis, making it unambiguous.

     FLAG is one of the words defined above.
  */
  rc = s2_next_token( se, pr, 0, 0 );
  if(rc) goto end;

  if(S2_T_ParenGroup!=pr->token.ttype){
    rc = s2_err_ptoker(se, pr, CWAL_SCR_SYNTAX,
                       "Expecting (IDENTIFIER ...) after '%s'.",
                       kw->word);
    goto end;
  }

  if(se->skipLevel>0){
    /**
       Reminder to self: someday we should arguably continue going
       in skip mode so that we can validate that the contents of (...)
       are syntactically valid.
    */
    *rv = cwal_value_undefined();
    goto end;
  }

  s2_ptoker_sub_from_toker(&prBody, pr);
  rc = s2_next_token(se, &prBody, 0, 0);
  if(rc) goto end;
  else if(S2_T_Identifier!=prBody.token.ttype){




    rc = s2_err_ptoker(se, &prBody, CWAL_SCR_SYNTAX,
                       "Expected typeinfo tag in %s(TAG ...).",
                       kw->word);
    goto end;
  }

  se->currentScript = &prBody;
  tIdent = prBody.token;
  assert(tIdent.end-tIdent.begin>0);
  idLen = (cwal_size_t)(tIdent.end-tIdent.begin);
  assert(idLen);
  /* MARKER(("typeinfo tag: %.*s\n", (int)idLen, tIdent.begin)); */

  /*
    Look for sub-keyword match...
    TODO: binary search. Need to move the struct decl
    up a scope for that.
  */


  {
    s2_typeinfo_word wordKey;
    wordKey.word = tIdent.begin;

    wordKey.wordLen = idLen;
    wordKey.type = TYPEINFO_REFCOUNT /*any will do*/;
    wordKey.argType = 0;
    word = (s2_typeinfo_word const *)bsearch(&wordKey, s2TypeInfoWords,
                                             sizeof(s2TypeInfoWords)
                                             /sizeof(s2TypeInfoWords[0])
                                             -1/*sentinel*/,

                                             sizeof(s2_typeinfo_word),
                                             s2_typeinfo_cmp);
  }
  if(0!=rc || !word->word){
    /* Note that in skip mode we've skipped over the whole (...), so
       this won't be triggered in skip mode (an exception to the
       rule/guideline regarding "blatant syntax errors").  Whether or
       not that needs "fixing" (such that this error could be
       triggered in skip mode) is as yet undecided.

    rc = s2_err_ptoker(se, &prBody, CWAL_SCR_SYNTAX,
                       "Expecting comma after %s(%.*s ...).",
                       kw->word, (int)idLen, tIdent.begin);
    goto end;
  }
#endif

  if(word->argType<0){
    /* typeinfo(tag IDENTIFIER) */

    rc = s2_next_token(se, &prBody, 0, 0);
    if(rc) goto end;
    else if(S2_T_Identifier != prBody.token.ttype){
      rc = s2_err_ptoker(se, &prBody, CWAL_SCR_SYNTAX,
                         "The %s('%s' ...) tag requires an IDENTIFIER "
                         "(variable name).",
                         kw->word, word->word);
      goto end;
    }
    switch(word->type){
      case TYPEINFO_ISLOCAL:
      case TYPEINFO_ISDECLARED:
        xrv = s2_var_get(se, TYPEINFO_ISLOCAL==word->type ? 0 : -1,
                         prBody.token.begin,
                         (cwal_size_t)(prBody.token.end - prBody.token.begin));
        buul = xrv ? 1 : 0;
        xrv = 0;
        cwal_value_ref(xrv);
        break;
      default:
        assert(!"Missing entry for argType<0!");
        break;
    }
  }else if(word->argType>0){
    /* typeinfo(tag EXPR) */
    rc = s2_eval_expr_impl(se, &prBody, 0,
                           (TYPEINFO_NAME==word->type)
                           ? S2_EVAL_UNKNOWN_IDENTIFIER_AS_UNDEFINED
                           : 0
                           , &xrv);
    if(rc){
      assert(!xrv);
      goto end;
    }else if(!xrv){
      rc = s2_err_ptoker(se, &prBody, CWAL_SCR_SYNTAX,
                         "Expecting non-empty expression after %s(%s, ...).",
                         kw->word, word ? word->word : "...");
      goto end;
    }
    cwal_value_ref(xrv);
  }else{
    /* typeinfo(tag) */
    ++se->skipLevel;
    rc = s2_eval_expr_impl(se, &prBody, 0, 0, &xrv);
    --se->skipLevel;
    if(rc){
      assert(!xrv);
      goto end;
    }else if(xrv){
      cwal_value_ref(xrv);
      rc = s2_err_ptoker(se, &prBody, CWAL_SCR_SYNTAX,
                         "Got unexpected expression in %s(%s <HERE>).",
                         kw->word, word->word);
      goto end;
    }
  }
  assert(!rc);

  switch(word->type){

#define TYPEWORD(WORD,PREDICATE) \
    case WORD: buul = PREDICATE(xrv); break

      break;

    case TYPEINFO_ISLOCAL:
    case TYPEINFO_ISDECLARED:
      /* handled above */
      assert(buul >= 0);
      break;

    case TYPEINFO_ISNEWING:
      buul = s2_scope_is_newing(se);
      break;

    case TYPEINFO_ISNUMERIC:
      if(!(buul = cwal_value_is_number(xrv))
         && cwal_value_is_string(xrv)){
      /* check for numeric-format strings a-la
         0.prototype.parseNumber(). */
        cwal_size_t slen = 0;
        char const * src = cwal_value_get_cstr(xrv, &slen);

    *rv = cwal_new_bool(buul ? 1 : 0);
  }else{
    assert(*rv);
  }

  end:
  se->currentScript = oldScript;
  if(xrv){
    if(!rc && *rv == xrv) cwal_value_unhand(xrv);
    else cwal_value_unref(xrv);
  }
  return rc;
}



cwal_value * s2_propagating_get( s2_engine * se ){

      };
      rc = s2_install_functions(se, proto, funcs, 0 );
      if(rc) goto end;
      else {
        cwal_value * fv = 0;
        s2_get(se, proto, "new", 3, &fv);
        assert(fv && "we JUST put this in there!");
        rc = s2_ctor_method_set( se, proto,
                                 cwal_value_get_function(fv) );
      }
    }

#undef FUNC2
#undef CHECKV
#undef RC

#else
#define MARKER(pfexp) (void)0
#endif

#define s2__pop_val s2_engine_pop_value
#define s2__pop_tok s2_engine_pop_token

/* defined in s2_eval.c */
void s2_dotop_state( s2_engine * se, cwal_value * self,
                     cwal_value * lhs, cwal_value * key );


/**
   Operator for unary and binary addition and subtraction.

   Required stack (from top to bottom):
   Binary: RHS LHS
   Unary: RHS

    rc = s2_engine_err_set(se, CWAL_RC_TYPE,
                           "Invalid LHS value (type %s) for "
                           "'%s' operator.",
                           cwal_value_type_name(lhs),
                           op->sym);
  }else if(se->skipLevel){
    if(S2_T_OpDot == op->id){
      s2_dotop_state( se, lhs, lhs, rhs );
      assert( se->dotOpSelf == se->dotOpLhs );
      assert( se->dotOpSelf == lhs );
      assert( se->dotOpKey == rhs );
    }else{
      s2_dotop_state( se, 0, cwal_value_undefined(),
                      cwal_value_undefined() );
      assert(!se->dotOpSelf);
      assert(cwal_value_undefined() == se->dotOpLhs);
      assert(cwal_value_undefined() == se->dotOpKey);
    }
    *rv = cwal_value_undefined();
    rc = 0;
  }else{ /* X.Y and X#Y... */
    cwal_value * xrv = 0;
    /* s2_dotop_state( se, 0, 0, 0 ); */
    /* s2_dump_val(lhs,"dot op lhs"); */
    if(S2_T_OpDot == op->id){
      const int isArrayAccess =
        cwal_value_is_integer(rhs)
        && cwal_value_array_part(se->e,lhs)
        /* Workaround to keep array.int's
           array from becoming 'this' if it
           resolves to a function which gets
           called.
        */
        ;
      
      rc = s2_get_v(se, lhs, rhs, &xrv);
      if(!rc){
        s2_dotop_state( se, isArrayAccess ? 0 : lhs, lhs, rhs );
      }
    }else{ /* X#Y */
      cwal_hash * h;
      assert(S2_T_OpHash==op->id);
#if 0
      if(!s2_op_check_overload(op, se, 0, lhs, rhs, &xrv, &rc)
         && !rc){
#endif
        h = cwal_value_hash_part(se->e, lhs);
        if(!h){
          rc = s2_engine_err_set(se, CWAL_RC_TYPE,
                                 "Invalid (non-Hash) LHS for '%s' operator.",
                                 op->sym);
        }else{
          xrv = cwal_hash_search_v( h, rhs );
        }
#if 0
      }
#endif
      if(!rc) s2_dotop_state(se, 0, lhs, rhs);
    }
    if(!rc){
      /*
        Hmmm. We can't cwal_refunref() the operands to these
        ops. We need to tweak the bits which use these parts
        (namely assignments) to refunref these.
       */
      /* s2_dotop_state( se, opSelf, lhs, rhs ); */

      *rv = xrv ? xrv : cwal_value_undefined();
    }
  }
  return rc;
}

int s2_op_f_oload_arrow( s2_op const * op, s2_engine * se,

      assert(rc);
    }
#if 0
    /*??? can of worms ??? */
    if(!rc){
      /* Has to be done afterwards b/c overload can overwrite these,
         triggering an assertion in fcall() */
      s2_dotop_state( se, se->dotOpSelf, lhs, rhs );

      /* s2_dump_val(rhs,"se->dotOpKey"); */
      /* s2_dump_val(lhs,"se->dotOpLhs"); */
    }
#endif
  }
  return rc;
}

  cwal_value * vResolved = 0, * vResult = 0;
  cwal_int_t addVal = 0;
  char gotOverLoad = 0;
  char resolvedIsContainer = 0;
  assert(1==op->arity);
  self = se->dotOpLhs;
  key = self ? se->dotOpKey : 0;
  if(key) cwal_value_ref(key);
  if(self) cwal_value_ref(self);
  s2_dotop_state( se, 0, 0, 0 );
  if(key) cwal_value_unhand(key);
  if(self) cwal_value_unhand(self);
  se->dotOpId = 0;
  vTok = s2__pop_tok(se, 1);
  if(se->skipLevel>0){
    /* FIXME: refunref self/key, as appropriate.
       What about dotOpId?*/
    *rv = cwal_value_undefined();
    s2_stoken_free(se, vTok, 1);
    return 0;
  }
  if(!self){
    assert(!key);
    key = vTok->value;
  }
  identType = vTok->ttype;
  s2_stoken_free(se, vTok, 1);
  vTok = 0;

  /*
    if (self) then we know (well, hope) this was a prefix op to
    X.Y.

    };
    rc = s2_install_functions(se, proto, funcs, 0);
    if(rc) goto end;
    else {
      cwal_value * fv = 0;
      s2_get(se, proto, "new", 3, &fv);
      assert(fv && "we JUST put this in there!");
      rc = s2_ctor_method_set( se, proto,
                               cwal_value_get_function(fv) );
    }
  }

#undef SET
#undef CHECKV
    end:

      };
      rc = s2_install_functions(se, proto, funcs, 0);
      if(rc) goto end;
      else {
        cwal_value * fv = 0;
        s2_get(se, proto, "new", 3, &fv);
        assert(fv && "we JUST put this in there!");
        rc = s2_ctor_method_set( se, proto,
                                 cwal_value_get_function(fv) );
      }
    }

    end:
    return rc
      ? NULL /* remember: proto is stashed at this point, so no leak. */

#  endif
#  ifndef _BSD_SOURCE
#    define _BSD_SOURCE
#  endif
#endif
/* start of file ../cwal_amalgamation.h */
#if !defined(CWAL_VERSION_STRING)
#  define CWAL_VERSION_STRING "cwal fc4ced93115269518c0b2f51baafc3bf6d718e95 2016-01-31 17:26:10 built 2016-01-31 17:33"
#endif
/* start of file include/wh/cwal/cwal_config.h */
#if !defined(WANDERINGHORSE_NET_CWAL_CONFIG_H_INCLUDED)
#define WANDERINGHORSE_NET_CWAL_CONFIG_H_INCLUDED 1

#if !defined(CWAL_VERSION_STRING)
#define CWAL_VERSION_STRING "cwal version ???"

   Returns a handle to v's originating cwal_engine, or NULL
   if !v.
*/
cwal_engine * cwal_value_engine( cwal_value const * v );

/**
   Returns the current owning scope of v, or NULL if !v.

   Note that this is always 0 for values for which
   cwal_value_is_builtin() returns true.
*/
cwal_scope * cwal_value_scope( cwal_value const * v );


/**
   Possibly reallocates self->list, changing its size. This
   function ensures that self->list has at least n entries. If n

   O(1) and cost no new memory.

   Token instances must not be in use more than once concurrently,
   e.g. a token may not be in more than one stack at a time, nor may
   it be in the same stack multiple times. Multiple entries may
   reference the same value, provided it is otherwise safe from being
   swept/vacuumed up.

*/
struct s2_stoken{
  /**
     A s2_token_types value.
  */
  int ttype;
  /**

   copy initialization.
*/
extern const s2_op s2_op_empty;
#endif

/**
   Holds a stack of s2_stokens.


   Reminders to self:

   - 20160131 this type was designed to _not_ ref/unref values added
   to the stack, but that may have turned out to be a mistake. It
   simplifies much other code but string interning combined with our
   internal use of "temp" values leads to unmanagable/incorrect
   refcounts for interned string values in some cases, triggering
   cwal-level corruption detection assertions. Rewiring s2 so that
   this type does much of the reference count managent for a given
   (sub)expression is certainly worth considering, but could require a
   weekend or more of intense concentration :/.
*/
struct s2_stoken_stack {
  /**
     The top of the stack.

     Maintained via s2_stoken_stack_push(),
     s2_stoken_stack_pop(), and friends.

 */
struct s2_scope {
  cwal_scope scope;
  s2_sweep_guard sguard;
  s2_scope * parent;
  s2_subexpr_savestate saved;
  int ctorCallFlag;
  /**
     Set very to allow typeinfo(issnewing) to elide its second
     argument. It also incidentally lets us implement that
     check more cleanly.
  */
  void /*cwal_value*/ const * newingThis;
};

#define s2_scope_empty_m {\
    cwal_scope_empty_m/*scope*/, \
    s2_sweep_guard_empty_m/*sguard*/,         \
    0/*parent*/, \
    s2_subexpr_savestate_empty_m/*saved*/,    \
    0/*ctorCallFlag*/,                      \
    0/*newingThis*/\
}
extern const s2_scope s2_scope_empty;

/**
   This class encapsulates a basic stack engine which uses
   the cwal_value type as its generic operand type.

  /**
     Used to communicate the "argv" value between the interpreter
     parts which call functions and the pre-call hook called by
     cwal.
  */
  cwal_array * callArgV;

  /**
     Gets set by the stack layer when an operator (A) triggers an
     error and (B) has its srcPos set. Used to communicate
     operator-triggered error location information back to the parser
     layer.
  */
  char const * opErrPos;

   cwal_value * fv;
   f = cwal_new_function( se->e, my_callback_f, my_callback_state,
                          my_callback_state_finalizer_f, my_type_id );
   if(!f) return CWAL_RC_OOM;
   fv = cwal_function_value(fv);
   assert(f == cwal_value_get_function(fv)); // will always be the case if f is valid
   cwal_value_ref(fv);
   rc = s2_ctor_method_set( se, myContainer, f );
   cwal_value_unref(fv);
   return rc;
   @endcode

   In such a setup, from inside the my_callback() implementation,
   cwal_args_state(args->engine, my_type_id) can be used to
   (type-safely) fetch the my_callback_state pointer. The s2_engine
   instance associated with the call can be fetched via
   s2_engine_from_args(args).

   @see s2_ctor_callback_set()
*/
int s2_ctor_method_set( s2_engine * se, cwal_value * container, cwal_function * method );

/**
   A convenience form of s2_ctor_method_set() which instantiates a
   cwal_function from the its 3rd argument using s2_new_callback().
   Returns CWAL_RC_MISUSE if any argument is NULL, else returns as for
   s2_ctor_method_set().
*/
int s2_ctor_callback_set( s2_engine * se, cwal_value * container, cwal_callback_f method );

/**
   Invokes a "constructor" function in the same manner as the 'new' keyword
   does. If ctor is NULL then s2 looks in operand (which must be a container
   type) for a property named "s2::new". If that property is not found or
   is not a Function, se's error state is set and non-0 is returned.

   "new" keyword. This only returns true if v is a container which
   holds (not counting properties inherited from prototypes) a key
   named "s2::new" with a value which is-a/has-a Function.
*/
char s2_value_is_newable( s2_engine * se, cwal_value * v );

/**
   Returns true (non-0) if se's current scope was started by the "new"
   keyword.


*/
char s2_scope_is_newing(s2_engine * se);

/**
   @internal

   Looks for a constructor function from operand, _not_ looking in
   prototypes (because ctors should generally not be inherited).

#else
static void noop_printf(char const * fmt, ...) {}
#define MARKER if(0) noop_printf
#endif
#define MESSAGE(pfexp) printf pfexp
#define VERBOSE(pfexp) if(App.verboseMode) { printf("verbose: "); MESSAGE(pfexp); }(void)0

#if !defined(S2_SHELL_EXTEND_FUNC_NAME)
#define S2_SHELL_EXTEND_FUNC_NAME s2_shell_extend
#endif
/*
  If S2_SHELL_EXTEND is defined, the client must define
  s2_shell_extend() (see shell_extend.c for one implementation) and
  link it in with this app. It will be called relatively early in the
  initialization process so that any auto-loaded scripts can make use
  of it. It must, on error, return one of the non-0 CWAL_RC_xxx error
  codes (NOT a code from outside the range! EVER!). An error is
  treated as fatal to the shell.

  See shell_extend.c for a documented example of how to use this
  approach to extending this app.

*/
#if defined(S2_SHELL_EXTEND)
extern int S2_SHELL_EXTEND_FUNC_NAME(s2_engine * se, int argc, char const * const * argv);
#endif

/**
   Global app-level state.
*/
static struct {
  char const * appName;

  */
  cwal_memcap_config memcap;
} App = {
0/*appName*/,
1/*enableArg0Autoload*/,
1/*enableValueRecycling*/,
35/*maxChunkCount*/,
1/*enableStringInterning*/,
0/*showMetrics*/,
0/*verboseMode*/,
0/*traceAssertions*/,
0/*traceStacks*/,
0/*traceSweeps*/,
1/*scopesUseHashes*/,
0/*inFile*/,

    slen = cwal_strlen(arg0) - (exe ? 4 : 0);
    rc = sprintf(fn, "%.*s.s2", (int)slen, arg0);
    assert(rc<BufSize-1);
    rc = 0;
    scriptName = fn;
  }
  if(s2_file_is_accessible(scriptName, 0)){
    if(App.cleanroom){
      VERBOSE(("Clean-room mode is active: NOT auto-loading script [%s].\n", scriptName));
    }else{
      cwal_value * rv = 0;
      VERBOSE(("Auto-loading script [%s].\n", scriptName));
      rc = s2_eval_filename(se, 1, scriptName, -1, &rv);
      if(rc){
        MESSAGE(("Error auto-loading init script [%s]: "
                 "error #%d (%s).\n", scriptName,
                 rc, s2_rc_cstr(rc)));
        s2sh_report_result(se, rc, &rv);
      }
      else{
        cwal_refunref(rv);
      }
    }
  }
  return rc;
}

int s2sh_main(int argc, char const * const * argv){
  enum {

  se = UseStackS2Engine ? &SE : s2_engine_alloc(e);
  assert(se);
  assert(UseStackS2Engine ? !se->allocStamp : (se->allocStamp == e));

  if((rc = s2_engine_init( se, e ))) goto end;
  if(!App.cleanroom){
    if((rc = s2_install_core_prototypes(se))) goto end;
    else if( (rc = s2_setup_s2_global(se)) ) goto end;
  }
  se->sweepInterval += App.addSweepInterval;
  se->vacuumInterval += App.addVacuumInterval;
  se->flags.traceStack = App.traceStacks;
  se->flags.traceAssertions = App.traceAssertions;
  se->flags.traceSweeps = App.traceSweeps;
  s2_clampdown_level_set(se, App.clampDown);


  s2_set_interrupt_handlable( se )
    /* after infrastructure, before the auto-loaded script, in case it
       contains an endless loop or some such.
    */;
#if defined(S2_SHELL_EXTEND)
  if(!App.cleanroom){
    if( (rc = S2_SHELL_EXTEND_FUNC_NAME(se, argc, argv)) ) goto end;
  }else{
    VERBOSE(("Clean-room mode is active: NOT running client-side shell extensions.\n"));
  }
#endif
  if( (rc=s2sh_autoload(se)) ) goto end;

  rc = s2sh_main2(se);
  App.s2Global = 0;

  end:

    }ARG("--W"){
      App.traceSweeps = 0;
    }ARG("-w"){
      ++App.addSweepInterval;
    }ARG("+w"){
      ++App.addVacuumInterval;
    }ARG("-S"){
#if 0
      MARKER(("WARNING: string interning is disabled (despite -S) "
              "because it can backfire badly in some "
              "(unpredictable) cases.\n"));
      App.enableStringInterning = 0;
#else
      App.enableStringInterning = 1;
#endif
    }ARG("--S"){
      App.enableStringInterning = 0;
    }ARG("-i"){
      App.interactive = 1;
    }ARG("-f"){
      GET_FLAG_VAL(App.inFile);
      assert(App.inFile);

#define SO(T) MARKER(("sizeof("#T")=%d\n", (int)sizeof(T)))
      SO(s2_stoken);
      SO(s2_ptoken);
      SO(s2_ptoker);
      SO(s2_op);
      SO(s2_engine);
      SO(cwal_engine);
      SO(cwal_memchunk_overlay);
#undef SO
    }else{
      MARKER(("Unknown argument: %s\n", arg));
      assert(!"Unknown argument");
      return CWAL_RC_MISUSE;
    }
  }

  FUNC("transactionState", cb_fsl_db_trans_state);
  FUNC("close", cb_fsl_db_finalize);
  FUNC("each", cb_fsl_db_each);
  FUNC("exec", cb_fsl_db_exec);
  FUNC("execMulti", cb_fsl_db_exec_multi);
  FUNC("lastInsertId", cb_fsl_db_last_insert_id);
  FUNC("open", cb_fsl_db_ctor);
  rc = s2_ctor_method_set(se, proto, cwal_value_get_function(v));
  if(rc) goto end;
  FUNC("prepare", cb_fsl_db_prepare);
  FUNC("selectValue", cb_fsl_db_select_value);
  FUNC("selectValues", cb_fsl_db_select_values);

  v = fsl_stmt_prototype(se);
  VCHECK;

  /* FUNC("closeConfig", cb_fsl_config_close); */
  FUNC("finalize", cb_fsl_cx_finalize);
  FUNC("getUserName", cb_fsl_cx_user_name);
  FUNC("loadBlob", cb_fsl_cx_content_get);
  FUNC("loadManifest",cb_fsl_cx_deck_load);
  FUNC("loginCookieName", cb_fsl_login_cookie_name);
  FUNC("new", cb_fsl_cx_ctor);
  rc = s2_ctor_method_set(se, proto, cwal_value_get_function(v));
  if(rc) goto end;
  FUNC("openCheckout", cb_fsl_checkout_open_dir);
  FUNC("openConfig", cb_fsl_config_open);
  FUNC("openDb", cb_fsl_db_ctor);
  FUNC("openRepo", cb_fsl_repo_open);
  FUNC("symToRid", cb_fsl_cx_sym2rid);
  FUNC("symToUuid", cb_fsl_cx_sym2uuid);

    check( "'h''i'", '%1$Q', "h'i" );
    check( 'NULL', '%1$Q', null );

    // check 0-precision characters...
    check( '', '%1$.0c', '*' );
    check( '', '%1$0.0c', '*' );
    check( '  ', '%1$2.0c', '*' ) /* arguable, but currently true */;

    // check urlencoding/decoding
    check( 'a%20b%26c', '%1$r', 'a b&c' );
    check( 'a b&c', '%1$R', 'a%20b%26c' );
    check( 'a%2zb', '%1$R', 'a%2zb' );

    assert catch {'%1$.1r'.applyFormat()}.message.indexOf('precision')>0;
    assert catch {'%1$1r'.applyFormat()}.message.indexOf('width')>0;
    assert catch {'%1$.1R'.applyFormat()}.message.indexOf('precision')>0;
    assert catch {'%1$1R'.applyFormat()}.message.indexOf('width')>0;
}

scope{
    var b = Buffer(100);
    var x = 0, y = 0;
    b << <<<EOF
    for(var i = 0; i < 5; ++i) ++x, --y; 

# We keep these in a separate file to avoid a rebuild when changing
# these flags. Damn... some automatic rules foil us here.
########################################################################
# Valgrind sanity checks...
VG := $(call ShakeNMake.CALL.FIND_FILE,valgrind)
ifneq (,$(VG))
VG_REPORT := VG.report.csv
VG_FLAGS ?= --leak-check=full -v --show-reachable=yes --track-origins=yes
#SCRIPT_LIST := $(shell ls -1 test-[0-9]*.s2 | sort)
# Whether or not to collect massif-based stats...
RUN_MASSIF := 1
.PHONY: vg
# Reminder: don't use -A b/c it breaks output buffering tests!
VG_SHELL_FLAGS=--a -S
VG_UNIT_RUN_CMD = ./$(f-s2sh.BIN) $(VG_SHELL_FLAGS)
vg: $(f-s2sh.BIN) $(UNIT_GENERATED)
	@echo "Running: $(VG) $(VG_FLAGS) $(VG_UNIT_RUN_CMD) ..."; \
	export LD_LIBRARY_PATH="$(TOP_SRCDIR):$${LD_LIBRARY_PATH}"; \
	massif_tmp=tmp.massif; \
	for i in $(sort $(UNIT_SCRIPT_LIST)) $(UNIT_GENERATED); do \
		vgout=$$i.vg; \

	$(patsubst %,unit/%,*.vg *._out *.massif *.db *~ *.uncompressed *.z *.zip *.2) \
	$(patsubst %,unit2/%,*.vg *._out *.massif *.db *~ *.uncompressed *.z *.zip *.2) \
	)
# 'vg' proxies which tweak various s2/cwal-level optimizations...
#vgp: VG_SHELL_FLAGS+=--p
#vgp: VG_REPORT:=VG.report-p.csv
#vgp: vg
vgr: VG_SHELL_FLAGS+=--R -C -S
vgr: VG_REPORT:=VG.report-r.csv
vgr: vg
vgs: VG_SHELL_FLAGS+=--S -R -C
vgs: VG_REPORT:=VG.report-s.csv
vgs: vg
#vgt: VG_SHELL_FLAGS+=--t
#vgt: VG_REPORT:=VG.report-t.csv
#vgt: vg
vgrs: VG_SHELL_FLAGS+=--R -C --S
vgrs: VG_REPORT:=VG.report-rs.csv
vgrs: vg
vgrsc: VG_SHELL_FLAGS+=--R --C --S
vgrsc: VG_REPORT:=VG.report-rsc.csv
vgrsc: vg
# vgrst: VG_SHELL_FLAGS+=--r --s --t
# vgrst: VG_REPORT:=VG.report-rst.csv
# vgrst: vg
# vgprst: VG_SHELL_FLAGS+=--r --s --t --p
# vgprst: VG_REPORT:=VG.report-prst.csv
# vgprst: vg
VG_REPORT_MEGA := VG.report-mega.csv
CLEAN_FILES += $(VG_REPORT_MEGA)
VG_COMMANDS := \
	$(MAKE) vg \
	&& $(MAKE) vgr \
	&& $(MAKE) vgs \
	&& $(MAKE) vgrs \
	&& $(MAKE) vgrsc

vgall:
	@start=$$(date); \
	echo "Start time: $$start"; \
	$(VG_COMMANDS) || exit; \
	echo "Run time: $$start - $$(date)"; \
	rm -f $(VG_REPORT_MEGA); \
	for i in VG.report*.csv; do \
		test -s $$i || continue; \
		echo $$i | grep t-mega >/dev/null && continue; \
		echo "Report: $$i"; \
		cut -d, -f1,2,4,5 $$i | tr ',' '\t'; \
	done > $(VG_REPORT_MEGA); \
	echo "Consolidated valgrind report is in [$(VG_REPORT_MEGA)]."

endif
#/$(VG)
########################################################################