/* Note: in Rapl the message is already set from lookupSimpleVar */
//      array_obj.interp.setResultFormatted("can't %s \"%#s\": variable isn't array", (val_obj_ptr ? "set" : "unset"), obj_ptr);
    }
    return ret_code;
  },

  /* ==================== arrayGet ================================== */
  arrayGet: function(obj_ptr, flags, result_var_ptr) {
    var array_obj = this;
    var subst_key_obj_ptr = new Array();
    var retcode;
    var create_part1 = 0;
    var err_msg_ptr = new Array();
    var index_ptr = new Array();

    array_obj.setFromAny(obj_ptr);
    if (array_obj.interp.script_obj_type.substObj(obj_ptr.arrayValue.indexObjPtr(), subst_key_obj_ptr, array_obj.FUNCTION_FLAGS_NONE) != array_obj.OK) {
      return null;
    }
    subst_key_obj_ptr = subst_key_obj_ptr[0]
    subst_key_obj_ptr.incrRefCount();
    var_ptr = array_obj.interp.variable_obj_type.lookupSimpleVar(obj_ptr.arrayValue.varNameObjPtr(), 0, create_part1, err_msg_ptr, index_ptr);
    if (var_ptr != null) {
      array_obj.interp.variable_obj_type.handleVariableTrace(subst_key_obj_ptr.getString(), array_obj.TRACE_OP_READ, "read");
    }
    retcode = array_obj.interp.dict_obj_type.expandArrayVariable(obj_ptr.arrayValue.varNameObjPtr(), subst_key_obj_ptr, flags, result_var_ptr);
    subst_key_obj_ptr.decrRefCount();
    return retcode;
  },

  /* ==================== expandArray ================================== */
  /* This function is used to expand array get in the form
   * of $var(INDEX). The function is mainly used by EvalObj()

  /*
   * Expands the array variable and returns the result, or null on error.
   *
   * If array_obj.FUNCTION_FLAGS_UNSHARED is set and the dictionary is shared,
   * it will be duplicated
   * and stored back to the variable before expansion.
   */
  expandArrayVariable: function(var_obj_ptr, key_obj_ptr, flags, result_var_ptr) {
    var dct = this;
    var dict_obj_ptr;
    var res_obj_ptr = new Array();
    var ret;
    var save_no_trace;
   
    save_no_trace = dct.interp.variable_obj_type.no_trace;
    dct.interp.variable_obj_type.no_trace = true;
    dict_obj_ptr = dct.interp.variable_obj_type.getVariable(var_obj_ptr, dct.FUNCTION_FLAGS_LEAVE_ERR_MSG, result_var_ptr);
    dct.interp.variable_obj_type.no_trace = save_no_trace;
    if (!dict_obj_ptr) {
      return null;
    }
    ret = dct.interp.dict_obj_type.dictKey(dict_obj_ptr, key_obj_ptr, res_obj_ptr, dct.FUNCTION_FLAGS_NONE);
    res_obj_ptr = res_obj_ptr[0];
    if (ret != dct.OK) {

        wC = (Alen != Blen || sA == sB);
      }
      break;
    case exp.TOKEN_EXPROP_STRIN:
      wC = exp.searchList(B, A);
      break;
    case exp.TOKEN_EXPROP_STRNI:
      wC = !exp.searchList(B, A);
      break;
    default:
      abort();
    }
    exp.exprPush(e, exp.interp.int_obj_type.newIntObj(wC));
    A.decrRefCount();
    B.decrRefCount();

      intp.frame_ptr.top_command_oid = R.Base.command_oid;
      intp.frame_ptr.top_itcl_command_oid = R.Base.itcl_command_oid;
      intp.frame_ptr.top_class_function_oid = R.Base.class_function_oid;
    }
    /* FIXME !! need to not use cache for these otherwise problems
     * have to figure out why
     */
if (intp.getcommand_debug) {
print("getCommand!"+cmd_name+"!");
}
    switch (cmd_name.toString()) {
    case "constructor":
    case "destructor":
    case "join":
    case "function":
      cmd_obj = null;
      break;

    var ns_ptr;
    var class_only = 0;
    var class_info;
    var class_object;
    var object_name;
    var object_namespace;
    var cmd_obj;
    var my_args = new Array();
    var retcode;

    var usage = "should be \""+class_name+" method ?arg ...?"
    if (args.length == 0) {
      itcl.interp.setResultString(usage);
      return itcl.ERROR;
    }
//print("class_name!"+class_name+"!"+itcl.interp.frame_ptr.ns_ptr+"!"+itcl.interp.frame_ptr.ns_ptr.parent_namespace+"!");

    }
    class_name = ns_ptr.name;
    cmd_obj = itcl.interp.global_ns_ptr.getClassCommand(ns_ptr, cmd_name, class_only);
    if (cmd_obj == null) {
      /* command not found seems to be creation of a class */
      var re = new RegExp("(.*)(#auto)(.*)");
      var res = re.exec(cmd_name);
      if (res == null) {
        re = new RegExp("(.*)(%AUTO%)(.*)");
        res = re.exec(cmd_name);
      }
      if (res != null) {
        var head = res[1];
	var trailer = res[3];
	class_name = class_name;
	var my_class_name = class_name.substring(0,1).toLowerCase()+class_name.substring(1);
	while (true) {
	  var cnt = ns_ptr.getAutoCount();

        cmd_name = object_name;
        break;
      case itcl.ITCL_CLASS:
      case itcl.ITCL_EXTENDEDCLASS:
        break;
      }
    } else {
      var cmd_ptr;
//print("classCommand 3!"+args+"!");
//print("cmd!"+cmd_obj+"!");
      if (typeof cmd_obj.ns_ptr.resolve_commands[itcl.escape_key(cmd_name)] != "undefined") {
        cmd_ptr = cmd_obj.ns_ptr.resolve_commands[itcl.escape_key(cmd_name)];
//print("CMD_PTR!"+cmd_ptr+"!");
        if (cmd_ptr.is_proc) {
           my_args.push(args[1]);
           for (var k = 2; k < args.length; k++) {
             my_args.push(args[k]);
             args[k].incrRefCount();
           }
          retcode = cmd_ptr.u.proc.cmd_proc(cmd_ptr, itcl.interp.empty_obj, -1, my_args.length, my_args);
          return retcode;
        }
      }
      itcl.interp.setResultString("direct classname function call for: \""+cmd_name+"\" not yet implemented");
      return itcl.ERROR;
    }
    itcl.interp.setResultString(cmd_name);
    return itcl.OK;
  },

      /* Call [unknown] */
      ret_code = i_obj.interp.unknownFcn(my_args.length, my_args, i_obj.interp.empty_obj, -1);
    }
    name_ptr.decrRefCount();
    for (var k = 0; k < args.length; k++) {
      args[k].decrRefCount();
    }
//print("callClassCommand END!"+ns_ptr+"!"+fcn_name+"!"+class_object+"!"+args+"!");
    return ret_code;
  },


  /* ==================== classObjectCommand ================================== */
  classObjectCommand: function(ns_ptr, class_object, args) {
//print("classObjectCommand!"+ns_ptr+"!"+class_object+"!"+args+"!");

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

  /* ==================== command array names  ===================================== */
  interp.registerSubCommand("::array", "names", function (interp, args) {
    interp.setResultString("array names not yet reimplemented");
    return interp.ERROR;
    this.requireArgcRange(args, 2, 4, "array names", "");
    throw "array names not yet implemented"
  });

  /* ==================== command array set  ===================================== */
  interp.registerSubCommand("::array", "set", function (interp, args) {
    interp.setResultString("array set not yet reimplemented");
    return interp.ERROR;
    this.requireExactArgc(args, 3, "array set", "");
    throw "array set not yet implemented"
  });

  /* ==================== command array size  ===================================== */
  interp.registerSubCommand("::array", "size", function (interp, args) {
    interp.setResultString("array size not yet reimplemented");
    return interp.ERROR;
    this.requireExactArgc(args, 2, "array size", "");
    throw "array size not yet implemented"
  });

  /* ==================== command array unset  ===================================== */
  interp.registerSubCommand("::array", "unset", function (interp, args) {
    interp.setResultString("array unset not yet reimplemented");
    return interp.ERROR;
    this.requireArgcRange(args, 2, 3, "array unset", "");
    throw "array unset not yet implemented"
  });

  R.log('constructor end', '2.life', 'PkgArray', true);
}

      if (var_obj != null) {
        var_obj.setValue(e);
      }
      return 1;
    }
    return 0;
  });

  /* ==================== command concat ===================================== */
  interp.registerCommand("::concat", function (interp, args) {
    interp.setResult(interp.default_obj.concatObj(args.length - 1, args.slice(1)));
    return interp.OK;
  });

  /* ==================== command continue ===================================== */
  interp.registerCommand("::continue", function (interp, args) {
    interp.code = this.CONTINUE;
    return;
  });

    if (args.length != 2) {
      interp.wrongNumArgs(1, args, "option_name");
      return interp.ERROR;
    }
    class_object = interp.frame_ptr.getClassObject();
    var class_ptr = class_object.class_info;
    var option_name = args[1];
    class_option_obj = class_object.getClassOptionObj(option_name);
    if (class_option_obj.my_name == "ItclDelegate") {
      return class_option_obj.delegateCget(option_name);
    }
    if (class_option_obj == null) {
      interp.setResultString("cget no such option: \""+option_name+"\"");
      return interp.ERROR;
    }
    var cget_method = class_option_obj.cget_method;
    if (cget_method == null) {
      /* look if cgetmethodvar is set */
      var cget_method_var = class_option_obj.cget_methodvar;
      if (cget_method_var == null) {
        /* just do "normal" cget */
        switch (class_ptr.class_type) {
        case interp.ITCL_TYPE_CLASS:
        case interp.ITCL_WIDGET:
        case interp.ITCL_WIDGETADAPTOR:
          name_ptr = interp.string_obj_type.newStringObj("options("+option_name.getString()+")", -1);
	  var var_ptr = new Array();
          obj_ptr = interp.variable_obj_type.getVariable(name_ptr, interp.FUNCTION_FLAGS_LEAVE_ERRMSG, var_ptr);
	  var_ptr = var_ptr[0];
//print("OP!"+option_name+"!"+name_ptr+"!"+obj_ptr.toDebugString()+"!"+var_ptr.toDebugString()+"!");
          break;
        case interp.ITCL_EXTENDEDCLASS:
        case interp.ITCL_CLASS:
          name_ptr = interp.string_obj_type.newStringObj("itcl_options("+option_name.getString()+")", -1);
          obj_ptr = interp.variable_obj_type.getVariable(name_ptr);
          break;
	}
	interp.setResult(obj_ptr);
      } else {
        /* get the method from the var */
// FIXME !!! need code here
      }
    } else {
      var cmd_obj = interp.string_obj_type.newStringObj(cget_method+" "+option_name, -1);
      cmd_obj.incrRefCount();

    var option_val = null;
    var option_name;
    var class_option_obj;
    var result;
    var cmd_obj;
    var ret_code = interp.OK;
    var my_args;
    var name_ptr;
    var_obj_ptr;

//print("::itcl::internal::classconfigure!"+args+"!"+args.length+"!ns!"+interp.frame_ptr.ns_ptr.full_name+"!");

    if (args.length < 2) {
      interp.wrongNumArgs(1, args, "option_name");
      return interp.ERROR;
    }
    class_object = interp.frame_ptr.getClassObject();
    class_ptr = class_object.class_info;
    if (args.length == 0) {
      /* return all option names */
      interp.setResultString("configure all not yet implemented!");
      return interp.ERROR;
    } else {
      option_name = args[1];
      class_option_obj = class_object.getClassOptionObj(option_name);
      if (class_option_obj.my_name == "ItclDelegate") {
        return class_option_obj.delegateConfigure(option_name, option_val);
      }
      if (class_option_obj == null) {
print("class_object!"+option_name+"!"+class_object.toDebugString()+"!");
        interp.setResultString("configure no such option: \""+option_name+"\"");
	return interp.ERROR;
      }
      result = "";
      if (args.length == 2) {
        /* return info about an option */
        // FIXME for that case the configuremethod seems not to be relevant at least for type class
        configure_method = null;
//        configure_method = class_option_obj.configure_method;
//print("configure:get option!"+option_name+"!configure_method!"+configure_method+"!");
	if (configure_method == null) {
          /* look if configuremethodvar is set */
          // FIXME see above comment
          configure_method_var = null;
//          configure_method_var = class_option_obj.configure_method_var;
	  if (configure_method_var == null) {
            /* just do "normal" configure */
            switch (class_ptr.class_type) {
            case interp.ITCL_TYPE_CLASS:
            case interp.ITCL_WIDGET:
            case interp.ITCL_WIDGETADAPTOR:
              name_ptr = interp.string_obj_type.newStringObj("options("+option_name.getString()+")", -1);
	      var var_ptr = new Array();
              obj_ptr = interp.variable_obj_type.getVariable(name_ptr, interp.FUNCTION_FLAGS_LEAVE_ERRMSG, var_ptr);
	      var_ptr = var_ptr[0];
//print("OP!"+option_name+"!"+name_ptr+"!"+obj_ptr.toDebugString()+"!"+var_ptr.toDebugString()+"!");
              break;
            case interp.ITCL_EXTENDEDCLASS:
            case interp.ITCL_CLASS:
              name_ptr = interp.string_obj_type.newStringObj("itcl_options("+option_name.getString()+")", -1);
              obj_ptr = interp.variable_obj_type.getVariable(name_ptr);
              break;
	    }
	    interp.setResult(obj_ptr);
	    return interp.OK;

          } else {
print("configure_method_var not yet implemented");
            /* get the method from the var */
// FIXME !!! need code here
	  }
        } else {
print("configure_method not yet implemented");
	}
      } else {
        if (args.length == 3) {
          /* set an option */
	  option_val = args[2];
	  if (class_option_obj.my_name == "ItclDelegate") {
	    return class_option_obj.delegateConfigure(option_name, option_val);
	  } else {

      command_obj.decrRefCount();
    }
    return rc;
  });

  /* ==================== command lset ===================================== */
  interp.registerCommand("::lset", function (interp, args) {
    interp.setResultString("lset not yet reimplemented");
    return interp.ERROR;
    this.requireMinArgc(args, 4, "lset", "");
    var list = interp.getVarValue(args[1].toString()).toList();
    var elt = list;
    for (var i = 2; i < args.length-2; i++) {
      elt.toList();
      elt = interp.statement_parser.objectify(elt.value[elt.listIndex(args[i])]);
    }
    elt.toList();
    i = args.length - 2;
    elt.value[elt.listIndex(args[i])] = interp.statement_parser.objectify(args[i+1]);
    return list;
  });

  /* ==================== command lsort ===================================== */
  interp.registerCommand("::lsort", function (interp, args) {
    interp.setResultString("lsort not yet reimplemented");
    return interp.ERROR;
    this.requireExactArgc(args, 2, "lsort", "");
    return args[1].toList().sort();
  });

  R.log('constructor end', '2.life', 'PkgList', true);
}

  PkgNamespace.superclass.constructor.apply(namesp, arguments);

  R.Base.pkg_namespace_oid++;
  namesp.oid = R.Base.pkg_namespace_oid;

  /* ==================== command namespace children ===================================== */
  interp.registerSubCommand("::namespace", "children", function (interp, args) {
    interp.setResultString("namespace children not yet reimplemented");
    return interp.ERROR;
    this.requireArgcRange(args, 1, 3, "namespace children", "");
    throw "namespace children not yet implemented";
  });

  /* ==================== command namespace current ===================================== */
  interp.registerSubCommand("::namespace", "current", function (interp, args) {
    var curr_ns_ptr;

    var ret = interp.eval_statement.evalObj(obj_ptr);
    interp.namespace_obj_type.popStackFrame();
    return ret;
  });

  /* ==================== command namespace exists ===================================== */
  interp.registerSubCommand("::namespace", "exists", function (interp, args) {
    interp.setResultString("namespace exists not yet reimplemented");
    return interp.ERROR;
    args.shift();
    this.requireExactArgc(args, 1, "namespace exists", "");
    var ns_name = args.shift().toString();
    try {
      var ns = interp.global_ns_ptr.getNamespace(ns_name);
      return interp.statement_parser.objectify("1");
    } catch(e) {
      return interp.statement_parser.objectify("0");
    }
  });

  /* ==================== command namespace parent ===================================== */
  interp.registerSubCommand("::namespace", "parent", function (interp, args) {
    interp.setResultString("namespace parent not yet reimplemented");
    return interp.ERROR;
    args.shift();
    this.requireArgcRange(args, 0, 1, "namespace parent", "");
    throw "namespace parent not yet implemented";
  });

  /* ==================== command namespace qualifiers ===================================== */
  interp.registerSubCommand("::namespace", "qualifiers", function (interp, args) {

print("NSUPVAR OK!"+ns_name+"!"+other_var+"!"+my_var+"!");
    }
    throw "namespace upvar not yet implemented";
  });

  /* ==================== command namespace unknown ===================================== */
  interp.registerSubCommand("::namespace", "unknown", function (interp, args) {
    interp.setResultString("names unknown not yet reimplemented");
    return interp.ERROR;
    args.shift();
    this.requireArgcRange(args, 0, 1, "namespace unknown", "");
    if (args.length > 0) {
        var script = args.shift();
        interp.current_namespace.setUnknownHandler(script);
    } else {
        return interp.current_namespace.getUnknownHandler();
    }
  });

  /* ==================== command namespace which ===================================== */
  interp.registerSubCommand("::namespace", "which", function (interp, args) {
    interp.setResultString("namespace which not yet reimplemented");
    return interp.ERROR;
    args.shift();
    this.requireArgcRange(args, 1, 3, "namespace which", "");
    throw "namespace which not yet implemented";
  });

  R.log('constructor end', '2.life', 'PkgNamespace', true);
}

    }
    interp.setResultInt(args[idx].stringCompareObj(args[idx + 1], !opt_case));
    return interp.OK;
  });

  /* ==================== command string index ===================================== */
  interp.registerSubCommand("::string", "index", function (interp, args) {
    interp.setResultString("string index not yet reimplemented");
    return interp.ERROR;
    this.requireExactArgc(args, 3, "string index", "");
    var s = args[1].toString();
    try {
      return s.charAt(args[1].stringIndex(args[2]));
    } catch (e) {
      return "";
    }

     ret_code = args[i].stringMatchObj(args[i+1], !opt_case);
    interp.setResultBool(ret_code == interp.OK);
    return interp.OK;
  });

  /* ==================== command string range ===================================== */
  interp.registerSubCommand("::string", "range", function (interp, args) {
    interp.setResultString("string range not yet reimplemented");
    return interp.ERROR;
    this.requireExactArgc(args, 4, "string range", "");
    var s = args[1];
    try {
      var b = s.stringIndex(args[2].toString());
      var e = s.stringIndex(args[3].toString());
      if (b > e) return "";
      return s.toString().substring(b, e + 1);

        }
        /* Error, so fall through to the error message */
      }
      break;

    case varbl.TOKEN_VAR_ARRAY_NAME:
      /* ARRAY. */
      return varbl.interp.array_obj_type.arrayGet(name_obj_ptr, flags, result_var_ptr);
    }
    if (flags & varbl.FUNCTION_FLAGS_LEAVE_ERR_MSG) {
      intp.setResultFormatted("can't read \""+name_obj_ptr.getString()+"\": no such variable");
    }
    return null;
  },