public String mySelf() {
    String str = "CallFrame!"+id+"!";
    return str;
  } 
      
  /* ==================== toString ===================================== */
  public String toString() {
    return mySelf()+(ns_ptr == null ? "null" : ns_ptr.full_name)+"!type!"+getCallTypeString(type)+"!";
  }

  /* ==================== toDebugString ===================================== */
  public String toDebugString() {
    StringBuffer str = new StringBuffer(mySelf()+"\n");
    str.append("  ref_count: "+ref_count+"\n");
    str.append("  type: "+getCallTypeString(type)+"\n");

    /* -- Put the object into the live list -- */
    my_call_frame.prev_call_frame_ptr = null;
    my_call_frame.next_call_frame_ptr = live_call_frame_list;
    if (live_call_frame_list != null) {
      live_call_frame_list.prev_call_frame_ptr = my_call_frame;
    }
    live_call_frame_list = my_call_frame;
//print("newCallFrame!"+my_call_frame.mySelf()+getCallTypeString(my_call_frame.type)+"!");
    return my_call_frame;
  }

  /* ==================== freeCallFrame ===================================== */
  /* Free an CallFrame. Actually call_frames are never freed, but
   * just moved to the free call_frames list, where they will be
   * reused by newCallFrame(). */

    CallFrame frame_ptr;
    String escaped_name;

//print("CFA!"+toDebugString()+"!");
//print("CF GetVariable!"+name+"!"+create+"!"+variables.get(name)+"!"+toDebugString()+"!");
//print("GEVFR!"+name+"!"+create+"!"+interp.var_frame_ptr.toDebugString()+"!");
    escaped_name = escapeKey(name);
if (interp.variable_obj_type.dbg != 0) {
print("callframe getvariable type!"+getCallTypeString(type)+"!");
}
    switch (type) {
    case CALL_TYPE_MACROEXPAND: 
      var_ns_ptr = interp.var_frame_ptr.ns_ptr;
      if (interp.var_frame_ptr.variables.get(escaped_name) == null) {
        if (var_ns_ptr.variables.get(escaped_name) == null) {
          if (create) {
            var_ns_ptr.variables.put(escaped_name, new Variable(interp, name, "VAR_NAMESPACE_VAR VAR_UNDEFINED", this, null));

  /* ==================== setClassObject =============================================== */
  public void setClassObject(ItclObject class_object) {
    this.class_object = class_object;
  }

  /* ==================== hasLocalVars =============================================== */
  public boolean hasLocalVars() {
if (interp.variable_obj_type.dbg != 0) {
print("call_type!"+getCallTypeString(CALL_TYPE_PROC));
}
    if (type == CALL_TYPE_PROC) {
      return true;
    }
    return false;
  }
}

  /* ==================== storeComponentInfo ================================== */
  public int storeComponentInfo(ArrayList<ApwtclObj> args) {
//print("storeComponentInfo!"+args+"!");
    int processed_args;
    int option_flags;
    ArrayList<ApwtclObj> my_args = new ArrayList<ApwtclObj>();
    ArrayList<Boolean> bool_ptr = new ArrayList<Boolean>();
    
    for (int i = 1; i < args.size(); i++) {
      my_args.add(args.get(i));
    }
//print("args!"+args+"!"+my_args+"!");
    command_option_list.resetOptionValues();
    if (command_option_list.parseOptions(my_args, 0, "itclComponent") != OK) {
//print("ERR!"+command_option_list.getErrorMsg()+"!");
      interp.setResultString(command_option_list.getErrorMsg());
      return ERROR;
    }
    option_flags = command_option_list.getOptionFlags();
    processed_args = command_option_list.getNumProcessedArgs();

    if (args.size() - processed_args > 0) {
      interp.setResultString("usage: component -public <typemethod>? ?-inherit ?<flag>?");
      return ERROR;
    }
    if ((option_flags & COMPONENT_OPTION_INHERIT) != 0) {
      int option_has_value = command_option_list.optionHasValue("-inherit");
      if (option_has_value != OPTION_HAS_NO_VALUE) {
        if (interp.int_obj_type.getBool(command_option_list.getOptionValue(COMPONENT_OPTION_INHERIT).get(0), bool_ptr) != OK) {
          return ERROR;

        }
      } else {
        if (interp.int_obj_type.getBool(interp.string_obj_type.newStringObj("1", -1, "ITCL_COMPONENT_1"), bool_ptr) != OK) {
          return ERROR;




        }
      }
      flag_inherit = bool_ptr.get(0);
    }
    if ((option_flags & COMPONENT_OPTION_PUBLIC) != 0) {
      if (interp.int_obj_type.getBool(command_option_list.getOptionValue(COMPONENT_OPTION_PUBLIC).get(0), bool_ptr) != OK) {
        return ERROR;

      }
      flag_public = bool_ptr.get(0);
    }
    return OK;
  }
}

//print("initItclObject!"+toDebugString()+"!");
    /* add to class instances */
    my_obj_ptr = interp.string_obj_type.newStringObj(object_name, -1, "ITCL_OBJECT_1");
    my_obj_ptr.incrRefCount("I_ITCL_OBJECT_1");
    class_info.instances.add(my_obj_ptr);
    /* Create a new call frame */
print("initItclObject PUSF");
    ret_code = interp.namespace_obj_type.pushStackFrame(frame_ptr_ptr, class_info.ns_ptr, CALL_TYPE_PROC);
    if (ret_code != OK) {
      return ERROR;
    }
    interp.frame_ptr.class_object = this;
    this_variable = new Variable(interp, "this", "VAR_THIS_VAR", null, class_info.ns_ptr);
    this_variable.setProtection(PROTECTION_PROTECTED);

    int processed_args;
    int option_flags;
    ArrayList<ApwtclObj> my_args = new ArrayList<ApwtclObj>();

    for (int i = 1; i < args.size(); i++) {
      my_args.add(args.get(i));
    }
print("args!"+args+"!"+my_args+"!");
    command_option_list.resetOptionValues();
    if (command_option_list.parseOptions(my_args, 0, "itclOption") != OK) {
print("ERR!"+command_option_list.getErrorMsg()+"!");
      interp.setResultString(command_option_list.getErrorMsg());
      return ERROR;
    }
    option_flags = command_option_list.getOptionFlags();
    processed_args = command_option_list.getNumProcessedArgs();
print("storeOption2!"+args.size()+"!"+processed_args);
    if (args.size() - 1 != processed_args) {
      interp.setResultString("usage: option ?option value ...? ?result?");
print("storeopt err2");
      return ERROR;
    }
    /* take care of command as args[0] */
    processed_args++;
    if ((option_flags & ITCL_OPTION_READONLY) != 0) {
      if (interp.int_obj_type.getBool(command_option_list.getOptionValue(ITCL_OPTION_READONLY).get(0), bool_ptr) != OK) {
print("storeopt err3");
    	 return ERROR;
      }
      read_only = bool_ptr.get(0);
    }
    if ((option_flags & ITCL_OPTION_DEFAULT) != 0) {
      default_value = command_option_list.getOptionValue(ITCL_OPTION_DEFAULT).get(0);
    }
    if ((option_flags & ITCL_OPTION_CGET_METHOD) != 0) {

  public String mySelf() {
    String str = "Namespace!"+id+"!";
    return str;
  } 
      
  /* ==================== toString ===================================== */
  public String toString() {
    return mySelf()+full_name+"!class_type!"+getItclClassTypeString(class_type);
  }

  /* ==================== toDebugString ===================================== */
  public String toDebugString() {
    StringBuffer str = new StringBuffer(mySelf()+"\n");
    str.append("  name: "+name+"\n");
    str.append("  full_name: "+full_name+"\n");
    str.append("  class_type: "+getItclClassTypeString(class_type)+"\n");
    str.append("  command_resolver: "+command_resolver+"\n");
    str.append("  variable_resolver: "+variable_resolver+"\n");
    str.append("  macro_resolver: "+macro_resolver+"\n");

    ArrayList<String> a1 = new ArrayList<String>();
    for (String z: variables.keySet()) {
      a1.add(z);
    }
    Collections.sort(a1);
    str.append("  variables: "+a1.toString()+"\n");

    ArrayList<String> a2 = new ArrayList<String>();
    for (String z: cmd_procs.keySet()) {
      a2.add(z);
    }
    Collections.sort(a2);
    str.append("  cmd_procs: "+a2+"\n");

    ArrayList<String> a3 = new ArrayList<String>();
    for (String z: resolve_variables.keySet()) {
      a3.add(z);
    }
    Collections.sort(a3);
    str.append("  resolve_variables: "+a3+"\n");

    ArrayList<String> a4 = new ArrayList<String>();
    for (String z: resolve_commands.keySet()) {
      a4.add(z);
    }
    Collections.sort(a4);
    str.append("  resolve_commands: "+a4.toString()+"\n");
    
    str.append("  children: "+children.keySet()+"\n");
    return str.toString();
  }

  /* ==================== getName ===================================== */
  public String getName() {
    return name;

//print("BDY!"+test_obj.mySelf()+"!"+body+"!");
//print("BDY!"+test_obj.mySelf()+"!"+test_name+"!");

    /* Create a new call frame */
    ArrayList<CallFrame> frame_ptr_ptr = new ArrayList<CallFrame>();
    ApwtclObj result;
    try {
print("tcltest runTest PUSF");
      ret_code = interp.namespace_obj_type.pushStackFrame(frame_ptr_ptr, interp.global_ns_ptr, CALL_TYPE_NAMESPACE);
    } catch(Exception e) {
print("TERR!"+e+"!");
    }
    if (ret_code != OK) {
      return ERROR;
    }

  /* ==================== initSubCmds ================================== */
  public int initSubCmds(Interp interp) {
//print("itcl initSubCmds called"+interp+"!");
    interp.command_obj_type.registerNativeSubCommand("::itcl", "body", "ItclCommand");
    interp.command_obj_type.registerNativeSubCommand("::itcl", "class", "ItclCommand");
    interp.command_obj_type.registerNativeSubCommand("::itcl", "delete", "ItclCommand");

    interp.command_obj_type.registerNativeSubCommand("::itcl", "extendedclass", "ItclCommand");
    interp.command_obj_type.registerNativeSubCommand("::itcl", "macro", "ItclCommand");
    interp.command_obj_type.registerNativeSubCommand("::itcl", "mkmember", "ItclCommand");
    interp.command_obj_type.registerNativeSubCommand("::itcl", "type", "ItclCommand");
    interp.command_obj_type.registerNativeSubCommand("::itcl", "widget", "ItclCommand");
    interp.command_obj_type.registerNativeSubCommand("::itcl", "widgetadaptor", "ItclCommand");
    interp.command_obj_type.registerNativeSubCommand("::itcl internal", "set", "ItclCommand");









    interp.command_obj_type.registerNativeCommand("::itcl::expandmacro", "ItclCommand", true);
    interp.command_obj_type.registerNativeCommand("::itcl::internal::classinfo", "ItclCommand", true);
    interp.command_obj_type.registerNativeCommand("::itcl::internal::classcget", "ItclCommand", true);
    interp.command_obj_type.registerNativeCommand("::itcl::internal::classconfigure", "ItclCommand", true);
    interp.command_obj_type.registerNativeCommand("::itcl::internal::classconfigurelist", "ItclCommand", true);
    interp.command_obj_type.registerNativeCommand("::itcl::internal::classdestroy", "ItclCommand", true);

      namespace_ptr = namespace_ptr_ptr.get(0);
    }
    /*
     * Make the specified namespace the current namespace and evaluate the
     * command(s).
     */
    frame_ptr_ptr = new ArrayList<CallFrame>();
//print("namespace eval PUSF!");
    result = interp.namespace_obj_type.pushStackFrame(frame_ptr_ptr, namespace_ptr, /*isProcCallFrame*/ 0);
    if (result != OK) {
      return ERROR;
    }
if (false) {
//    if (namesp.interp.ensembleRewrite.source_objs == null) {
//      frame_ptr.objc = args.length;

    }
    ApwtclObj package_name = args.get(1);
    ApwtclObj package_version = args.get(2);
    ApwtclObj script = null;
    if (args.size() > 3) {
      script = args.get(3);
    }
    int ret = interp.package_obj_type.setPackageScript(package_name, package_version, script, FUNCTION_FLAGS_LEAVE_ERR_MSG);
//print("package ifneeded end");
    return ret;
  }

  /* ==================== packageNamesCmd ===================================== */
  public int packageNamesCmd(Interp interp, ArrayList<ApwtclObj> args) {
print("package names called");
    if (args.size() != 2 && args.size() != 3) {
      interp.wrongNumArgs(1, args, "package ?version?");

//print("FR!"+intp.frame_ptr.toDebugString()+"!"+intp.max_nesting_depth+"!");
    if (interp.frame_ptr.level == interp.max_nesting_depth) {
      interp.setResultString("Too many nested calls. Infinite recursion?");
      return ERROR;
    }
    /* Create a new call frame */
    ArrayList<CallFrame> frame_ptr_ptr = new ArrayList<CallFrame>();
//print("commandObjType callProcedure PUSF!"+cmd_ptr+"!"+interp.frame_ptr+"!"+interp.var_frame_ptr+"!"+argv+"!");
    int result = interp.namespace_obj_type.pushStackFrame(frame_ptr_ptr, cmd_ptr.ns_ptr, CALL_TYPE_PROC);
    if (result != OK) {
      return ERROR;
    }
    call_frame_ptr = frame_ptr_ptr.get(0);
    call_frame_ptr.argv = argv;
    call_frame_ptr.argc = argc;
    call_frame_ptr.proc_args_obj_ptr = cmd_ptr.proc.arg_list_obj_ptr;
    call_frame_ptr.proc_body_obj_ptr = cmd_ptr.proc.body_obj_ptr;
    call_frame_ptr.static_vars = cmd_ptr.proc.static_vars;
    call_frame_ptr.file_name_obj = file_name_obj;
    call_frame_ptr.line = line_no;
    cmd_ptr.proc.arg_list_obj_ptr.incrRefCount("I_COMMAND_OBJ_TYPE_5");
    cmd_ptr.proc.body_obj_ptr.incrRefCount("I_COMMAND_OBJ_TYPE_6");
//print("commandObjType callProcedure evalObj0!"+interp.frame_ptr+"!"+interp.var_frame_ptr+"!");
    interp.frame_ptr = call_frame_ptr;
    /* Install a new stack for local procs */
    prev_local_procs = interp.local_procs;
    interp.local_procs = null;
    /* How many optional args are available */
    optargs = (argc - 1 - param_info.req_arity);
    /* Step 'i' along the actual args, and step 'd' along the formal args */
//print("commandObjType callProcedure evalObj1!"+cmd_ptr+"!"+interp.frame_ptr+"!"+interp.var_frame_ptr+"!");
    i = 1;
    for (d = 0; d < param_info.arg_list.size(); d++) {
      ApwtclObj name_obj_ptr = param_info.arg_list.get(d).name_obj_ptr;

      if (d == param_info.args_pos) {
        /* assign $args */
        ApwtclObj list_obj_ptr = null;

      if (retcode != OK) {
        bad_arg_set = true;
        break;
      }
    }
    if (!bad_arg_set) {
      /* Eval the body */
//print("commandObjType callProcedure evalObj!"+cmd_ptr+"!"+interp.frame_ptr+"!"+interp.var_frame_ptr+"!");
      retcode = interp.eval_statement.evalObj(cmd_ptr.proc.body_obj_ptr);
    }

    /* Destroy the call frame */
//print("commandObjType callProcedure POSF!");
    interp.namespace_obj_type.popStackFrame();
//    if (callFramePtr.vars.size != JIM_HT_INITIAL_SIZE) {
//        JimFreeCallFrame(interp, callFramePtr, JIM_FCF_NONE);
//    } else {
//        JimFreeCallFrame(interp, callFramePtr, JIM_FCF_NOHT);
//    }
    /* Handle the EVAL return code */

     * public variables go directly to the class namespace
     */
    String var_namespace = "::itcl::internal::variables"+full_class_name;
    class_info.variable_namespace = interp.namespace_obj_type.createNamespace(var_namespace);
    Namespace parse_ns_ptr = interp.variable_obj_type.findNamespace("::itcl::classdefs", interp.global_ns_ptr, NAMESPACE_CREATE_IF_UNKNOWN);
    parse_ns_ptr.setMacroResolver(new Resolve(interp, RESOLVER_TYPE_MACRO));
    ArrayList<CallFrame> frame_ptr = new ArrayList<CallFrame>();
//print("itclObjType sFA PUSF");
    interp.namespace_obj_type.pushStackFrame(frame_ptr, parse_ns_ptr, CALL_TYPE_EVAL);
//print("EV!"+interp.frame_ptr+"!");
    ret_code = interp.eval_statement.evalObj(obj_ptr);
    interp.namespace_obj_type.popStackFrame();
    if (ret_code == OK) {
      /*
       *  At this point, parsing of the class definition has succeeded.
       *  Add built-in methods such as "configure" and "cget"--as long
       *  as they don't conflict with those defined in the class.

      ItclFunction fcn_info = new ItclFunction(interp, protection, kind_val, my_name, class_info);
      if (fcn_info.storeFunctionInfo(my_args) != OK) {
        return ERROR;
      }
      interp.curr_class_info.functions.put(escapeKey(my_name), fcn_info);
      break;
    case ITCL_OPTION:
print("ITCL_OPTION1!");
      if (interp.curr_class_info.options.get(escapeKey(my_name)) != null) {
        interp.setResultString(kind+" "+my_name+" is already defined for "+getItclClassTypeString(class_info.class_type)+" \""+class_info.class_name+"\"");
        return ERROR;
      }
print("ITCL_OPTION2!");
      ItclOption opt_info = new ItclOption(interp, protection, kind_val, my_name_ptr, class_info);
      if (opt_info == null) {
        return ERROR;
      }
print("ITCL_OPTION3!");
      if (opt_info.storeOptionInfo(my_args) != OK) {
          return ERROR;
      }
print("ITCL_OPTION4!");
      interp.curr_class_info.options.put(escapeKey(opt_info.option_name), opt_info);
print("ITCL_OPTION5!");
      break;
    case ITCL_COMPONENT:
    case ITCL_TYPECOMPONENT:
      if (interp.curr_class_info.components.get(escapeKey(my_name)) != null) {
        interp.setResultString(kind+" "+my_name+" is already defined for "+getItclClassTypeString(class_info.class_type)+" \""+class_info.class_name+"\"");
        return ERROR;
      }

//print("cmd_obj4!"+cmd_obj.toDebugString()+"!");
      if (cmd_obj.is_proc) {
//        ret_code = (Integer)cmd_obj.call(interp, my_args, /* ensemble_expand */ true);
        ret_code = interp.command_obj_type.callProcedure(cmd_obj, null, 0, my_args.size(), my_args);
      } else {
        /* Create a new call frame */
        ArrayList<CallFrame>frame_ptr_ptr = new ArrayList<CallFrame>();
print("itclObjType callClassCommand PUSF");
        int result = interp.namespace_obj_type.pushStackFrame(frame_ptr_ptr, ns_ptr, CALL_TYPE_PROC);
        if (result != OK) {
          return ERROR;
        }
        /* Check if there are too nested calls */
//print("FR!"+i_obj.intp.frame_ptr.toDebugString()+"!"+i_obj.interp.max_nesting_depth+"!");
        interp.cmd_priv_data = cmd_obj.native_fcn.privdata;

   *      Modifies the interpreter's RAPL call stack.
   *
   *----------------------------------------------------------------------
   */
  public int pushCallFrame(CallFrame frame_ptr, Namespace namespace_ptr, int call_type) {
    Namespace ns_ptr;

//print("PUCF!"+namespace_ptr+"!"+getCallTypeString(call_type)+"!");
//print("VARCF!"+interp.var_frame_ptr+"!"+interp.frame_ptr+"!");
    if (namespace_ptr == null) {
      ns_ptr = getCurrentNamespace();
    } else {
      ns_ptr = namespace_ptr;
        /*
         * TODO: Examine whether it would be better to guard based on NAMESPACE_DYING
         * or NAMESPACE_KILLED. It appears that these are not tested because they can

   *----------------------------------------------------------------------
   */
  public int pushStackFrame(ArrayList<CallFrame> frame_ptr, Namespace namespace_ptr, int call_type) {
//if (call_type == 0)  {
//print("ERROR pushStackFrame calltype 0!"+frame_ptr+"!"+namespace_ptr+"!");
//}
    frame_ptr.add(interp.frame_ptr.newCallFrame(call_type, interp.frame_ptr));
//print("PUSF!"+frame_ptr.get(0).mySelf()+namespace_ptr+"!"+getCallTypeString(call_type)+"!");
    return pushCallFrame(frame_ptr.get(0), namespace_ptr, call_type);
  }

  /* ==================== popStackFrame ===================================== */
  public void popStackFrame() {
//    var free_ptr = interp.eval_statement.curr_call_frame;

  private static final int LOOKUP_MSG_MISSING_NAME = 128;
  public static final int LOOKUP_MSG_IS_ARRAY_ELEMENT = 256;

  private int id;
  private Interp interp;
  public int variable_debug;
  public boolean no_trace;
public int dbg;

  /* ==================== VariableObjType ================================== */
  public VariableObjType(Interp interp) {
    oid++;
    id = oid;

    this.interp = interp;

      return TOKEN_VAR_ARRAY_NAME;
    }
//print("varobjtype sFA 3");
    ApwtclObj part1_ptr = interp.string_obj_type.newStringObj(var_name, -1, "VARIABLE_OBJ_TYPE_1");
    part1_ptr.incrRefCount("I_VARIABLE_OBJ_TYPE_1");
    ArrayList<String> lookup_err_msg_ptr = new ArrayList<String>();
    ArrayList<Integer> lookup_index_ptr = new ArrayList<Integer>();
if (dbg != 0) {
print("sFA call lookupSimpleVar");
}
    Variable var_obj_ptr = lookupSimpleVar(part1_ptr, FUNCTION_FLAGS_LEAVE_ERR_MSG, /* create_part1 */ false, lookup_err_msg_ptr, lookup_index_ptr);
if (dbg != 0) {
print("sFA after call lookupSimpleVar");
}
    part1_ptr.decrRefCount("D_VARIABLE_OBJ_TYPE_1");
if (dbg != 0) {
print("varobjtype sFA 4!"+var_obj_ptr+"!"+frame_ptr.ns_ptr.toDebugString()+"!");
}
    if (var_obj_ptr == null) {
      err_msg_ptr_ptr.add(lookup_err_msg_ptr.get(0));
      return ERROR;
    }
    err_msg_ptr_ptr.add(null);
    /* Free the old internal repr and set the new one. */
    obj_ptr.freeIntRep();

  public int setVariable(ApwtclObj name_obj_ptr, ApwtclObj val_obj_ptr, ArrayList<Variable> result_var_ptr) {
    String name;
    Variable var_ptr;
    boolean create = true;
    int err;
    ArrayList<String> err_msg_ptr = new ArrayList<String>();
if (name_obj_ptr.getString().equals("extrainits")) {
dbg = 0;
} else {
dbg = 0;
}
if (dbg != 0) {
print("setVariable1!"+name_obj_ptr+"!"+val_obj_ptr+"!"+interp.frame_ptr+"!"+interp.var_frame_ptr+"!");
}

    if ((err = setFromAny(name_obj_ptr, err_msg_ptr)) != OK) {
if (dbg != 0) {
print("setVariable NOT OK");
}
//print("setVariable2 not OK!"+err_msg_ptr+"!");
      CallFrame frame_ptr = interp.frame_ptr;

      /* Check for array names like syntax. */
      if (err == TOKEN_VAR_ARRAY_NAME) {
//print("setVariable2a!"+name_obj_ptr+"!"+interp.frame_ptr.ns_ptr+"!");
        int ret = interp.array_obj_type.arraySet(name_obj_ptr, val_obj_ptr, result_var_ptr);
//print("setVariable2b!"+name_obj_ptr+"!"+interp.frame_ptr.ns_ptr.toDebugString()+"!");
        return ret;
      }
      if (interp.validName("variable", name_obj_ptr) != OK) {
        result_var_ptr.add(null);
        return ERROR;
      }
      /* if we did not find the variable it cannot be a namespace variable
       * as namespace variables are created with VAR_UNDEFINED, if not initialized
       * if err_msg_ptr is null
       * only exception global variables starting with :: like ::abc need
       * special handling here
       */
if (dbg != 0) {
print("setVariable3!"+name_obj_ptr.getString()+"!"+err_msg_ptr+"!");
}
      String err_msg = err_msg_ptr.get(0);
      if (err_msg_ptr != null) {
        String my_name = name_obj_ptr.getString();
        if (my_name.indexOf("::") >= 0) {
          if (my_name.substring(2).indexOf("::") > 0) {
            interp.setResultString(err_msg);
            result_var_ptr.add(null);
            return ERROR;
          }
          /* special handling for global variables !! */
        } 
      }
      /* New variable to create */
      // FIXME need to get tail of variable name here !!
      name = name_obj_ptr.getString();
      if (name.charAt(0) == ':' && name.charAt(1) == ':') {
        name = name.substring(2);
      }
      var_ptr = frame_ptr.getVariable(name, create);
if (dbg != 0) {
print("setVariable a!"+name+"!"+var_ptr+"!"+create+"!"+interp.frame_ptr.ns_ptr.toDebugString()+"!"+interp.frame_ptr.toDebugString()+"!");      
}
//print("SEV!"+name+"!"+frame_ptr.variables.get(name)+"!"+interp.var_frame_ptr.variables.get(name)+"!"+frame_ptr.toDebugString()+"!"+interp.var_frame_ptr.toDebugString()+"!");
      result_var_ptr.add(var_ptr);
      var_ptr.obj_ptr = val_obj_ptr;
      val_obj_ptr.incrRefCount("I_VARIABLE_OBJ_TYPE_2");
      var_ptr.link_frame_ptr = null;
      /* Make the object int rep a variable */
      name_obj_ptr.freeIntRep();
      name_obj_ptr.obj_type = OBJ_TYPE_VARIABLE;
      name_obj_ptr.varValue_SetCallFrame(null);
//print("SEVNS!"+frame_ptr.ns_ptr);
      name_obj_ptr.varValue_SetNamespace(frame_ptr.ns_ptr);
      name_obj_ptr.varValue_SetVarPtr(var_ptr);
      if ((var_ptr.type & VAR_UNDEFINED) != 0) {
        var_ptr.type &= ~VAR_UNDEFINED;
      }
      handleVariableTrace(name_obj_ptr, null, TRACE_OP_WRITE, "write", null);
    } else {
if (dbg != 0) {
print("setVariable OK");
}
//print("SEV2!");
      var_ptr = name_obj_ptr.varValue_GetVarPtr();
      if ((var_ptr.type & VAR_UNDEFINED) != 0) {
        var_ptr.type &= ~VAR_UNDEFINED;
      }
      if (var_ptr.link_frame_ptr == null) {
        val_obj_ptr.incrRefCount("I_VARIABLE_OBJ_TYPE_3");

   *
   * If FUNCTION_FLAGS_UNSHARED is set and the variable is an array element (dict sugar)
   * in a dictionary which is shared, the array variable value is duplicated first.
   * This allows the array element to be updated (e.g. append, lappend) without
   * affecting other references to the dictionary.
   */
  public ApwtclObj getVariable(ApwtclObj name_obj_ptr, int flags, ArrayList<Variable> result_var_ptr) {
if (dbg != 0) {
print("getVariable1!"+name_obj_ptr+"!");
}
//print("GEV!"+name_obj_ptr+"!"+interp.var_frame_ptr.variables.get(name_obj_ptr.getString())+"!"+interp.var_frame_ptr.variables.get(name_obj_ptr.getString())+"!"+interp.frame_ptr.toDebugString()+"!"+interp.var_frame_ptr.toDebugString()+"!");
//print("getVariable1!"+name_obj_ptr+"!");
    ArrayList<String> err_msg_ptr_ptr = new ArrayList<String>();
    switch (setFromAny(name_obj_ptr, err_msg_ptr_ptr)) {
    case OK:
if (dbg != 0) {
print("getVariable2!"+name_obj_ptr+"!");
}
      Variable var_ptr = name_obj_ptr.varValue_GetVarPtr();

      result_var_ptr.add(var_ptr);
      if (!no_trace) {
        handleVariableTrace(name_obj_ptr, null, TRACE_OP_READ, "read", var_ptr);
      }
      if (var_ptr.link_frame_ptr == null) {
if (dbg != 0) {
print("getVariable3!"+"@@@"+var_ptr.obj_ptr+"!");
}
        return var_ptr.obj_ptr;
      } else {
//print("getVariable4!");
        ApwtclObj obj_ptr;

        /* The variable is a link? Resolve it. */
        CallFrame saved_call_frame = interp.frame_ptr;

      break;

    case TOKEN_VAR_ARRAY_NAME:
//print("+++getVariable2array!"+name_obj_ptr+"!");
      /* ARRAY. */
      return interp.array_obj_type.arrayGet(name_obj_ptr, flags, result_var_ptr);
    }
if (dbg != 0) {
print("getVariable not ok!"+name_obj_ptr+"!");
}
    if ((flags & FUNCTION_FLAGS_LEAVE_ERR_MSG) != 0) {
      interp.setResultString("can't read \""+name_obj_ptr.getString()+"\": no such variable");
    }
    result_var_ptr.add(null);
    return null;
  }

      if (entry != null) {
        ns_ptr = entry;
      } else {
        if ((flags & NAMESPACE_CREATE_IF_UNKNOWN) != 0) {
          CallFrame frame_ptr = interp.frame_ptr.newCallFrame(/* call_type */ CALL_TYPE_NAMESPACE, interp.frame_ptr);
          ArrayList<CallFrame> frame_ptr_ptr = new ArrayList<CallFrame>();
          frame_ptr_ptr.add(frame_ptr);
//print("variableObjType getNamespaceForQualName PUSF");
          interp.namespace_obj_type.pushStackFrame(frame_ptr_ptr, ns_ptr, /* call_type */ CALL_TYPE_NAMESPACE);
          ns_ptr = interp.namespace_obj_type.createNamespace(ns_name);
          interp.namespace_obj_type.popStackFrame();
          if (ns_ptr == null) {
            panic(true, "could not create namespace '"+ns_name+"'");
          }
        } else {  /* namespace not found and was not created */

   *----------------------------------------------------------------------
   */
  public Variable lookupSimpleVar(ApwtclObj var_name_ptr, int flags, boolean create, ArrayList<String>err_msg_ptr, ArrayList<Integer> index_ptr) {
if (variable_debug > 0) {
print("lookupSimpleVar!"+var_name_ptr+"!cfr!"+interp.var_frame_ptr.toDebugString()+"!flags!"+flags+"!crp1!"+create+"!");
print("FLAGS!"+getVarLookupTypeString(flags)+"!");
}
if (dbg != 0) {
print("lookupSimpleVar!"+interp.var_frame_ptr+"!");
}
    CallFrame var_frame_ptr = interp.var_frame_ptr;
    ArrayList<Object> var_obj_ptr = new ArrayList<Object>();
    Variable var_obj = null;
    Variable var_ptr = null;
    int result;
    Resolve res_ptr = null;
    ArrayList<Namespace> var_ns_ptr = null;

     *    3) the active frame was pushed to define the namespace context for a
     *       "namespace eval" or "namespace inscope" command,
     *    4) the name has namespace qualifiers ("::"s).
     * Otherwise, if var_name is a local variable, search in the call frame variables
     *
     * If create and the variable isn't found, create the variable
     */
if (dbg != 0) {
print("LL!"+((flags & (NAMESPACE_LOOKUP_GLOBAL_ONLY | NAMESPACE_LOOKUP_NAMESPACE_ONLY)) != 0)+"!"+!var_frame_ptr.hasLocalVars()+"!"+var_name.matches("::.*")+"!");
print("CF!"+var_frame_ptr+"!");
}
    if (((flags & (NAMESPACE_LOOKUP_GLOBAL_ONLY | NAMESPACE_LOOKUP_NAMESPACE_ONLY)) != 0)
        || !var_frame_ptr.hasLocalVars()
        || var_name.matches("::.*")) {
      boolean look_global = ((flags & NAMESPACE_LOOKUP_GLOBAL_ONLY) != 0)
        || (ctx_ns_ptr == interp.global_ns_ptr)
        || ((var_name.charAt(0) == ':') && (var_name.charAt(1) == ':'));
if (variable_debug > 1 || dbg != 0) {
print("look_gobal!"+look_global+"!"+var_frame_ptr.hasLocalVars()+"!"+var_frame_ptr.toDebugString()+"!");
}
      if (look_global) {
        index_ptr.add( -1);
        flags = (flags | NAMESPACE_LOOKUP_GLOBAL_ONLY) & ~NAMESPACE_LOOKUP_NAMESPACE_ONLY;
      } else {
        if ((flags & VAR_LOOKUP_AVOID_RESOLVERS) != 0) {

interp alias {} ::itcl::type {} ::itcl type
interp alias {} ::itcl::macro {} ::itcl macro
interp alias {} ::itcl::body {} ::itcl body
interp alias {} ::itcl::mkmember {} ::itcl mkmember
interp alias {} ::itcl::internal::classcget {} ::itcl internal classcget
interp alias {} ::itcl::internal::classconfigure {} ::itcl internal classconfigure
interp alias {} ::itcl::internal::classinstall {} ::itcl internal classinstall
interp alias {} ::itcl::internal::set {} ::itcl internal set
package ifneeded itcl 4.0b6 {
    namespace eval ::itcl { # init
    }
    source [file join $dir itclParse.tcl]
    package provide itcl 4.0b6
}