case stmt._EXPRSUGAR:
      obj_ptr = JimExpandExprSugar(stmt.interp, token.obj_ptr);
      break;
    case stmt.TOKEN_CMD:
      switch (stmt.evalObj(token.obj_ptr)) {
      case stmt.OK:
      case stmt.RETURN:
        obj_ptr = interp.result;
        obj_ptr = stmt.interp.result;
        break;
      case stmt.BREAK:
        /* Stop substituting */
        return stmt.BREAK;
      case stmt.CONTINUE:
        /* just skip this one */
        return stmt.CONTINUE;

        while (i--) {
          stmt.interp.empty_obj.decrRefCount(stmt.intv[i]);
        }
        stmt.intv = null;
        return null;
      }
      stmt.interp.empty_obj.incrRefCount(stmt.intv[i]);
//      stmt.interp.empty_obj.getString(stmt.intv[i]);
//      stmt.intv[i].getString();
      total_len += stmt.intv[i].len;
    }

    /* Fast path return for a single token */
    if (word_tokens == 1 && stmt.intv[0]) {
      stmt.interp.empty_obj.decrRefCount(stmt.intv[0]);
      return stmt.intv[0];
    }

    /* Concatenate every token in an unique
     * object. */
    obj_ptr = stmt.empty_obj.newStringObjNoAlloc(NULL, 0);
    obj_ptr = stmt.interp.empty_obj.newStringObjectNoAlloc(null, 0);

    if (word_tokens == 4 && token[idx + 0].token == stmt.TOKEN_ESC && token[idx + 1].token == stmt.TOKEN_ESC
        && token[idx + 2].token == stmt.TOKEN_VAR) {
      /* May be able to do fast interpolated object -> dictSubst */
      obj_ptr.obj_type = obj_ptr.interpolatedObjType;
      obj_ptr.internalRep.twoPtrValue.ptr1(token);
      obj_ptr.internalRep.twoPtrValue.ptr2(stmt.intv[idx + 2]);
      obj_ptr.twoPtrValue.ptr1(token);
      obj_ptr.twoPtrValue.ptr2(stmt.intv[idx + 2]);
      obj_ptr.incrRefCount(stmt.intv[idx + 2]);
    }

    obj_ptr.bytes = "";
    s = obj_ptr.bytes;
    obj_ptr.length = total_len;
    for (i = 0; i < word_tokens; i++) {
      if (stmt.intv[i]) {
        s += s.substring(stmt.intv[i].bytes, 0, stmt.intv[i].len);
        obj_ptr.decrRefCount(stmt.intv[i]);
      }
    }
    obj_ptr.bytes.charAt(total_len) = '\0';
    obj_ptr.bytes[total_len] = '\0';
    /* Free the intv vector. */
    stmt.intv = null;
print("INTERPOL!"+obj_ptr.getString(obj_ptr)+"!");
print("INTERPOL!"+obj_ptr.getString()+"!");
    return obj_ptr;
  },

  /* ==================== evalObj ===================================== */
  evalObj: function (script_obj_ptr) {
    var stmt = this;
    var i;

     */
    if (script.len == 0) {
      script_obj_ptr.decrRefCount(script_obj_ptr);
      return stmt.OK;
    }
    if (script.len == 3
        && script.script_object.tokens[1].obj_ptr.obj_type.name == "command"
        && script.script_object.tokens[1].obj_ptr.internalRep.cmd_value.cmd_ptr.isproc == 0
        && script.script_object.tokens[1].obj_ptr.internalRep.cmd_value.cmd_ptr.u.native.cmdProc == Jim_IncrCoreCommand
        && script.script_object.tokens[1].obj_ptr.cmdValue.cmdPtr.isproc == 0
        && script.script_object.tokens[1].obj_ptr.cmdValue.cmdPtr.u.native.cmdProc == Jim_IncrCoreCommand
        && script.script_object.tokens[2].obj_ptr.obj_typ.name == "variable") {

      var obj_ptr = stmt.interp.getVariable(script.script_object.tokens[2].obj_ptr, stmt.TOKENNONE);

      if (obj_ptr && !obj_ptr.isShared(obj_ptr) && obj_ptrobj_type.name == "int") {
//            JimWideValue(obj_ptr)++;
        obj_ptr.invalidateStringRep(obj_ptr);

    script.in_use++;

    token = script.script_object.tokens;

    /* Execute every command sequentially until the end of the script
     * or an error occurs.
     */
print("TOKS!"+token.length+"!");
    for (i = 0; i < script.len && retcode == stmt.OK; ) {
        var argc;
        var j;
        var cmd;

        /* First token of the line is always TOKEN_LINE */
print("I!"+i+"!"+script.getTokenString(token[i].token)+"!");
        argc = token[i].obj_ptr.internalRep.script_line_value.argc();
        linenr = token[i].obj_ptr.internalRep.script_line_value.line();
        argc = token[i].obj_ptr.scriptLineValue.argc();
        linenr = token[i].obj_ptr.scriptLineValue.line();

        /* Skip the TOKEN_LINE token */
        i++;

        /* Populate the arguments objects.
         * If an error occurs, retcode will be set and
         * 'j' will be set to the number of args expanded
         */
        for (j = 0; j < argc; j++) {
          var word_tokens = 1;
          var expand = 0;
          var word_obj_ptr = null;

print("I1!"+i+"!");
print("I2!"+i+"!"+script.getTokenString(token[i].token)+"!");
          if (token[i].token == stmt.TOKEN_WORD) {
            word_tokens = stmt.interp.empty_obj.wideValue(token[i++].obj_ptr);
            word_tokens = token[i++].obj_ptr.wideValue();
print("I2a!"+i+"!"+word_tokens+"!");
            if (word_tokens < 0) {
              expand = 1;
              word_tokens = -word_tokens;
            }
          }

            /* Need to expand word_obj_ptr into multiple args from argv[j] ... */
            var len = listLength(word_obj_ptr);
            var newargc = argc + len - 1;
            var k;

            /* Now copy in the expanded version */
            for (k = 0; k < len; k++) {
              argv[j++] = word_obj_ptr.internalRep.listValue.ele[k];
              word_obj_ptr.incrRefCount(word_obj_ptr.internalRep.list_value.ele[k]);
              argv[j++] = word_obj_ptr.listValue.elem[k];
              word_obj_ptr.incrRefCount(word_obj_ptr.listValue.elem[k]);
            }

            /* The original object reference is no longer needed,
             * after the expansion it is no longer present on
             * the argument vector, but the single elements are
             * in its place. */
            word_obj_ptr.decrRefCount(word_obj_ptr);

    /* Possibly add to the error stack trace */
    stmt.addErrorToStack(retcode, script.script_object.file_name_obj, line_no);

    /* Note that we don't have to decrement in_use, because the
     * following code transfers our use of the reference again to
     * the script object. */
    script_obj_ptr.freeIntRep(script_obj_ptr);
    script_obj_ptr.obj_type = stmt.interp.empty_obj.scriptObjType;
    script_obj_ptr.obj_type = stmt.interp.obj_types.script_obj_type;
    script_obj_ptr.setIntRepPtr(script_obj_ptr, script);
    script_obj_ptr.decrRefCount(script_obj_ptr);

print("retcode!"+stmt.interp.getResultString(retcode)+"!");
    return retcode;
  },

      throw "ERROR in OUTER evalTclStatements:!"+e+"!"+this.interp.current_statement+"!";
    }
    return result;
  },

  /* ==================== call ===================================== */
  call: function(cmd_obj, args) {
    var cmd = this;
this.call_debug = 1;
//print("CALL1");
//this.call_logs.push(args.toString());
if (this.call_debug) {
if (cmd.call_debug) {
//print("IPCALL!"+args.toString()+"!");
}
//print("interp.call arg0!"+args[0]+"!length!"+args.length+"!arg1!"+args[1]+"!lv!"+this.level+"!call_lv!"+this.call_level+"!");
    this.call_level++;
//print("interp.call arg0!"+args[0]+"!length!"+args.length+"!arg1!"+args[1]+"!lv!"+cmd.level+"!call_lv!"+cmd.call_level+"!");
    cmd.call_level++;
//print("CALL2a!"+args[0].toString()+"!");
//print("IPNS1!"+this.interp.current_namespace.full_name+"!");
//print("IPNS1!"+cmd.interp.current_namespace.full_name+"!");
//print("CA!"+args[0]+"!"+func+"!");
if (this.call_debug) {
print("interp call func!"+cmd_obj+"!type!"+cmd_obj.type+"!name!"+cmd_obj.name+"!NS!"+this.interp.command_namespace.name+"!");
if (cmd.call_debug) {
print("interp call func!"+cmd_obj+"!type!"+cmd_obj.type+"!name!"+cmd_obj.name+"!NS!"+cmd.interp.command_namespace.name+"!");
}
//print("CMD_OBJ!"+(cmd_obj instanceof this.EnsembleCommand)+"!");
//print("CMD_OBJ!"+(cmd_obj instanceof cmd.EnsembleCommand)+"!");
    var pushed = 0;
    if ((this.interp.current_namespace != this.interp.command_namespace) && (this.interp.command_namespace.name != "::")) {
      this.interp.pushNamespace(this.interp.command_namespace.name, this.interp.command_namespace);
    if ((cmd.interp.current_namespace != cmd.interp.command_namespace) && (cmd.interp.command_namespace.name != "::")) {
      cmd.interp.pushNamespace(cmd.interp.command_namespace.name, cmd.interp.command_namespace);
      pushed = 1;
    }
//print("IPNS!"+this.interp.current_namespace.full_name+"!");
    var function_args = interp.empty_obj.getStringFromArgs(args);
    if (!this.no_trace && (this.enterstep_traces.length > 0)) {
      for (var i = 0; i < this.enterstep_traces.length; i++) {
        var trace_obj = this.enterstep_traces[i];
//print("IPNS!"+cmd.interp.current_namespace.full_name+"!");
    var function_args = cmd.interp.empty_obj.getStringFromArgs(args);
    if (!cmd.no_trace && (cmd.enterstep_traces.length > 0)) {
      for (var i = 0; i < cmd.enterstep_traces.length; i++) {
        var trace_obj = cmd.enterstep_traces[i];
	var ops = trace_obj.getOps();
	for (var j = 0; j < ops.length; j++) {
          if (ops[j] == this.TRACE_OP_ENTERSTEP) {
          if (ops[j] == cmd.TRACE_OP_ENTERSTEP) {
	    var code = trace_obj.getCommand()+" {"+function_args+"} enter";
            try {
              this.no_trace = true;		    
              this.eval(code);
              this.no_trace = false;		    
              cmd.no_trace = true;		    
              cmd.eval(code);
              cmd.no_trace = false;		    
            } catch(e) {
              throw "error in executing enterstep trace: "+code+"!";
            }
          }
        }
      }
    }
if (this.call_debug) {
if (cmd.call_debug) {
print("CALL!"+args+"!"+cmd_obj+"!");
}
    var r = cmd_obj.call(this.interp, args);
if (this.call_debug) {
    var r = cmd_obj.call(cmd.interp, args);
if (cmd.call_debug) {
print("CALL after!"+r+"!");
}
    if (pushed) {
      this.interp.popNamespace();
      cmd.interp.popNamespace();
    }
    if (!this.no_trace && (this.leavestep_traces.length > 0)) {
      for (var i = 0; i < this.leavestep_traces.length; i++) {
        var trace_obj = this.leavestep_traces[i];
    if (!cmd.no_trace && (cmd.leavestep_traces.length > 0)) {
      for (var i = 0; i < cmd.leavestep_traces.length; i++) {
        var trace_obj = cmd.leavestep_traces[i];
	var ops = trace_obj.getOps();
	for (var j = 0; j < ops.length; j++) {
          if (ops[j] == this.TRACE_OP_LEAVESTEP) {
          if (ops[j] == cmd.TRACE_OP_LEAVESTEP) {
	    var result = r;
	    if (result == null) {
              result = "";
	    }
	    var code = trace_obj.getCommand()+" {"+function_args+"} "+this.code+" {"+result+"} leavestep";
	    var code = trace_obj.getCommand()+" {"+function_args+"} "+cmd.code+" {"+result+"} leavestep";
            try {
              this.no_trace = true;		    
              this.eval(code);
              this.no_trace = false;		    
              cmd.no_trace = true;		    
              cmd.eval(code);
              cmd.no_trace = false;		    
            } catch(e) {
              throw "error in executing leavestep trace: "+code+"!";
            }
          }
        }
      }
    }
    this.call_level--;
    switch (this.code) {
    case this.OK:
    case this.ERROR:
    case this.RETURN:
    cmd.call_level--;
    switch (cmd.code) {
    case cmd.OK:
    case cmd.ERROR:
    case cmd.RETURN:
      return r;
    case this.BREAK:
      if (!this.inLoop) {
    case cmd.BREAK:
      if (!cmd.inLoop) {
        throw "Invoked break outside of a loop";
      }
      break;
    case this.CONTINUE:
      if (!this.inLoop) {
    case cmd.CONTINUE:
      if (!cmd.inLoop) {
        throw "Invoked continue outside of a loop";
      }
      break;
    default:
      throw "Unknown return code " + this.code;
      throw "Unknown return code " + cmd.code;
    }
    return r;
  },

  /* ==================== evalExprSubTree ===================================== */
  evalExprSubTree: function(node, parent, lv) {
//this.eval_expr_debug = 1;