/* ==================== ApwtclClassLoader ================================== */
  public ApwtclClassLoader(Interp interp, String path) {
    oid++;
    id = oid;

    this.path = path;
System.out.println("ApwtclClassLoader!"+path+"!");
  }

  /* ==================== mySelf ================================== */
  public String mySelf() {
    String str = "ApwtclClassLoader!"+id+"!";
    return str;
  } 

  /* ==================== myFindClass ===================================== */
  public Class<?> myFindClass(String name) {
    Class<?> my_class = null;
    String class_name = null;
    try {
      class_name = path.replaceAll("/",".")+"."+name;
      my_class = Class.forName(class_name, false, this);
System.out.println("found class!"+name+"!"+my_class+"!");
    } catch (Exception e) {
System.out.println("not found!"+class_name+"!"+e.getMessage()+"!");
      byte[] b = loadClassData(name);
System.out.println("name!"+name+"!");
      name = path.replaceAll("/",".")+"."+name;
System.out.println("name2!"+name+"!");
      return defineClass(name, b, 0, b.length);
    }
    return my_class;
  }

  /* ==================== loadClassData ===================================== */
  private byte[] loadClassData(String name) {
//    File file = new File("/home/arnulf/workspace/apwtcl/bin/"+path+"/"+name+".class");
    File file = new File(path+"/"+name+".class");

System.out.println("FF!"+file+"!"+file.canRead()+"!"+file.length()+"!");
    int len = (int)file.length();
    FileInputStream fin = null;
    try {
      fin = new FileInputStream(file);
    } catch (Exception e) {
      System.out.println("Exception fin!"+e.getMessage()+"!");
//      file = new File(path+"/"+name+".class");
      file = new File("/home/arnulf/workspace/apwtcl/bin/"+path+"/"+name+".class");
      len = (int)file.length();
      try {
        fin = new FileInputStream(file);
      } catch (Exception e1) {
  	    System.out.println("Exception 2 fin!"+e1.getMessage()+"!");
        return null;
      }
    }
//System.out.println("FFin!"+fin+"!");
    byte[] b = new byte[len];
    try {
      fin.read(b);
      fin.close();
    } catch (Exception e) {
      System.out.println("Exception read!"+e.getMessage()+"!");
    }
//System.out.println("RES!"+res+"!");
    return b;
  }
}

import java.util.ArrayList;
import java.util.HashMap;

public class CommandOption extends Token implements Debug {
  private static int oid = 0;

  private int id;


  public String opt_name;        /* Name of this option */
  public int opt_code;           /* Defined value for this option */
                                 /* the code has to be a unique bit! within an OptionList */
  public int opt_has_value;      /* this option has a value =1 or not = 0 or it can have one or not = -1*/
  public ArrayList<ApwtclObj> default_value; /* value for that option to be used as default */
  public HashMap<String, Integer> allowed_option_values; /* allowed values for that option */


  /* ==================== CommandOption ================================== */
  public CommandOption(Interp interp, String opt_name, int opt_code, int opt_has_value, 
		  ArrayList<ApwtclObj> default_value, HashMap<String, Integer> allowed_option_values) {
    oid++;
    id = oid;


    this.opt_name = opt_name;
    this.opt_code = opt_code;
    this.opt_has_value = opt_has_value;
    this.default_value = default_value;
    this.allowed_option_values = allowed_option_values;
  }

 *
 * Copyright 2012 Arnulf P. Wiedemann
 *
 */

package org.apwtcl.lang;


import java.util.Hashtable;


public class Defines extends Object {
  public static final int OK = 0;
  public static final int ERROR = 1;
  public static final int RETURN = 2;
  public static final int BREAK = 3;
  public static final int CONTINUE = 4;

}
      switch (my_ret) {
      case OK:
      case RETURN:
if (my_ret == RETURN) {
print("+++substonetoken RETURN!");
}
//print("SUBST!"+interp.result+"!");
        obj_ptr = interp.result;
        break;
      case BREAK:
        /* Stop substituting */
    	result_ptr.add(null);
        return BREAK;
      case CONTINUE:

      interp.setEmptyResult();
      if (cmd_ptr.is_proc) {
//print("call callProcedure!"+objc+"!"+objv+"!");
        retcode = interp.command_obj_type.callProcedure(cmd_ptr, file_name_obj, line_no, objc, objv);
//print("after callProcedure!");
      } else {
        interp.cmd_priv_data = cmd_ptr.native_fcn.privdata;
//        Object ret = null;
        try {
//          ret = cmd_ptr.native_fcn.cmd_proc.invoke(cmd_ptr.native_fcn.instance, interp, objv);
          retcode = (Integer)cmd_ptr.call(interp, objv, /* ensemble_expand */ true);
        } catch (Exception e) {
          e.printStackTrace();
System.out.println("Exception call2!"+e.getMessage()+"!");
        }

      }
    }
  }

  /* ==================== appendStackTrace ===================================== */
  /* Returns 1 if the stack trace information was used or 0 if not */
  public void appendStackTrace(String procname, ApwtclObj file_name_obj, int linenr) {
    if (procname != null && procname.equals("unknown")) {
      procname = "";
    }
    if (procname == null && file_name_obj.getStringLength() == 0) {
      /* No useful info here */
      return;
    }

 *
 */

package org.apwtcl.lang;

import java.io.File;
import java.io.FileInputStream;
// import java.lang.reflect.Method;
import java.util.ArrayList;

public class Helpers extends Defines {

  /* ==================== Helpers ================================== */
  public Helpers() {
  }

      return null;
    }
    long len = file.length();
//print("len!"+len+"!");
    byte[] bytes = new byte[(int)len];
    try {
      int my_len = file_st.read(bytes);
      file_st.close();
      if (my_len != (int)len) {
        interp.setResultString("cannot read full file: "+url+"! got: "+my_len+" expected: "+len);
        return null;
      }
    } catch (Exception e) {
      interp.setResultString("no such file: "+url+"!");
      return null;
    }
//print("file contents!"+new String(bytes)+"!");
	return new String(bytes);  
  }
  
  /* ==================== source ===================================== */
  public int source(Interp interp, String url) {
    String response_text;
    ApwtclObj script;

  //  Method read_file = null;
  //  Method read_fcn = null;
  //  Method read = null;
    int result = ERROR;
  //  ApwtclObj my_obj_ptr;
    ApwtclObj xhr_object;

    interp.curr_file_name = url;
    url = interp.start_dir+"/"+url;
//print("source!"+url+"!win!"+interp.win+"!");
    xhr_object = null;
    if (interp.win != null) {
//    try {
//      if(interp.win.ActiveXObject != null) {    // Internet Explorer
//        xhr_object = new ActiveXObject("Microsoft.XMLHTTP");
//      }
//    } catch(Exception e) {
//    }
      if (xhr_object == null) {
//        if(interp.win.XMLHttpRequest != null) { // Firefox
//          xhr_object = new XMLHttpRequest();
//        } else { // XMLHttpRequest not supported by the browser
//          if (read_file != null) {
//            response_text = readFile(url);
//            result = interp.eval_statement.evalObj(interp.string_obj_type.newStringObj(response_text, -1, "BASE_1"));
//            return result;
//          } else {
//            print("Your browser does not support XMLHTTP requests. " +
//                  "Sorry that we cannot deliver this page.");
//            return result;

//          }
//        }
        }
      } else {
//        read_fcn = null;
//        if (read_file != null) {
//          read_fcn = read_file;

//        }
//        if (read != null) {
//          read_fcn = read;

//        }
//        if (read_fcn != null) {
//print("source rhino2!"+url+"!"+interp.current_namespace.full_name+"!");
//          response_text = read_fcn(url);
          response_text = getFileContents(interp, url);
//print("source!"+url+"!"+responseText+"!");
//print("responseText!"+responseText+"!");
          script = interp.string_obj_type.newStringObj("::set dir "+interp.current_dir+"\n"+response_text, -1, "BASE_2");

     *  Scan through all classes in the hierarchy, from most to
     *  least specific.  Add a lookup entry for each variable
     *  into the table.
     */
    for (int i = 0; i < my_classes.size(); i++) {
      class_ptr = my_classes.get(i);
      for (String key: class_ptr.variables.keySet()) {
        // int var_type = ITCL_VARIABLE;
        my_variable_obj = class_ptr.variables.get(key);
        ItclVariableLookup vlookup = new ItclVariableLookup(interp, my_variable_obj);
        vlookup.accessible = (my_variable_obj.protection != PROTECTION_PRIVATE || class_ptr == this);
        if (my_variable_obj.type == ITCL_COMMON) {
          // var_type = VAR_COMMON;
        }
        /*
         *  Create all possible names for this variable and enter
         *  them into the variable resolution table:
         *     var
         *     class::var
         *     namesp1::class::var

  /* ==================== ItclMacro ================================== */
  public ItclMacro(Interp interp, String name, ApwtclObj params, ApwtclObj body) {
    oid++;
    id = oid;

    this.interp = interp;
    if (this.interp == null) {
    	
    }

    this.macro_name = name;
    this.arglist = params;
    this.body = body;

  }

    return str.toString();
  }

  /* ==================== initItclObject ========================================== */
  public int initItclObject() {
    int ret_code = OK;
    boolean err = false;
    // CallFrame result;
    ArrayList<CallFrame> frame_ptr_ptr = new ArrayList<CallFrame>();
    ApwtclObj self_obj_ptr;
    ApwtclObj value_ptr;
    ApwtclObj this_obj_ptr;
    ApwtclObj my_obj_ptr;
    String inst_ns_name = null;

     return ret_code;
  }

  /* ==================== callDestructors ========================================== */
  public int callDestructors() {
    int result = OK;
//print("callDestructors for!"+this.name+"!"+this.class_obj.full_name+"!");
    // ArrayList<ItclClass> heritage = class_info.ns_ptr.getHeritage();
    Command my_destructor = class_info.ns_ptr.getDestructor(class_info.full_name.getString());
    /* FIXME need to call the other destructors here !!! */
//    int class_type = dict_helpers.getDictInfo("classes", class_info.full_name, "type");
//    if (class_type < 0) {
//      print("now such class. \""+class_name+"\"");
//      return ERROR;
//    }
//    ApwtclObj function_dict = dict_helpers.getDictInfo("classFunctions", class_obj.fullclass_name, "destructor");
//    if (function_dict == null) {
//      print("now such command: \"destructor\" in class. \""+class_obj.full_name+"\"");
//      return ERROR;
//    }

    if (my_destructor != null) {
      // ArrayList<ApwtclObj> my_args = new ArrayList<ApwtclObj>();
//      result = my_destructor.call(interp, my_args);
    }
    return result;
  }

  /* ==================== checkForInitializedComponents =============================== */
  public int checkForInitializedComponents() {

  }

  /* ==================== initObjectVariables ========================================== */
  public int initObjectVariables() {
    ItclVariable class_var_ptr;
    Variable var_ptr;
    ApwtclObj var_name_ptr;
    // ApwtclObj var_value_ptr;
    String var_type;

    for (String var_name: class_info.resolve_variables.keySet()) {
      class_var_ptr = class_info.resolve_variables.get(escapeKey(var_name)).var_ptr;
      switch (class_var_ptr.type) {
      case ITCL_TYPE_VARIABLE:
        var_type = "VAR_TYPE_VAR";

  /* ==================== ItclVariable ================================== */
  public ItclVariable(Interp interp, int protection, int type, String var_name, ArrayList<ApwtclObj> args, ItclClass class_info) {
    oid++;
    id = oid;

    this.interp = interp;
    if (this.interp == null) {
    	
    }
    this.protection = protection;
    this.type = type;
    this.var_name = var_name;
    this.state = VARIABLE_STATE_NO_INIT;
    this.class_info = class_info;
    if (args.size() > 0) {
      init_val = args.get(0);

  /* ==================== ItclVariableLookup ================================== */
  public ItclVariableLookup(Interp interp, ItclVariable var_ptr) {
    oid++;
    id = oid;
    
    this.interp = interp;
    if (this.interp == null) {
    	
    }
    this.var_ptr = var_ptr;
    this.usage = 0;
    this.least_qual_name = null;
    this.accessible = false;
  }

  /* ==================== mySelf ================================== */

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

    this.interp = interp;
    if (this.interp == null) {
    	
    }
    this.instance_info = new HashMap<String, Object>();
    this.instance_initted = new HashMap<String, Boolean>();
    this.class_methods = new HashMap<String, String>();
  }

  /* ==================== mySelf ================================== */
  public String mySelf() {

  public int flags;
  private int command_path_length;
  public int cmd_ref_epoch;
  private String class_command;
  public HashMap<String, Namespace> children;
  private HashMap<String, Command> class_functions;
  // private HashMap<String, Variable> class_variables;
  public HashMap<String, Command> resolve_commands;
  public HashMap<String, Variable> resolve_variables;
  public HashMap<String, Command> cmd_procs;
  public HashMap<String, Variable> variables;
  public Resolve variable_resolver;
  public Resolve command_resolver;
  private Resolve macro_resolver;

    command_path_array = null;
    ref_count = 0;
    cmd_ref_epoch = 0;
    class_command = null;
    parent_namespace = null;  // null means :: global namespace
    children = new HashMap<String, Namespace>();
    class_functions = new HashMap<String, Command>();
    // class_variables = new HashMap<String, Variable>();
    resolve_commands = new HashMap<String, Command>();
    resolve_variables = new HashMap<String, Variable>();
    variables = new HashMap<String, Variable>();
    cmd_procs = new HashMap<String, Command>();
    variable_resolver = null;
    command_resolver = null;
    macro_resolver = null;

  public int getNamespaceType() {
    return class_type;
  }

  /* ==================== setNamespaceClassCommand ===================================== */
  public void setNamespaceClassCommand(String name) {
    class_command = name;
    if (class_command == null) {
    	
    }
  }

  /* ==================== setFullName ===================================== */
  public void setFullName(String full_name) {
    this.full_name = full_name;
  }

  /* ==================== PackageInfo ================================== */
  public PackageInfo(Interp interp, ApwtclObj package_name, ApwtclObj version, ApwtclObj script) {
    oid++;
    id = oid;

    this.interp = interp;
    if (this.interp == null) {
    	
    }
    this.package_name = package_name;
    this.version = version;
    this.script = script;
  }

  /* ==================== mySelf ================================== */
  public String mySelf() {

  public Object instance;

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

    this.interp = interp;
    if (this.interp == null) {
    	
    }
    arg_list_obj_ptr = null;
    body_obj_ptr = null;
    static_vars = null;
    prev_cmd = null;
    upcall = false;
    cmd_proc = null;
    instance = null;
  }

  /* ==================== mySelf ================================== */
  public String mySelf() {
    String str = "Proc!"+id+"!";
    return str;
  } 

    return CONTINUE;
  }

  /* ==================== resolveVariable ===================================== */
  public int resolveVariable(String var_name, Namespace ns_ptr, int flags, ArrayList<Object> result_ptr) {
    ItclVariableLookup class_var_ptr = null;
    Variable var_ptr = null;
    // ItclVariableLookup vlookup = null;
    ItclClass class_ptr;
    boolean special_name = false;
    ItclObject class_object = interp.frame_ptr.getClassObject();
if (variable_debug != 0) {
print("resolveVariable1!"+var_name+"!"+ns_ptr+"!"+flags+"!"+interp.variable_obj_type.getFlagsString(flags)+"!"+class_object+"!");
}
    if (class_object == null) {

      return null;
    }
  }

  /* ==================== getProps ===================================== */
  public int getProps() {
//FIXME !!!
    // ArrayList<ApwtclObj> props = new ArrayList<ApwtclObj>();
    ApwtclObj result;

//    Set<String> keys = configure_options.keySet();
//    Iterator<String> iter = keys.iterator();
//    while (iter.hasNext()) {
//      String z = iter.next();
//      if (configure_options.get(z) != null) {

 *
 */

package org.apwtcl.lang.cmd;

import java.util.ArrayList;

//import org.apwtcl.lang.CallFrame;
//import org.apwtcl.lang.Command;
import org.apwtcl.lang.Interp;
import org.apwtcl.lang.ApwtclObj;
import org.apwtcl.lang.Token;
import org.apwtcl.lang.Variable;

public class ArrayCommand extends Token {

package org.apwtcl.lang.cmd;

import java.util.ArrayList;
import org.apwtcl.lang.Interp;
import org.apwtcl.lang.ApwtclObj;
import org.apwtcl.lang.Token;
//import org.apwtcl.lang.Variable;

public class FileCommand extends Token {

  /* ==================== initSubCmds ================================== */
  public int initSubCmds(Interp interp) {
//print("file initSubCmds called"+interp+"!");
    interp.command_obj_type.registerNativeSubCommand("::file", "join", "FileCommand");

 *
 */

package org.apwtcl.lang.cmd;

import java.util.ArrayList;

//import org.apwtcl.lang.CallFrame;
//import org.apwtcl.lang.Command;
import org.apwtcl.lang.Interp;
import org.apwtcl.lang.ApwtclObj;
import org.apwtcl.lang.Token;

public class ForCommand extends Token {

  /* ==================== ForCommand ================================== */
  public ForCommand() {
  }

  /* ==================== forCmd ================================== */
  public int forCmd(Interp interp, ArrayList<ApwtclObj> args) {
//print("for called!"+args+"!");
    int retval;
    int bool = 1;
    ArrayList<Integer> bool_ptr = new ArrayList<Integer>();
    //ApwtclObj var_name_ptr = null;
    //ApwtclObj stop_var_name_ptr = null;
    boolean evalstart = false;
    boolean evalnext = false;
    boolean out = false;
    boolean testcond = false;

    if (args.size() != 5) {
      interp.wrongNumArgs(1, args, "start test next body");

              }
            }
          }
        }
      }
    }
    if (out) {
//      if (stop_var_name_ptr != null) {
//        stop_var_name_ptr.decrRefCount("D_PKG_CORE_CMD_3");
//      }
    }

//    if (var_name_ptr != null) {
//      var_name_ptr.decrRefCount("D_PKG_CORE_CMD_4");

//    }
    if (retval == CONTINUE || retval == BREAK || retval == OK) {
      interp.setEmptyResult();
      return OK;
    }
    return retval;
  }

}

package org.apwtcl.lang.cmd;

import java.util.ArrayList;
import org.apwtcl.lang.Interp;
import org.apwtcl.lang.ApwtclObj;
import org.apwtcl.lang.Token;
//import org.apwtcl.lang.Variable;

public class ForeachCommand extends Token {

  /* ==================== ForeachCommand ================================== */
  public ForeachCommand() {
  }

      ArrayList<Long> increment_ptr = new ArrayList<Long>();
      if (interp.int_obj_type.getWide(args.get(2), increment_ptr) != OK) {
        return ERROR;
      }
      increment = increment_ptr.get(0).intValue();
    }
    ArrayList<Variable> var_ptr_ptr = new ArrayList<Variable>();
    int_obj_ptr = interp.variable_obj_type.getVariable(args.get(1), FUNCTION_FLAGS_UNSHARED, var_ptr_ptr);
    if (int_obj_ptr == null) {
      /* Set missing variable to 0 */
      wide_value = 0;
    } else {
      ArrayList<Long> wide_value_ptr = new ArrayList<Long>();
      if (interp.int_obj_type.getWide(int_obj_ptr, wide_value_ptr) != OK) {
        return ERROR;

package org.apwtcl.lang.cmd;

import java.util.ArrayList;
import org.apwtcl.lang.Interp;
import org.apwtcl.lang.ApwtclObj;
import org.apwtcl.lang.InterpAlias;
import org.apwtcl.lang.Token;
//import org.apwtcl.lang.Variable;

public class InterpCommand extends Token {

  /* ==================== InterpCommand ================================== */
  public InterpCommand() {
  }

        }
      }
      interp.setResultString(result_str);
      return OK;
    }
    if (args.size() == 5) {
      /* seems to be the unset, so the argument has to be empty */
      // ApwtclObj arg3 = args.get(3);
      if (!src_path.getString().equals("")) {
        interp.setResultString("interp alias interp other current interp not yet implemented, src_path must be empty!");
        return ERROR;
      }
      if (src_path.getString().equals("")) {
//        src_path = interp;
      }

 *
 */

package org.apwtcl.lang.cmd;

import java.util.ArrayList;

//import org.apwtcl.lang.CallFrame;
//import org.apwtcl.lang.Command;
import org.apwtcl.lang.Interp;
import org.apwtcl.lang.ApwtclObj;
import org.apwtcl.lang.Token;

public class JavadebugCommand extends Token {

  /* ==================== JavadebugCommand ================================== */

    if (type.equals("expr_parser_debug")) {
//      interp.eval_statement.expr_parser_debug = val;
    }
    if (type.equals("class_command_debug")) {
//      this.class_command_debug = 1;
    }
print("javadebug set: "+type+"!"+val+"!");
    return OK;
  }

}

 *
 */

package org.apwtcl.lang.cmd;

import java.util.ArrayList;

//import org.apwtcl.lang.CallFrame;
//import org.apwtcl.lang.Command;
import org.apwtcl.lang.Interp;
import org.apwtcl.lang.ApwtclObj;
import org.apwtcl.lang.Token;

public class LinsertCommand extends Token {

  /* ==================== LinsertCommand ================================== */

  public LsetCommand() {
  }

  /* ==================== lsetCmd ================================== */
  public int lsetCmd(Interp interp, ArrayList<ApwtclObj> args) {
print("lset called!"+args+"!");
    interp.setResultString("lset not yet reimplemented");
    return ERROR;
  }

}

import org.apwtcl.lang.CallFrame;
import org.apwtcl.lang.Command;
import org.apwtcl.lang.CommandOptionList;
import org.apwtcl.lang.Interp;
import org.apwtcl.lang.ApwtclObj;
import org.apwtcl.lang.Namespace;
import org.apwtcl.lang.Token;
//import org.apwtcl.lang.Variable;

public class NamespaceCommand extends Token {
  public static CommandOptionList command_option_list;
  public static boolean initted = false;

  public static final int NAMESPACE_ENSEMBLE_OPTION_COMMAND = 1;
  public static final int NAMESPACE_ENSEMBLE_OPTION_MAP = 2;

    command_option_list.resetOptionValues();
    if (command_option_list.parseOptions(args, 1, "namespace ensemble create") != OK) {
      interp.setResultString(command_option_list.getErrorMsg());
      return ERROR;
    }
    int option_flags = command_option_list.getOptionFlags();
    //int num_processed_args = command_option_list.getNumProcessedArgs();

    if ((option_flags & NAMESPACE_ENSEMBLE_OPTION_MAP) != 0) {
      map_lst = command_option_list.getOptionValue(NAMESPACE_ENSEMBLE_OPTION_MAP);
      map_info = map_lst.get(0);
      map_len = interp.list_obj_type.listLength(map_info);
      if (map_len % 2 != 0) {
        interp.setResultString("option -map must have an even number of elements");

      return ERROR;
    }
    if (ens_cmd.ensemble == null) {
      interp.setResultString("'"+ensemble_ptr.getString()+"' is not an ensemble");
      return ERROR;
    }
    HashMap<String, Command> ens = ens_cmd.ensemble;
    // String cmd_name = ensemble_ptr.getString();
//    Ensemble ens = cmd.ensemble;
    ArrayList<ApwtclObj> map_lst = null;
    ApwtclObj map_info = null;
    ArrayList<ApwtclObj> parameters_lst = null;
    // ApwtclObj parameters_info = null;
    ArrayList<ApwtclObj> prefixes_lst = null;
    // ApwtclObj prefixes_info = null;
    ArrayList<ApwtclObj> subcommands_lst = null;
    // ApwtclObj subcommands_info = null;
    ArrayList<ApwtclObj> unknown_lst = null;
    // ApwtclObj unknown_info = null;
    //ArrayList<ApwtclObj> command_lst = null;
    //ApwtclObj command_info = null;
    StringBuffer result = new StringBuffer("");
    //String sep = "";

    command_option_list.resetOptionValues();
    ArrayList<ApwtclObj> my_args = new ArrayList<ApwtclObj>();
    for (int j = 1; j < args.size(); j++) {
       my_args.add(args.get(j));
    }
    if (command_option_list.parseOptions(my_args, 1, "namespace ensemble configure") != OK) {
      interp.setResultString(command_option_list.getErrorMsg());
      return ERROR;
    }
    int option_flags = command_option_list.getOptionFlags();
    // int num_processed_args = command_option_list.getNumProcessedArgs();

    if ((option_flags & NAMESPACE_ENSEMBLE_OPTION_MAP) != 0) {
      map_lst = command_option_list.getOptionValue(NAMESPACE_ENSEMBLE_OPTION_MAP);
      if (map_lst == null) {
//        result.append(sep+ens.get("map"));
        // sep = " ";
      } else {
//print("map_lst!"+map_lst+"!");
        map_info = map_lst.get(0);
        int map_len = interp.list_obj_type.listLength(map_info);
        if (map_len % 2 != 0) {
          interp.setResultString("option -map must have an even number of elements");
          return ERROR;

    }
//print("ENS!!"+ens+"!");
    if ((option_flags & NAMESPACE_ENSEMBLE_OPTION_PARAMETERS) != 0) {
      parameters_lst = command_option_list.getOptionValue(NAMESPACE_ENSEMBLE_OPTION_PARAMETERS);
//      parameters = .join(" ");
      if (parameters_lst == null) {
//        result.append(sep+ens.get("parameters"));
        // sep = " ";
      } else {
        /* FIXME need code here !!! */
        // parameters_info = parameters_lst.get(0);
        interp.setResultString("namespace ensemble configure -parameters not yet implemented");
        return ERROR;
      }
    }
    if ((option_flags & NAMESPACE_ENSEMBLE_OPTION_PREFIXES) != 0) {
      prefixes_lst = command_option_list.getOptionValue(NAMESPACE_ENSEMBLE_OPTION_PREFIXES);
//      parameters = .join(" ");
      if (prefixes_lst == null) {
//        result.append(ens.get("prefixes"));
        // sep = " ";
      } else {
        /* FIXME need code here !!! */
        //prefixes_info = prefixes_lst.get(0);
        interp.setResultString("namespace ensemble configure -prefixes not yet implemented");
        return ERROR;
      }
    }
    if ((option_flags & NAMESPACE_ENSEMBLE_OPTION_SUBCOMMANDS) != 0) {
      subcommands_lst = command_option_list.getOptionValue(NAMESPACE_ENSEMBLE_OPTION_SUBCOMMANDS);
//      parameters = .join(" ");
      if (subcommands_lst == null) {
//        result.append(sep+ens.get("subcommands");
//        .join(" ");
        // sep = " ";
      } else {
        /* FIXME need code here !!! */
        // subcommands_info = subcommands_lst.get(0);
        interp.setResultString("namespace ensemble configure -subcommands not yet implemented");
        return ERROR;
      }
    }
    if ((option_flags & NAMESPACE_ENSEMBLE_OPTION_UNKNOWN) != 0) {
      unknown_lst = command_option_list.getOptionValue(NAMESPACE_ENSEMBLE_OPTION_UNKNOWN);
//      parameters = .join(" ");
      if (unknown_lst == null) {
//        result.append(sep+ens.get("unknown");
//           .join(" ");
        // sep = " ";
      } else {
        /* FIXME need code here !!! */
        // unknown_info = unknown_lst.get(0);
        interp.setResultString("namespace ensemble configure -unknown not yet implemented");
        return ERROR;
      }
    }
    if ((option_flags & NAMESPACE_ENSEMBLE_OPTION_NAMESPACE) != 0) {
//      parameters = .join(" ");
//      result.append(sep+ens.get("command");
//      .join(" ");
      // sep = " ";
    }
    interp.setResultString(result.toString());
    return OK;
  }

  /* ==================== namespaceEnsembleExistsCmd =========================== */
  public int namespaceEnsembleExistsCmd(Interp interp, ArrayList<ApwtclObj> args) {
print("namespace ensemble exists called");
    interp.setResultString("namespace ensemble exists not yet reimplemented");
    return ERROR;
//    requireMinArgc(args, 0, "namespace exists", "");
//    var cmd = interp.global_ns_ptr.getCommand(interp, args[1].toString());
//    if (cmd != null) {
//      if (typeof cmd.ensemble != "undefined") {
//         return ERROR;
//      }
//    }
//    return OK;
  }

  /* ==================== namespaceEvalCmd =========================== */
  public int namespaceEvalCmd(Interp interp, ArrayList<ApwtclObj> args) {
//print("namespace eval called!"+args+"!");
  try {
	int result;
    // int word = 0;
    ApwtclObj obj_ptr;
    ArrayList<Namespace> namespace_ptr_ptr = new ArrayList<Namespace>();
    Namespace namespace_ptr = null;
    ArrayList<CallFrame> frame_ptr_ptr = null;

    if (args.size() < 3) {
      interp.wrongNumArgs(1, args, "name arg ?arg...?");

//    work = new Array();
    if (args.size() == 3) {
      /*
       * TIP #280: Make actual argument location available to eval'd script.
       */
      obj_ptr = args.get(2);
//      invoker = namesp.interp.cmd_frame_ptr;
      // word = 3;
//FIXME      argumentGet(objPtr, invoker, word);
    } else {
      /*
       * More than one argument: concatenate them together with spaces
       * between, then evaluate the result. evalObjEx will delete the
       * object when it decrements its refcount after eval'ing it.
       */
      ArrayList<ApwtclObj> my_args = new ArrayList<ApwtclObj>();
      for (int i = 2; i < args.size(); i++) {
         my_args.add(args.get(i));
      }
      obj_ptr = interp.default_obj.concatObj(args.size() - 2, my_args);
//      invoker = null;
      // word = 0;
    }
    /*
     * TIP #280: Make invoking context available to eval'd script.
     */
//    TclNRAddCallback(NsEval_Callback, namespacePtr, "eval", null, null);
//print("EV!"+obj_ptr.toDebugString()+"!"+invoker+"!"+word+"!");
// FIXME need to do TIP #280 code here !!!

  }
  }

  /* ==================== namespaceExistsCmd =========================== */
  public int namespaceExistsCmd(Interp interp, ArrayList<ApwtclObj> args) {
print("namespace exists called");
    interp.setResultString("namespace exists not yet reimplemented");
    return ERROR;
//    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");

 * Copyright 2012 Arnulf P. Wiedemann
 *
 */

package org.apwtcl.lang.cmd;

import java.util.ArrayList;

import org.apwtcl.lang.Interp;
import org.apwtcl.lang.ApwtclObj;
import org.apwtcl.lang.Token;
import org.apwtcl.lang.Variable;

public class SetCommand extends Token {

package org.apwtcl.lang.cmd;

import java.util.ArrayList;
import org.apwtcl.lang.Interp;
import org.apwtcl.lang.ApwtclObj;
import org.apwtcl.lang.Token;
//import org.apwtcl.lang.Variable;

public class SourceCommand extends Token {

  /* ==================== SourceCommand ================================== */
  public SourceCommand() {
  }

          };
          if (cmd_obj == null) {
            break;
          }
        }
      }
      object_namespace = interp.frame_ptr.ns_ptr;
//print("NS!"+object_namespace+"!"+escapeKey(ns_ptr.full_name)+"!");
      class_info = interp.classes.get(escapeKey(ns_ptr.full_name));
//print("object_namespace!"+object_namespace+"!"+class_info+"!"+ns_ptr.toDebugString()+"!");
      if (object_namespace.full_name.equals("::")) {
        if (!(cmd_name.charAt(0) == ':' && cmd_name.charAt(1) == ':')) {
          object_name = "::"+cmd_name;
        } else {
          object_name = cmd_name;

        dlg_info = class_ptr.delegated_methods.get(escapeKey(fcn_name));
        to_part = dlg_info.to_part.getString();
      }
      if (class_ptr.delegated_methods.get("*") != null) {
        dlg_info = class_ptr.delegated_methods.get("*");
        to_part = dlg_info.to_part.getString();
      }
//print("++++to_part!"+fcn_name+"!"+to_part+"!"+class_object.class_info+"!");
      if (to_part != null) {
        Variable var_ptr = class_object.variables.get(escapeKey(to_part));
//print("++++to_part2!"+var_ptr.obj_ptr.getString()+"!");
        ItclObject obj2 = interp.class_objects.get(escapeKey(var_ptr.obj_ptr.getString()));
        my_args = new ArrayList<ApwtclObj>();
        my_args.add(interp.string_obj_type.newStringObj(obj2.object_name, -1, "ITCL_OBJ_TYPE_4"));
        my_args.add(interp.string_obj_type.newStringObj(fcn_name, -1, "ITCL_OBJ_TYPE_5"));

  public int ptrObjMakeUpvar(Variable other_ptr, ApwtclObj my_name_ptr, int my_flags, int index) {
    CallFrame var_frame_ptr = interp.var_frame_ptr;
    ArrayList<String> err_msg = new ArrayList<String>();
    boolean p;
    String my_name;
    Variable var_ptr = null;

//print("ptrObjMakeUpvar!"+other_ptr.toDebugString()+"!"+index+"!"+my_name_ptr+"!");
    if (index >= 0) {
      if (!var_frame_ptr.hasLocalVars()) {
        panic(true, "ptrObjMakeUpvar called with an index outside from a proc");
      }
//      var_ptr = var_frame_ptr.compiled_locals.get(index); // ???
      my_name_ptr = localName(interp.var_frame_ptr, index);
      my_name = my_name_ptr != null ? my_name_ptr.getString() : null;

        ll2.add("VARNAME");
        ll2.add(my_name_ptr.getString());
        interp.setErrorCode(ll2);
//print("pOMU3!");
        return ERROR;
      }
    }
//print("LS!"+var_ptr.toDebugString()+"!"+other_ptr.toDebugString()+"!");
    if (var_ptr == other_ptr) {
      interp.setResult(interp.string_obj_type.newStringObj("can't upvar from variable to itself", -1, "VARIABLE_OBJ_TYPE_8"));
      ArrayList<String> ll3 = new ArrayList<String>();
      ll3.add("TCL");
      ll3.add("UPVAR");
      ll3.add("SELF");
      interp.setErrorCode(ll3);

    }
    /*
     * Check that we are not trying to create a namespace var linked to a
     * local variable in a procedure. If we allowed this, the local
     * variable in the shorter-lived procedure frame could go away leaving
     * the namespace var's reference invalid.
     */

    boolean b1 = (array_ptr != null
        ? (isVarInHash(array_ptr) && getVarNsPtr(array_ptr) != null)
        : (isVarInHash(other_ptr) && getVarNsPtr(other_ptr) != null));
    if (index < 0) {
      if (!b1
          && ((my_flags & (NAMESPACE_LOOKUP_GLOBAL_ONLY | NAMESPACE_LOOKUP_NAMESPACE_ONLY)) != 0)
          || (var_frame_ptr == null)
          || !var_frame_ptr.hasLocalVars()
          || (my_name_ptr.getString().indexOf("::") >= 0)) {
        interp.setResult(interp.string_obj_type.newStringObj("bad variable name \""+my_name_ptr.getString()+ "\": upvar won't create namespace variable that refers to procedure variable", -1, "VARIABLE_OBJ_TYPE_11"));
        ArrayList<String> ll = new ArrayList<String>();
        ll.add("TCL");

    }
    /*
     * If this namespace has a variable resolver, then give it first crack at
     * the variable resolution. It may return a Variable value, it may signal
     * to continue onward, or it may signal an error.
     */
if (variable_debug > 0) {
print("NS!"+ctx_ns_ptr.full_name+"!variable_resolver!"+ctx_ns_ptr.variable_resolver+"!");
}
    if ((ctx_ns_ptr.variable_resolver != null || interp.variable_resolver != null)
        && ((flags & VAR_LOOKUP_AVOID_RESOLVERS) == 0)) {
      res_ptr = interp.variable_resolver;
      if (ctx_ns_ptr.variable_resolver != null) {
        result = ctx_ns_ptr.variable_resolver.resolveVariable(var_name, ctx_ns_ptr, flags, var_obj_ptr);
        var_obj = (Variable)var_obj_ptr.get(0);