case stmt.TOKEN_VAR_ARRAY_NAME:
    case stmt.TOKEN_VAR:
      result_var_ptr[0] = null;
      obj_ptr = stmt.interp.variable_obj_type.getVariable(token.obj_ptr, stmt.FUNCTION_FLAGS_LEAVE_ERR_MSG, result_var_ptr);
      result_var_ptr = result_var_ptr[0];
      /* special case for ::itcl::type type variable !! */
      if (obj_ptr == null && result_var_ptr != null && token.obj_ptr.getString() == "type") {
        obj_ptr = stmt.interp.string_obj_type.newStringObj(result_var_ptr.namespace.full_name, -1, "EVAL_STATEMENT_1");
        obj_ptr.incrRefCount("I_EVAL_STATEMENT_1");
      }
      if (stmt.interp.frame_ptr.type == stmt.CALL_TYPE_MACROEXPAND) {
        /* if we are expanding a macro and we find a not escaped variable not in the
	 * parameter/argument list, for the macro, we ignore that and return the variable
	 * as "$var_name" instead
	 */
        if (obj_ptr == null) {
          obj_ptr = stmt.interp.string_obj_type.newStringObj("$"+token.obj_ptr.getString(), -1, "EVAL_STATEMENT_2");
	  stmt.interp.setResult(stmt.interp.empty_string_obj);
	} else {
          /* if we are expanding a macro and the variable is a list put it into {} to be safe */
          if (obj_ptr.obj_type = stmt.interp.list_obj_type) {
            obj_ptr = stmt.interp.string_obj_type.newStringObj("{"+obj_ptr.getString()+"}", -1, "EVAL_STATEMENT_3");
	  }
	}
      } else {
        if (stmt.had_macro_cmd) {
          obj_ptr = stmt.interp.string_obj_type.newStringObj("$"+token.obj_ptr.getString(), -1, "EVAL_STATEMENT_4");
	}
      }
      break;
    case stmt.TOKEN_ARRAY_NAME_VAR:
      obj_ptr = JimExpandDictSugar(stmt.interp, token.obj_ptr);
      break;
    case stmt.TOKEN_EXPRSUGAR:
      obj_ptr = stmt.interp.expr_obj_type.expandExprSugar(token.obj_ptr);
      break;
    case stmt.TOKEN_BRACE:
      if (!stmt.in_quotes) {
        obj_ptr = token.obj_ptr;
      } else {
        if (token.obj_ptr.len == 0) {
          /* we have a single pair of {} within quotes,
	   * so make a corresponding string object 
	   */
	  obj_ptr = stmt.interp.string_obj_type.newStringObj("{}", -1, "EVAL_STATEMENT_5");
	} else {
        switch (stmt.interp.script_obj_type.substObj(token.obj_ptr, result_ptr, stmt.FUNCTION_FLAGS_LEAVE_ERR_MSG)) {
        case stmt.OK:
	  obj_ptr = result_ptr[0];
	  /* special handling for expand in quotes !! */
	  if (obj_ptr.len == 1 && obj_ptr.bytes.substring(0,1) == "*") {
            obj_ptr.len = 3;

      retcode = stmt.substOneToken(script, idx + i, result_ptr);
      intv2[j] = result_ptr[0];
if (stmt.eval_ipol_debug > 1) {
print("RES!"+result_ptr[0]+"!"+intv2+"!"+retcode+"!");
script.dumpToken(i+idx);
}
      if (intv2[j] != null) {
        intv2[j].incrRefCount("I_EVAL_STATEMENT_2");
      }
      switch(retcode) {
      case stmt.OK:
      case stmt.RETURN:
        break;
      case stmt.BREAK:
        if (flags & stmt.SUBST_FLAG) {

          continue;
        }
        /* XXX: Ditto continue outside loop */
        /* fall through to error */
      default:
        while (j--) {
          if (intv2[j] != null) {
            intv2[j].decrRefCount("D_EVAL_STATEMENT_1");
	  }
        }
        intv2 = null;
	stmt.in_quotes = my_in_quotes;
        return null;
      }
      total_len += intv2[j].toString().length;
      j++;
    }

    /* Fast path return for a single token */
    if (word_tokens == 1 && intv2[0]) {
      intv2[0].decrRefCount("D_EVAL_STATEMENT_2");
      stmt.in_quotes = my_in_quotes;
      return intv2[0];
    }

    /* Concatenate every token in an unique
     * object. 
     */
    obj_ptr = stmt.interp.string_obj_type.newStringObjNoAlloc(null, 0, "EVAL_STATEMENT_6");

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

    obj_ptr.bytes = "";
    obj_ptr.length = total_len;
    for (i = 0; i < j; i++) {
      if (intv2[i]) {
        obj_ptr.bytes += intv2[i].toString();
        intv2[i].decrRefCount("D_EVAL_STATEMENT_3");
      }
    }
//    obj_ptr.bytes[total_len] = '\0';
    obj_ptr.len = total_len;
    /* Free the intv2 vector. */
    intv2 = null;
if (stmt.eval_ipol_debug > 1) {

      retcode = stmt.evalObjList(script_obj_ptr, stmt.interp.empty_obj, 1);
      if (stmt.macro_cmd_level == stmt.eval_level) {
        stmt.had_macro_cmd = false;
      }
      stmt.eval_level--;
      return retcode;
    }
    script_obj_ptr.incrRefCount("I_EVAL_STATEMENT_4");     /* Make sure it's shared. */
    script = script_obj_ptr.interp.script_obj_type.getScript(script_obj_ptr);
    if (script == null) {
      stmt.interp.setResultString("error in parsing script: \""+script_obj_ptr+"\"");
      if (stmt.macro_cmd_level == stmt.eval_level) {
        stmt.had_macro_cmd = false;
      }
      stmt.eval_level--;
      return stmt.ERROR;
    }

    /* Reset the interpreter result. This is useful to
     * return the empty result in the case of empty program. */
    script_obj_ptr.interp.setEmptyResult();

    /* Check for one of the following common scripts used by for, while
     *
     *   {}
     *   incr a
     */
    if (script.len == 0) {
      script_obj_ptr.decrRefCount("D_EVAL_STATEMENT_4");
      if (stmt.macro_cmd_level == stmt.eval_level) {
        stmt.had_macro_cmd = false;
      }
      stmt.eval_level--;
      return stmt.OK;
    }
    if (script.len == 3
        && script.script_object.tokens[1].obj_ptr.obj_type.type_name == "command"
        && script.script_object.tokens[1].obj_ptr.cmdValue.cmdPtr().is_proc == false
        && script.script_object.tokens[1].obj_ptr.cmdValue.cmdPtr().u.native_fcn.cmd_proc == script.interp.incrCoreCommand
        && script.script_object.tokens[2].obj_ptr.obj_typ.type_name == "variable") {

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

      if (obj_ptr && !obj_ptr.isShared() && obj_ptrobj_type.name == "int") {
//        JimWideValue(obj_ptr)++;
        obj_ptr.invalidateStringRep();
        script_obj_ptr.decrRefCount("D_EVAL_STATEMENT_5");
        stmt.interp.setResult(obj_ptr);
        if (stmt.macro_cmd_level == stmt.eval_level) {
          stmt.had_macro_cmd = false;
        }
        stmt.eval_level--;
        return stmt.OK;
      }

          case stmt.TOKEN_VAR:
	    var result_var_ptr = new Array();
	    result_var_ptr[0] = null;
            word_obj_ptr = stmt.interp.variable_obj_type.getVariable(token[i].obj_ptr, stmt.FUNCTION_FLAGS_LEAVE_ERR_MSG, result_var_ptr);
	    result_var_ptr = result_var_ptr[0];
            /* special case for ::itcl::type type variable !! */
            if (word_obj_ptr == null && result_var_ptr != null && token[i].obj_ptr.getString() == "type") {
              word_obj_ptr = stmt.interp.string_obj_type.newStringObj(result_var_ptr.namespace.full_name, -1, "EVAL_STATEMENT_7");
              word_obj_ptr.incrRefCount("I_EVAL_STATEMENT_5");
            }
            break;
          case stmt.TOKEN_EXPRSUGAR:
            word_obj_ptr = stmt.expandExprSugar(token[i].obj_ptr);
            break;
          case stmt.TOKEN_ARRAY_NAME_VAR:
            word_obj_ptr = stmt.expandDictSugar(token[i].obj_ptr);

	if (!had_comment) {
          if (!word_obj_ptr) {
            if (retcode == stmt.OK) {
              retcode = stmt.ERROR;
            }
            break;
          }
          word_obj_ptr.incrRefCount("I_EVAL_STATEMENT_6");
          if (!expand) {
	    if (!had_comment) {
              argv.push(word_obj_ptr);
	    }
          } else {
            /* Need to expand word_obj_ptr into multiple args from argv[j] ... */
            var len = stmt.interp.list_obj_type.listLength(word_obj_ptr);
            var newargc = argc + len - 1;
            var k;
  
//print("EXPAND!"+argc+"!"+len+"!"+newargc+"!"+word_obj_ptr.toDebugString()+"!");
            /* Now copy in the expanded version */
            for (k = 0; k < len; k++) {
              argv.push(word_obj_ptr.listValue.elem()[k]);
	      j++;
              word_obj_ptr.listValue.elem()[k].incrRefCount("I_EVAL_STATEMENT_7");
            }
            /* 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("D_EVAL_STATEMENT_6");
            /* And update the indexes */
            j--;
            argc += len - 1;
          }
        }
      }
      if (had_comment) {

            retcode = stmt.interp.unknownFcn(argc, argv, script.script_object.file_name_obj, line_no);
	  } else {
            /* we do not call unknown, if we had only the empty string as command and no arguments */
	  }
        }
      }
//      /* Finished with the command, so decrement ref counts of each argument */
      for (j = 0; j < argv.length; j++) {

        argv[j].decrRefCount("D_EVAL_STATEMENT_7");
      }
      argv = new Array();
    }

    /* 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 ref_count, because the
     * following code transfers our use of the reference again to
     * the script object. */
    script_obj_ptr.freeIntRep();
    script_obj_ptr.obj_type = stmt.interp.script_obj_type;
    script_obj_ptr.setIntRepPtr(script);
    script_obj_ptr.decrRefCount("D_EVAL_STATEMENT_8");
//print("EVALOBJ end level!"+stmt.eval_level+"!"+retcode+"!");
    if (stmt.macro_cmd_level == stmt.eval_level) {
      stmt.had_macro_cmd = false;
    }
    stmt.eval_level--;
    return retcode;
  },

    var stmt = this;
    var i;
    var retcode;
    var cmd_ptr;

    /* Incr refcount of arguments. */
    for (i = 0; i < objc; i++) {
      objv[i].incrRefCount("I_EVAL_STATEMENT_8");
    }
    /* Command lookup */
    cmd_ptr = stmt.interp.getCommand(objv[0], stmt.interp.FUNCTION_FLAGS_LEAVE_ERR_MSG);
//print("EOV!"+cmd_ptr.toDebugString()+"!");
    if (cmd_ptr == null) {
      retcode = stmt.interp.unknown(objc, objv, file_name_obj, line_no);
    } else {

        stmt.interp.cmd_priv_data = cmd_ptr.u.native_fcn.priv_data;
        retcode = cmd_ptr.u.native_fcn.cmd_proc(stmt.interp, objv);
      }
      cmd_ptr.decrCmdRefCount();
    }
    /* Decr refcount of arguments and return the retcode */
    for (i = 0; i < objc; i++) {
      objv[i].decrRefCount("D_EVAL_STATEMENT_9");
    }
    return retcode;
  },

  /* ==================== evalObjVector ===================================== */
  evalObjVector: function(objc, objv) {
    var stmt = this;

      if (my_str.match(" ") != null) {
        my_str += sep+"{"+args[i]+"}";
      } else {
        my_str += sep+args[i];
      }
      sep = " ";
    }
    my_ptr = stmt.interp.string_obj_type.newStringObj(my_str, -1, "EVAL_STATEMENT_8");
    my_ptr.incrRefCount("I_EVAL_STATEMENT_9");
    ret_code = stmt.evalObj(my_ptr);
    my_ptr.decrRefCount("D_EVAL_STATEMENT_10");
    return ret_code;
  },

  /* ==================== evalObjList ===================================== */
  /* If list_ptr is a list, call evalObjVector() with the given source info.
   * Otherwise eval with evalObj()
   */
  evalObjList: function (list_ptr, file_name_obj, linenr) {
    var stmt = this;
    var retcode = stmt.OK;

    stmt.interp.panic(!list_ptr.isListObj(), "evalObjList() called without list arg");
    if (list_ptr.listValue.len()) {
      list_ptr.incrRefCount("I_EVAL_STATEMENT_10");
      retcode = stmt.evalObjVector(list_ptr.listValue.len(), list_ptr.listValue.elem(), file_name_obj, linenr);
      list_ptr.decrRefCount("D_EVAL_STATEMENT_11");
    }
    return retcode;
  },

  /* ==================== commandMatchObj ===================================== */
  /* Returns 1 if match, 0 if no match or -<error> on error (e.g. -stmt.ERROR, -stmt.BREAK)*/
  commandMatchObj: function(command_obj, pattern_obj, string_obj, nocase) {
    var stmt = this;
    var parms = new Array();
    var argc = 0;
    var eq = new Array();
    var rc;

    parms[argc++] = command_obj;
    if (nocase) {
      parms[argc++] = stmt.interp.string_obj_type.newStringObj("-nocase", -1, "EVAL_STATEMENT_9");
    }
    parms[argc++] = pattern_obj;
    parms[argc++] = string_obj;
    rc = stmt.evalObjVector(argc, parms);
    if (rc != stmt.OK || stmt.interp.int_obj_type.getLong(stmt.interp.getResult(), eq) != stmt.OK) {
      eq[0] = -rc;
    }
    return eq[0];
  },

  /* ==================== addErrorToStack ===================================== */
  addErrorToStack: function(retcode, file_name_obj, line) {
    var stmt = this;
    var rc = retcode;

    if (rc == stmt.ERROR && !stmt.interp.error_flag) {
        /* This is the first error, so save the file/line information and reset the stack */
        stmt.interp.error_flag = 1;
        file_name_obj.incrRefCount("I_EVAL_STATEMENT_11");
        stmt.interp.error_file_name_obj.decrRefCount("D_EVAL_STATEMENT_12");
        stmt.interp.error_file_name_obj = file_name_obj;
        stmt.interp.error_line = line;
        stmt.resetStackTrace();
        /* Always add a level where the error first occurs */
        stmt.interp.add_stack_trace++;
    }

         * don't clear the addStackTrace flag
         * so we can pick it up at the next level
         */
        if (file_name_obj.getStringLength()) {
          stmt.interp.add_stack_trace = 0;
        }

        stmt.interp.error_proc.decrRefCount("D_EVAL_STATEMENT_13");
        file_name_obj.interp.error_proc = stmt.interp.empty_obj;
        stmt.interp.error_proc.incrRefCount("I_EVAL_STATEMENT_12");
    } else {
      if (rc == stmt.RETURN && stmt.interp.return_code == stmt.ERROR) {
        /* Propagate the addStackTrace value through 'return -code error' */
      } else {
        stmt.interp.add_stack_trace = 0;
      }
    }
  },

  /* ==================== resetStackTrace ===================================== */
  resetStackTrace: function() {
    var stmt = this;
    stmt.interp.stack_trace.decrRefCount("D_EVAL_STATEMENT_14");
    stmt.interp.stack_trace = stmt.interp.list_obj_type.newListObj(null, 0);
    stmt.interp.stack_trace.incrRefCount("I_EVAL_STATEMENT_13");
  },

  /* ==================== setStackTrace ===================================== */
  setStackTrace: function(stack_trace_obj) {
    var stmt = this;
    var len;

    /* Increment reference first in case these are the same object */
    stack_trace_obj.incrRefCount("I_EVAL_STATEMENT_14");
    stmt.interp.stack_trace.decrRefCount("D_EVAL_STATEMENT_15");
    stmt.interp.stack_trace = stack_trace_obj;
    stmt.interp_error_flag = 1;

    /* This is a bit ugly.
     * If the filename of the last entry of the stack trace is empty,
     * the next stack level should be added.
     */

    }
    if (!procname && !file_name_obj.getStringLength()) {
      /* No useful info here */
      return;
    }

    if (stmt.interp.stack_trace.isShared()) {
      stmt.interp.stack_trace.decrRefCount("D_EVAL_STATEMENT_16");
      stmt.interp.stack_trace = file_name_obj.duplicateObj(stmt.interp.stack_trace);
      stmt.interp.stack_trace.incrRefCount("I_EVAL_STATEMENT_15");
    }

    /* If we have no procname but the previous element did, merge with that frame */
    if (!procname && file_name_obj.getStringLength()) {
      /* Just a filename. Check the previous entry */
      var len = stmt.interp.list_obj_type.listLength(stmt.interp.stack_trace);

      if (len >= 3) {
        var obj_ptr;
        if (stmt.interp.list_obj_type.listIndex(stmt.interp.stack_trace, len - 3, obj_ptr, stmt.FUNCTION_FLAGS_NONE) == stmt.OK && obj_ptr.getStringLength()) {
          /* Yes, the previous level had procname */
          if (stmt.interp.list_obj_type.listIndex(stmt.interp.stack_trace, len - 2, objPtr, stmt.FUNCTION_FLAGS_NONE) == stmt.OK && !obj_ptr.getStringLength()) {
            /* But no filename, so merge the new info with that frame */
            stmt.interp.list_obj_type.listSetIndex(stmt.interp.stack_trace, len - 2, file_name_obj, 0);
            stmt.interp.list_obj_type.listSetIndex(stmt.interp.stack_trace, len - 1, stmt.interp.int_obj_type.newIntObj(linenr), 0);
            return;
          }
        }
      }
    }
    stmt.interp.list_obj_type.listAppendElement(stmt.interp.stack_trace, stmt.interp.string_obj_type.newStringObj(procname, -1, "EVAL_STATEMENT_10"));
    stmt.interp.list_obj_type.listAppendElement(stmt.interp.stack_trace, file_name_obj);
    stmt.interp.list_obj_type.listAppendElement(stmt.interp.stack_trace, stmt.interp.int_obj_type.newIntObj(linenr));
  },

});

EvalStatement.prototype.constructor = EvalStatement;

R.EvalStatement = EvalStatement;

}, "0.0.1", {});