}
    }
    return result_str;
  });

  /* ==================== command join ===================================== */
  interp.registerCommand("::join", function (interp, args) {

    var join_str;
    var join_str_len;
    var i;
    var list_len;
    var res_obj_ptr;

    if (args.length != 2 && args.length != 3) {

      interp.list_obj_type.listIndex(args[1], i, obj_ptr, interp.FUNCTION_FLAGS_NONE);
      obj_ptr = obj_ptr[0];
      interp.string_obj_type.appendObj(res_obj_ptr, obj_ptr);
      if (i + 1 != list_len) {
        interp.string_obj_type.appendString(res_obj_ptr, join_str, join_str_len);
      }
    }

    interp.setResult(res_obj_ptr);
    return interp.OK;
  });

  /* ==================== command jsdebug ===================================== */
  interp.registerCommand("::jsdebug", function (interp, args) {
    args.shift();

      print(args[1]);
    }
    return interp.OK;
  });

  /* ==================== command proc ===================================== */
  interp.registerCommand("::proc", function (interp, args) {
    var full_name;
    var ns_ptr = new Array();
    var alt_ns_ptr = new Array();
    var cxt_ns_ptr = new Array();
    var proc_name = new Array();

    if (args.length != 4 && args.length != 5) {
      interp.wrongNumArgs(1, args, "name arglist ?statics? body");
      return interp.ERROR;
    }
    /*
     * Determine the namespace where the procedure should reside. Unless the
     * command name includes namespace qualifiers, this will be the current
     * namespace.
     */
    full_name = args[1].getString();
    interp.variable_obj_type.getNamespaceForQualName(full_name, null, 0, ns_ptr, alt_ns_ptr, cxt_ns_ptr, proc_name);
    ns_ptr = ns_ptr[0];
    alt_ns_ptr = alt_ns_ptr[0];
    cxt_ns_ptr = cxt_ns_ptr[0];
    proc_name = proc_name[0];
    if (ns_ptr == null) {
      interp.setResultString("can't create procedure \""+full_name+"\": unknown namespace");
      interp.setErrorCode(["TCL", "VALUE", "COMMAND"]);
      return interp.ERROR;
    }
    if ((ns_ptr != interp.global_ns_ptr) && (proc_name != null) && (proc_name.charAt(0) == ':')) {
      interp.setResultString("can't create procedure \""+proc_name+"\" in non-global namespace with name starting with \":\"");
      interp.setErrorCode(["TCL", "VALUE", "COMMAND"]);
      return interp.ERROR;
    }
    if (args.length == 4) {
      return interp.command_obj_type.createProcedure(args[1], args[2], null, args[3], ns_ptr);
    } else {
      return interp.command_obj_type.createProcedure(args[1], args[2], args[3], args[4], ns_ptr);
    }
  });

  /* ==================== command regexp ===================================== */
  interp.registerCommand("::regexp", function (interp, args) {
    var regcomp_flags = 0;
    var regexp;

    option_flags = option_flags[0];
    options = options[0];
    if (args.length - processed_args > 2) {
      interp.setResultString("usage: return ?option value ...? ?result?");
      return interp.ERROR;
    }
    /* take care of command as args[0] */

    processed_args++;

    if (option_flags & core_cmd.return_options.RETURN_OPT_ERRORCODE) {
      error_code_obj = options["-errorcode"] ;
      throw "return -errorcode not yet implemented"
    }
    if (option_flags & core_cmd.return_options.RETURN_OPT_CODE) {
      code = options["-code"];
      if (interp.return_code_obj_type.getReturnCode(code, result) == interp.ERROR) {

//print("TT!"+((sec_msec()-t0)*1000/n + " microseconds per iteration")+"!");
    interp.setResult(interp.string_obj_type.newStringObj((sec_msec()-t0)*1000/n + " microseconds per iteration", -1));
    return interp.OK;
  });

  /* ==================== command uplevel ===================================== */
  interp.registerCommand("::uplevel", function (interp, args) {

    if (args.length >= 2) {

      var retcode;

      var saved_callframe;
      var target_callframe;
      var obj_ptr;
      var str;
      var argc = args.length;
      var i = 1;





      /* Save the old callframe pointer */
      saved_callframe = interp.frame_ptr;
      /* Lookup the target frame pointer */
      str = args[1].getString();
      if ((str.charAt(0) >= '0' && str.charAt(0) <= '9') || strcharAt(0) == '#') {
        target_callframe = interp.getCallFrameByLevel(args[i]);
        argc--;
	i++;
      } else {

        target_callframe = interp.getCallFrameByLevel(null);

      }
      if (target_callframe == null) {
        return interp.ERROR;
      }
      if (argc < 2) {
        i--;
        interp.wrongNumArgs(1, args, "?level? command ?arg ...?");
        return interp.ERROR;
      }
      /* Eval the code in the target callframe. */
      interp.frame_ptr = target_callframe;

      if (argc == 2) {

        retcode = interp.eval_statement.evalObj(args[i]);
      } else {
        obj_ptr = interp.concatObj(argc - 1, args.slice(i));

        obj_ptr.incrRefCount();
        retcode = interp.evalObj(obj_ptr);
        obj_ptr.decrRefCount();

      }
      interp.frame_ptr = saved_callframe;
      return retcode;
    } else {
      interp.wrongNumArgs(1, args, "?level? command ?arg ...?");
      return interp.ERROR;
    }


  });

  /* ==================== command upvar ===================================== */
  interp.registerCommand("::upvar", function (interp, args) {
//print("UPVAR!"+args+"!");
    args.shift();
    this.requireMinArgc(args, 2, "upvar", "");

      /*
       * If a value was specified, set the variable to that value.
       * Otherwise, if the variable is new, leave it undefined. (If the
       * variable already exists and no value was specified, leave its value
       * unchanged; just create the local link if we're in a RAPL procedure).
       */
      if (i + 1 < args.length) {	/* A value was specified. */




        var_value_ptr = interp.variable_obj_type.ptrSetVar(var_ptr, array_ptr, var_name_ptr, null, args[i + 1],
            interp.NAMESPACE_LOOKUP_NAMESPACE_ONLY | interp.FUNCTION_FLAGS_LEAVE_ERR_MSG, -1);
        if (var_value_ptr == null) {
          return interp.ERROR;
        }
      }
      /*