/**
     An experiment.

     20160125: reminder to self: the next time i write that without an
     explanation for my future self to understand, please flog
     me. Currently trying to figure out what this is for an am
     at a loss. It doesn't appear to do anything useful.

     20191209: used for implementing the experimental __using keyword
     to access "using" properties from inside a script function.
  */
  s2_func_state const * currentScriptFunc;

  /**
     Various commonly-used values which the engine stashes
     away for its own use...
  */

static int s2_keyword_f_nameof( s2_keyword const * kw, s2_engine * se, s2_ptoker * pr, cwal_value **rv);
static int s2_keyword_f_new( s2_keyword const * kw, s2_engine * se, s2_ptoker * pr, cwal_value **rv);
static int s2_keyword_f_refcount( s2_keyword const * kw, s2_engine * se, s2_ptoker * pr, cwal_value **rv);
static int s2_keyword_f_reserved( s2_keyword const * kw, s2_engine * se, s2_ptoker * pr, cwal_value **rv);
static int s2_keyword_f_typeinfo( s2_keyword const * kw, s2_engine * se, s2_ptoker * pr, cwal_value **rv);
static int s2_keyword_f_typename( s2_keyword const * kw, s2_engine * se, s2_ptoker * pr, cwal_value **rv);
static int s2_keyword_f_unset( s2_keyword const * kw, s2_engine * se, s2_ptoker * pr, cwal_value **rv);
static int s2_keyword_f_using( s2_keyword const * kw, s2_engine * se, s2_ptoker * pr, cwal_value **rv);
static int s2_keyword_f_var( s2_keyword const * kw, s2_engine * se, s2_ptoker * pr, cwal_value **rv);
static int s2_keyword_f_while( s2_keyword const * kw, s2_engine * se, s2_ptoker * pr, cwal_value **rv);


static const struct S2_KEYWORDS__ {
/*
  Keep sorted on keyword name (string) so that we can binary-search it.

*/
  s2_keyword const _breakpoint;
  s2_keyword const _col;
  s2_keyword const _file;
  s2_keyword const _filedir;
  s2_keyword const _flc;
  s2_keyword const _line;
  s2_keyword const _using;
  s2_keyword const affirm;
  s2_keyword const assert_;
  s2_keyword const break_;
  s2_keyword const catch_;
  s2_keyword const class_;
  s2_keyword const const_;
  s2_keyword const continue_;

  s2_keyword const typeName;
  s2_keyword const undef_;
  s2_keyword const unset;
  s2_keyword const var;
  s2_keyword const while_;
  s2_keyword const _sentinel_;
} S2_KWDS = {
/*{ id                      word,         wordLen,  call(), allowEOLAsEOXWhenLHS } */
  { S2_T_KeywordBREAKPOINT, "__BREAKPOINT", 12, s2_keyword_f_breakpoint, 0 },
  { S2_T_KeywordCOLUMN,     "__COLUMN",   8, s2_keyword_f_FLC,           0 },
  { S2_T_KeywordFILE,       "__FILE",     6, s2_keyword_f_FLC,           0 },
  { S2_T_KeywordFILEDIR,    "__FILEDIR",  9, s2_keyword_f_FLC,           0 },
  { S2_T_KeywordSRCPOS,     "__FLC",      5, s2_keyword_f_FLC,           0 },
  { S2_T_KeywordLINE,       "__LINE",     6, s2_keyword_f_FLC,           0 },
  { S2_T_Keyword__Using,    "__using",    7, s2_keyword_f_using,         0 },

  { S2_T_KeywordAffirm,     "affirm",     6, s2_keyword_f_assert,        0 },
  { S2_T_KeywordAssert,     "assert",     6, s2_keyword_f_assert,        0 },
  { S2_T_KeywordBreak,      "break",      5, s2_keyword_f_eval,          0 },
  { S2_T_KeywordCatch,      "catch",      5, s2_keyword_f_eval,          0 },
  { S2_T_KeywordClass,      "class",      5, s2_keyword_f_reserved,      0 },
  { S2_T_KeywordConst,      "const",      5, s2_keyword_f_var,           0 },

    WORD(S2_T_KeywordThrow,throw_);
    WORD(S2_T_KeywordTrue,true_);
    WORD(S2_T_KeywordTry,try_);
    WORD(S2_T_KeywordTypeinfo,typeInfo);
    WORD(S2_T_KeywordTypename,typeName);
    WORD(S2_T_KeywordUndefined,undef_);
    WORD(S2_T_KeywordUnset,unset);
    WORD(S2_T_Keyword__Using,_using);
    WORD(S2_T_KeywordVar,var);
    WORD(S2_T_KeywordWhile,while_);

#undef WORD
    default:
      return 0;
  }

#define WORD(W) &S2_KWDS.W
  WORD(_breakpoint),
  WORD(_col),
  WORD(_file),
  WORD(_filedir),
  WORD(_flc),
  WORD(_line),
  WORD(_using),
  WORD(affirm),
  WORD(assert_),
  WORD(break_),
  WORD(catch_),
  WORD(class_),
  WORD(const_),
  WORD(continue_),

   If asExpr is true it uses s2_eval_expr_impl() to process one
   expression, otherwise it uses s2_eval_ptoker() to parse it all as a
   collection of expressions.

*/
static int s2_eval_current_token( s2_engine * se, s2_ptoker * pr,
                                  char asExpr,
                                  int evalFlags,
                                  cwal_value **rv ){
  int rc = s2_check_interrupted(se, 0);
  pr->errToken = s2_ptoken_empty;
  /* assert(!name || nameLen>0); */
  if(rc) return rc;
  else if(!s2_ptoken_has_content(&pr->token)){
    /* we know it's empty, so don't bother.*/
    if(rv) *rv = 0

                         : "<NULL>");
    goto end;
  }
  /* MARKER(("Function call args: %.*s\n", (int)(pr->token.end-pr->token.begin), pr->token.begin)); */
  /* s2_dump_val(vSelf,"call() vSelf"); */
  /* s2_dump_val(fv,"call() func"); */


  fst = s2_func_state_for_func(theFunc);
  {
    /* 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;

    if(rc){
      cwal_value_make_vacuum_proof(arV, 0);
      cwal_value_unref(arV);
      goto end;
    }
    oldArgV = se->callArgV;
    se->callArgV = 0;
    se->currentScriptFunc = 0 /* if this is a script-side function call,
                                 s2_callback_f(), which is about to trigger,
                                 will set this to the corresponding function. */;
    pr->errToken = origin /* just in case, location for error reporting */;
    if(0){
      MARKER(("Function call()...\n"));
      s2_dump_val(vSelf ? vSelf : fv, "vSelf ? vSelf : fv");
      s2_dump_val(cwal_array_value(ar), "argv");
    }

                                      vSelf
                                      ? vSelf
                                      : (1 ? fv : cwal_value_undefined()),
                                      &xrv, ar )
      /* Still wavering on this point: when called without a propery
         access (vSelf===0), should the function's "this" be the
         undefined value or itself? i don't want "this" propagating in
         from an older scope.

         One argument for passing fv instead of undefined:

         var obj = { prototype: proc(x){ this.x = argv.x } };

         obj(1);

         'this' is undefined in that call.

         Another argument: it seems that i already wrote a chapter on
         how to use/abuse it in the docs.
       */;
    }
    se->currentScriptFunc = oldScriptFunc;
    /* assert(!se->callArgV && "Gets unset via the post-call() hook");
    
       interesting problem: on certain types of errors, first made
       possible with the introduction of interceptors, the pre()

      /* we have to ref *rv before destroying arV for the case that *rv==arV
         or arV contains (perhaps indirectly) *rv. */
        cwal_value_ref(xrv);
    }
    cwal_value_unref(arV);
  }
  end:

  rc = s2_check_interrupted(se, rc);
  switch(rc){
    case 0:
      break;
    case CWAL_RC_EXCEPTION:
      s2_exception_add_script_props(se, pr)
        /* Needed to decorate calls to native functions. */;
      CWAL_SWITCH_FALL_THROUGH;
    /* case CWAL_SCR_SYNTAX: */
    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? Much later: no.*/
      break;
    case CWAL_RC_BREAK:
    case CWAL_RC_CONTINUE:
      /*
        If a break/continue are triggered while handling the
        arguments, that's okay: let them propagate so they can be
        caught by upstream code. If they passed through the call()
        itself, that's not okay: stop them from propagating further.
      */
      if(!reachedTheCall) break;
      CWAL_SWITCH_FALL_THROUGH;
    default:
      if(se->err.code){
        /* Likely a syntax-related error pending */
        /*MARKER(("[rc=%s] se->err.msg=%s\n", s2_rc_cstr(se->err.code), (char *)se->err.msg.mem));*/

   It's crashing in the && operator, and it seems to be a lifetime
   problem related to the 'd' value (possibly getting hosed via the
   2nd assignment?). Running with recycling ON (-R instead of --R)
   hides the problem but potentially causes Weird Broken Stuff to
   happen later (as is being witnessed in the CGI plugin, which was
   where this was initially triggered).  This is the first serious
   lifetime-related bug we've seen the core in a couple years :`(. A
   decent solution, aside from the eval holder, is as yet unknown :`(.

   Other formulations and permutations:

   (Forewarning: these are often dependent on the exact recycling
   options used and the internal state of the recycling system(s)!)

   var d; if((d = s2.getenv('HOME')) && (d = s2.fs.realpath(d+'/fossil'))) 0;
   // ^^^ crashes

#  define eval_hold(V) if( holder && (V) \
                           && (rc = eval_hold_this_value(holder, (V)))) goto end
#else
#  define eval_hold(V) /* now done via s2_process_op_impl(), and yet...
                          that doesn't get all of them. */
#endif
  /*
    Create se->scopes.current->evalHolder to hold refs to our
    being-eval'd values. As an optimization, if we're in skip mode,
    don't bother... and let's hope that this function is never called
    in such a way that skip mode is disabled by a downstream sub-eval
    (because this optimization will hose us if that happens).
  */
  if(!se->skipLevel && !(holder = se->scopes.current->evalHolder)){
    holder = cwal_new_array(se->e);

  }
  se->currentScript = oldScript;
  return rc;
}

int s2_keyword_f_breakpoint( s2_keyword const * kw, s2_engine * se, s2_ptoker * pr, cwal_value **rv){
  int rc;
  S2_UNUSED_ARG kw;
  S2_UNUSED_ARG se;
  S2_UNUSED_ARG pr;
  *rv = cwal_value_undefined();
  rc = 0 /* place breakpoint here */;
  /**
     TODO:

     add an interactive breakpoint callback hook, which the client can
     optionally start running when the hook is called. e.g. s2sh might

    switch(pr->token.ttype){
      case S2_T_KeywordUndefined: *rv = cwal_value_undefined(); return 0;
      case S2_T_KeywordNull: *rv = cwal_value_null(); return 0;
      case S2_T_KeywordTrue: *rv = cwal_value_true(); return 0;
      case S2_T_KeywordFalse: *rv = cwal_value_false(); return 0;
      default:
        assert(!"Invalid keyword mapping");
        S2_UNUSED_ARG kw;
        s2_fatal(CWAL_RC_RANGE, "Invalid keyword mapping in s2_keyword_f_builtin_vals()")
          /* does not return, but your compiler doesn't know that, so... */;
        return CWAL_RC_ERROR;
    }
  }
}

   assertion may be triggered (or a NULL pointer deref).
*/
int s2_callback_hook_pre(cwal_callback_args const * args,
                         void * stateUnused){
  s2_func_state * fs = args->callee
    ? s2_func_state_for_func(args->callee)
    : NULL;
  S2_UNUSED_ARG stateUnused;
  /* MARKER(("PRE-FUNC HOOK fstate=%p argc=%d!\n", (void const *)fs, (int)args->argc)); */
  if(
     !fs /* It's a native function */
     || (/* A function with neither body content nor params. */
         fs->flags & S2_FUNCSTATE_F_EMPTY_BODY
         && fs->flags & S2_FUNCSTATE_F_EMPTY_PARAMS)
     ){
    s2_engine * se = s2_engine_from_state(args->engine);
    assert(se);
    se->callArgV = 0 /* Make sure this doesn't propagate through to a script
                        func that this native function calls. Been
                        there, debugged that! */;
    /* MARKER(("Non-script or empty function. Not injecting argv/this.\n")); */
    s2_dotop_state( se, 0, 0, 0 ) /* necessary!!! */;
    return 0;
  }

#endif
    if(fs){
      /* Import imported properties (using/Function.importSymbols())
         into the current scope.
      */
      if(fs->vImported){
        rc = cwal_scope_import_properties( s, fs->vImported );

      }
    }
    return rc;
  }
}

int s2_callback_hook_post(cwal_callback_args const * args,

        rc = s2_throw_ptoker(se, pr, CWAL_RC_TYPE,
                             "Expecting an Object literal but got a %s.",
                             cwal_value_type_name(v));
        cwal_value_unref(v);
      }
      else if(!fst->vImported){
        fst->vImported = v /* fst now owns the ref point */;
        cwal_value_prototype_set(v, NULL);
        s2_value_to_lhs_scope(fv, v);
      }else{
        rc = cwal_props_copy(v, fst->vImported);
        cwal_value_unref(v);
      }
      v = 0;
    }

  TYPEINFO_ISINT,
  /** True if operand is a tuple or an array. */
  TYPEINFO_ISLIST,
  /** 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 "this" is being initalized via 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()).

  if(operand){
    if(!rc && rv) cwal_value_ref(*rv);
    cwal_value_unref(operand);
    if(!rc && rv) cwal_value_unhand(*rv);
  }
  return rc;
}

/**
   The __using() function-like keyword is used for accessing
   "using"/importSymbols()-injected state.
*/
int s2_keyword_f_using( s2_keyword const * kw, s2_engine * se, s2_ptoker * pr, cwal_value **rv){
  int rc;
  cwal_value * imports = 0;
  cwal_value * xrv = 0;
  assert(S2_T_Keyword__Using == kw->id);
  rc = s2_next_token(se, pr, 0, 0);
  if(rc) return rc;
  if(S2_T_ParenGroup!=pr->token.ttype){
    return s2_err_ptoker(se, pr, CWAL_SCR_SYNTAX,
                         "Expecting (...) after %s keyword.",
                         kw->word);
  }
  rc = s2_eval_current_token(se, pr, 0, S2_EVAL_PUSH_SCOPE, &xrv);
  if(rc){
    assert(!xrv);
    return rc;
  }
  else if(!xrv){
    /* __using() is valid in the current script-side func to refer
       to its own imports. */
    if(!se->currentScriptFunc){
      rc = s2_err_ptoker(se, pr, CWAL_SCR_SYNTAX,
                         "%s() is only valid in the body of a "
                         "script-implemented function.",
                         kw->word);
    }else{
      imports = se->currentScriptFunc->vImported;
      cwal_value_ref(imports);
    }
  }else{
    /* __using(expr), where expr must be a script-side function. */
    cwal_function * f = cwal_value_get_function(xrv);
    s2_func_state * fst = f ? s2_func_state_for_func(f) : 0;
    cwal_value_ref(xrv);
    if(!fst){
      rc = s2_throw_ptoker(se, pr, CWAL_RC_TYPE,
                           "Expression passed to %s(...) is not a "
                           "script-defined function.",
                           kw)
        /* Note that this throws an exception, but __using(<EMPTY>) in
           the wrong place is a syntax error. Feature or bug? */;
    }else{
      imports = fst->vImported;
      cwal_value_ref(imports);
    }
    cwal_value_unref(xrv);
    xrv = 0;
  }
  if(imports){
    assert(!rc);
    cwal_value_rescope(se->scopes.current->cwalScope, imports)
      /* i don't think this is strictly necessary, as the input
         function cannot possibly live in a too-old scope, but better
         safe than sorry. */;
    cwal_value_unhand(imports);
    *rv = imports;
  }else if(!rc){
    *rv = cwal_value_undefined();
  }
  return rc;
}

#undef MARKER

  assert(se && theFunc && fst);
  props = fst->vImported;
  if(!props){
    props = cwal_new_object_value(se->e);
    if(!props) return 0;
    s2_value_to_lhs_scope(theFunc, props);
    cwal_value_ref(props);
    cwal_value_prototype_set(props, NULL);
    fst->vImported = props;
  }
  return props;
}

/**
   Implements Function.importSymbols().

/** @internal

   S2_UNUSED_VAR exists only to squelch, in non-debug builds, warnings
   about the existence of vars which are only used in assert()
   expressions (and thus get filtered out in non-debug builds).
*/
#define S2_UNUSED_VAR __attribute__((__unused__))
/**
   S2_UNUSED_ARG is used to squelch warnings about interface-level
   function parameters which are not used in a given implementation:

   @code
   int some_interface(type1 arg1, type2 arg2){
     S2_UNUSED_ARG arg1;
     ...
     return 0;
   }
   @code
*/
#define S2_UNUSED_ARG (void)

typedef struct s2_op s2_op;

/** @internal

   Internal state for Object.eachProperty() and similar functions.
*/

     will be NULL. It gets rescoped along with the containing Function
     value.
  */
  cwal_value * vSrc;

  /**
     An Object which holds all "imported" symbols associated with this
     function (via the "using" pseudo-keyword when defining a function
     or via Function.importSymbols(). When this function gets called,
     all of these symbols get imported into the call()'s scope.

     20190911: it "might be interesting" to add a keyword, or even a
     local variable, to access this list from inside a
     function. Slightly tricky would be to only resolve that symbol
     from inside the body of the function it applies to (similar to
     how the break keyword only works from within a loop).

     20191209: the __using() keyword now provides access to this. Part
     of that change is that this value's prototype is removed. We've
     never needed it in native code and remove it now so that script
     code does not inadvertently do anything silly with it or trip
     over inherited properties.
  */
  cwal_value * vImported;

  /**
     The name of the function, if any, gets defined as a scope-local
     symbol when the function is called, just like this->vImported
     does.

int s2_handle_get_result( s2_engine * se, s2_ptoker const * pr, int rc );

/** @internal

   Fetches fst's "imported symbols" holder object, initializing it if
   needed (which includes rescoping it to theFunc's scope). theFunc
   _must_ be the Function Value to which fst is bound.

   If this function creates the imported symbols holder, its prototype
   is removed.

   Is highly intolerant of NULL arguments.

   Returns NULL on OOM, else the properties object (owned by fst
   resp. theFunc).
*/
cwal_value * s2_func_import_props( s2_engine * se,

   Maintenance reminder: s2_op_f_assign2() and s2_op_f_assign3() share
   most of their logic, but having them separate improves their
   readability considerably. It might be useful to separate parts of
   the two implementations (e.g. the main operator dispatch switch)
   into a shared function at some point.
*/
int s2_op_f_assign3( s2_op const * op, s2_engine * se,
                     int argc, cwal_value **rv ){
  int rc = 0;
  cwal_value * rhs, * lhs, * self /* Assignment op: self[lhs]=rhs */;
  s2_stoken * vTok;
  int opReturnedLhs = -1
    /* optimization. If an operator returns the (X.Y) part of (X.Y OP
       Z) then we can skip the assignment back to X.Y.  A value of <0
       means we don't yet know. */;
  S2_UNUSED_ARG argc;
  assert( 3==op->arity );
  rhs = s2__pop_val(se);
  vTok = s2__pop_tok(se, 1);
  lhs = vTok->value;
  self = s2__pop_val(se);
  assert(self);
  cwal_value_ref(lhs);
  cwal_value_ref(rhs);
  cwal_value_ref(self);
  s2_stoken_free(se, vTok, 1);
  vTok = 0;
  if(se->skipLevel>0){
    cwal_value_unref(lhs);
    cwal_value_unref(rhs);
    cwal_value_unref(self);
    *rv = cwal_value_undefined();

    return 0;
  }
  if(op->id != S2_T_OpAssign3
     /* combo assignment, i.e. not: X.Y = Z */){
    /* For combo ops (all but and X.Y=Z) we need to resolve the LHS
       first because it's needed for calculating the result. For plain
       assignments we don't need to do this, and we don't allow

  s2_stoken * vTok;
  int ttype;
  int opReturnedLhs = -1
    /* optimization. If an operator returns the X part of (X OP Y)
       then we can skip the assignment back to X. A value of <0 means
       we don't yet know. */;
  char gotOverload = 0;
  S2_UNUSED_ARG argc;
  rhs = s2__pop_val(se);
  vTok = s2__pop_tok(se, 1);
  lhs = vTok->value;
  assert( 2==op->arity );
  cwal_value_ref(rhs);
  cwal_value_ref(lhs);
  ttype = vTok->ttype;
  s2_stoken_free(se, vTok, 1);
  vTok = 0;
  if(se->skipLevel>0){
    *rv = cwal_value_undefined();
    cwal_value_unref(rhs);
    cwal_value_unref(lhs);
    return 0;
  }
  if(S2_T_Identifier != ttype){
    cwal_value_unref(rhs);
    cwal_value_unref(lhs);

    return s2_engine_err_set(se, CWAL_SCR_SYNTAX,
                             "Invalid LHS (%s) for '%s' op.",
                             s2_ttype_cstr(ttype), op->sym);
  }

  if(op->id != S2_T_OpAssign /* a combo assignment, not plain X=Y */){
    /* For combo ops (all but X=Y) we need to resolve the LHS first

    CASE(S2_T_KeywordThrow);
    CASE(S2_T_KeywordTrue);
    CASE(S2_T_KeywordTry);
    CASE(S2_T_KeywordTypeinfo);
    CASE(S2_T_KeywordTypename);
    CASE(S2_T_KeywordUndefined);
    CASE(S2_T_KeywordUnset);
    CASE(S2_T_Keyword__Using);
    CASE(S2_T_KeywordVar);
    CASE(S2_T_KeywordWhile);

    CASE(S2_T_Comment__);
    CASE(S2_T_CommentC);
    CASE(S2_T_CommentCpp);
    CASE(S2_T_Mark__);

S2_T_KeywordThrow,
S2_T_KeywordTrue,
S2_T_KeywordTry,
S2_T_KeywordTypeinfo,
S2_T_KeywordTypename,
S2_T_KeywordUndefined,
S2_T_KeywordUnset,
S2_T_Keyword__Using /* __using(), as opposed to function()using(...){} */,
S2_T_KeywordVar,
S2_T_KeywordWhile,

S2_T_Comment__ = 4000,
S2_T_CommentC,
S2_T_CommentCpp,

    var f = proc(){return o} using{o:{x:1}};
    assert 1 === f().x;
    assert 1 === f().x++;
    assert 3 === ++f().x;
    assert 2 === --(f()).x;
    //assert 3 === ++(f().x) /* doesn't work b/c (x) is resolved in a subexpression */;
}

var u = scope {
    /* 20191209: __using() keyword */
    assert undefined === proc(){return __using()}();
    var f = proc(){return __using()} using{a: 1};
    var u = f();
    assert typeinfo(isobject u);
    assert !u.prototype;
    assert 1 === u.a;
    u.b = 2;
    assert 2 === f().b;
    assert undefined ===  __using(proc(){});
    assert 'CWAL_SCR_SYNTAX' === catch {__using()}.codeString();
    assert 'CWAL_RC_TYPE' === catch __using(f.apply).codeString();
    f = proc(){return __using()} using{} /* as fate would have it, using{}
                                            is legal but using() is not. */;
    u = f();
    assert typeinfo(isobject u);
    u.b = 1;
    assert 1 === f().b;

    /* imports must survive propagation out of a temporary value... */
    u = __using(proc()using{a:999}{});
    assert typeinfo(isobject u);
    assert 999 === u.a;

    /* imports can be added after the fact with importSymbols()... */
    f = proc(){return __using()};
    assert undefined === f();
    f.importSymbols({a: 1000});
    assert 1000 === f().a;
    /* imports must survive propagation out of this scope... */
    f() /* scope result */;
};
assert typeinfo(isobject u);
assert 1000 === u.a;